mirror of
https://github.com/genuinetools/reg.git
synced 2024-09-19 16:51:01 -04:00
1985 lines
53 KiB
Go
1985 lines
53 KiB
Go
|
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
||
|
// source: combos/both/types.proto
|
||
|
|
||
|
/*
|
||
|
Package types is a generated protocol buffer package.
|
||
|
|
||
|
It is generated from these files:
|
||
|
combos/both/types.proto
|
||
|
|
||
|
It has these top-level messages:
|
||
|
KnownTypes
|
||
|
ProtoTypes
|
||
|
StdTypes
|
||
|
RepProtoTypes
|
||
|
RepStdTypes
|
||
|
MapProtoTypes
|
||
|
MapStdTypes
|
||
|
OneofProtoTypes
|
||
|
OneofStdTypes
|
||
|
*/
|
||
|
package types
|
||
|
|
||
|
import testing "testing"
|
||
|
import rand "math/rand"
|
||
|
import time "time"
|
||
|
import proto "github.com/gogo/protobuf/proto"
|
||
|
import jsonpb "github.com/gogo/protobuf/jsonpb"
|
||
|
import fmt "fmt"
|
||
|
import math "math"
|
||
|
import _ "github.com/gogo/protobuf/gogoproto"
|
||
|
import _ "github.com/gogo/protobuf/types"
|
||
|
import _ "github.com/gogo/protobuf/types"
|
||
|
import _ "github.com/gogo/protobuf/types"
|
||
|
|
||
|
// Reference imports to suppress errors if they are not otherwise used.
|
||
|
var _ = proto.Marshal
|
||
|
var _ = fmt.Errorf
|
||
|
var _ = math.Inf
|
||
|
|
||
|
func TestKnownTypesProto(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedKnownTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &KnownTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
littlefuzz := make([]byte, len(dAtA))
|
||
|
copy(littlefuzz, dAtA)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
if len(littlefuzz) > 0 {
|
||
|
fuzzamount := 100
|
||
|
for i := 0; i < fuzzamount; i++ {
|
||
|
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
|
||
|
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
|
||
|
}
|
||
|
// shouldn't panic
|
||
|
_ = proto.Unmarshal(littlefuzz, msg)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestKnownTypesMarshalTo(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedKnownTypes(popr, false)
|
||
|
size := p.Size()
|
||
|
dAtA := make([]byte, size)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
_, err := p.MarshalTo(dAtA)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &KnownTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkKnownTypesProtoMarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*KnownTypes, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
pops[i] = NewPopulatedKnownTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
dAtA, err := proto.Marshal(pops[i%10000])
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
total += len(dAtA)
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func BenchmarkKnownTypesProtoUnmarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
datas := make([][]byte, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
dAtA, err := proto.Marshal(NewPopulatedKnownTypes(popr, false))
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
datas[i] = dAtA
|
||
|
}
|
||
|
msg := &KnownTypes{}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += len(datas[i%10000])
|
||
|
if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestProtoTypesProto(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedProtoTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &ProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
littlefuzz := make([]byte, len(dAtA))
|
||
|
copy(littlefuzz, dAtA)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
if len(littlefuzz) > 0 {
|
||
|
fuzzamount := 100
|
||
|
for i := 0; i < fuzzamount; i++ {
|
||
|
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
|
||
|
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
|
||
|
}
|
||
|
// shouldn't panic
|
||
|
_ = proto.Unmarshal(littlefuzz, msg)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestProtoTypesMarshalTo(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedProtoTypes(popr, false)
|
||
|
size := p.Size()
|
||
|
dAtA := make([]byte, size)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
_, err := p.MarshalTo(dAtA)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &ProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkProtoTypesProtoMarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*ProtoTypes, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
pops[i] = NewPopulatedProtoTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
dAtA, err := proto.Marshal(pops[i%10000])
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
total += len(dAtA)
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func BenchmarkProtoTypesProtoUnmarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
datas := make([][]byte, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
dAtA, err := proto.Marshal(NewPopulatedProtoTypes(popr, false))
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
datas[i] = dAtA
|
||
|
}
|
||
|
msg := &ProtoTypes{}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += len(datas[i%10000])
|
||
|
if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestStdTypesProto(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedStdTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &StdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
littlefuzz := make([]byte, len(dAtA))
|
||
|
copy(littlefuzz, dAtA)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
if len(littlefuzz) > 0 {
|
||
|
fuzzamount := 100
|
||
|
for i := 0; i < fuzzamount; i++ {
|
||
|
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
|
||
|
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
|
||
|
}
|
||
|
// shouldn't panic
|
||
|
_ = proto.Unmarshal(littlefuzz, msg)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestStdTypesMarshalTo(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedStdTypes(popr, false)
|
||
|
size := p.Size()
|
||
|
dAtA := make([]byte, size)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
_, err := p.MarshalTo(dAtA)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &StdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkStdTypesProtoMarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*StdTypes, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
pops[i] = NewPopulatedStdTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
dAtA, err := proto.Marshal(pops[i%10000])
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
total += len(dAtA)
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func BenchmarkStdTypesProtoUnmarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
datas := make([][]byte, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
dAtA, err := proto.Marshal(NewPopulatedStdTypes(popr, false))
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
datas[i] = dAtA
|
||
|
}
|
||
|
msg := &StdTypes{}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += len(datas[i%10000])
|
||
|
if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestRepProtoTypesProto(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepProtoTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &RepProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
littlefuzz := make([]byte, len(dAtA))
|
||
|
copy(littlefuzz, dAtA)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
if len(littlefuzz) > 0 {
|
||
|
fuzzamount := 100
|
||
|
for i := 0; i < fuzzamount; i++ {
|
||
|
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
|
||
|
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
|
||
|
}
|
||
|
// shouldn't panic
|
||
|
_ = proto.Unmarshal(littlefuzz, msg)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestRepProtoTypesMarshalTo(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepProtoTypes(popr, false)
|
||
|
size := p.Size()
|
||
|
dAtA := make([]byte, size)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
_, err := p.MarshalTo(dAtA)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &RepProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkRepProtoTypesProtoMarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*RepProtoTypes, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
pops[i] = NewPopulatedRepProtoTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
dAtA, err := proto.Marshal(pops[i%10000])
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
total += len(dAtA)
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func BenchmarkRepProtoTypesProtoUnmarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
datas := make([][]byte, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
dAtA, err := proto.Marshal(NewPopulatedRepProtoTypes(popr, false))
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
datas[i] = dAtA
|
||
|
}
|
||
|
msg := &RepProtoTypes{}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += len(datas[i%10000])
|
||
|
if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestRepStdTypesProto(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepStdTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &RepStdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
littlefuzz := make([]byte, len(dAtA))
|
||
|
copy(littlefuzz, dAtA)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
if len(littlefuzz) > 0 {
|
||
|
fuzzamount := 100
|
||
|
for i := 0; i < fuzzamount; i++ {
|
||
|
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
|
||
|
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
|
||
|
}
|
||
|
// shouldn't panic
|
||
|
_ = proto.Unmarshal(littlefuzz, msg)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestRepStdTypesMarshalTo(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepStdTypes(popr, false)
|
||
|
size := p.Size()
|
||
|
dAtA := make([]byte, size)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
_, err := p.MarshalTo(dAtA)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &RepStdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkRepStdTypesProtoMarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*RepStdTypes, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
pops[i] = NewPopulatedRepStdTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
dAtA, err := proto.Marshal(pops[i%10000])
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
total += len(dAtA)
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func BenchmarkRepStdTypesProtoUnmarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
datas := make([][]byte, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
dAtA, err := proto.Marshal(NewPopulatedRepStdTypes(popr, false))
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
datas[i] = dAtA
|
||
|
}
|
||
|
msg := &RepStdTypes{}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += len(datas[i%10000])
|
||
|
if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestMapProtoTypesProto(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapProtoTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &MapProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
littlefuzz := make([]byte, len(dAtA))
|
||
|
copy(littlefuzz, dAtA)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
if len(littlefuzz) > 0 {
|
||
|
fuzzamount := 100
|
||
|
for i := 0; i < fuzzamount; i++ {
|
||
|
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
|
||
|
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
|
||
|
}
|
||
|
// shouldn't panic
|
||
|
_ = proto.Unmarshal(littlefuzz, msg)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestMapProtoTypesMarshalTo(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapProtoTypes(popr, false)
|
||
|
size := p.Size()
|
||
|
dAtA := make([]byte, size)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
_, err := p.MarshalTo(dAtA)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &MapProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkMapProtoTypesProtoMarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*MapProtoTypes, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
pops[i] = NewPopulatedMapProtoTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
dAtA, err := proto.Marshal(pops[i%10000])
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
total += len(dAtA)
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func BenchmarkMapProtoTypesProtoUnmarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
datas := make([][]byte, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
dAtA, err := proto.Marshal(NewPopulatedMapProtoTypes(popr, false))
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
datas[i] = dAtA
|
||
|
}
|
||
|
msg := &MapProtoTypes{}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += len(datas[i%10000])
|
||
|
if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestMapStdTypesProto(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapStdTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &MapStdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
littlefuzz := make([]byte, len(dAtA))
|
||
|
copy(littlefuzz, dAtA)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
if len(littlefuzz) > 0 {
|
||
|
fuzzamount := 100
|
||
|
for i := 0; i < fuzzamount; i++ {
|
||
|
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
|
||
|
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
|
||
|
}
|
||
|
// shouldn't panic
|
||
|
_ = proto.Unmarshal(littlefuzz, msg)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestMapStdTypesMarshalTo(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapStdTypes(popr, false)
|
||
|
size := p.Size()
|
||
|
dAtA := make([]byte, size)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
_, err := p.MarshalTo(dAtA)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &MapStdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkMapStdTypesProtoMarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*MapStdTypes, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
pops[i] = NewPopulatedMapStdTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
dAtA, err := proto.Marshal(pops[i%10000])
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
total += len(dAtA)
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func BenchmarkMapStdTypesProtoUnmarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
datas := make([][]byte, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
dAtA, err := proto.Marshal(NewPopulatedMapStdTypes(popr, false))
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
datas[i] = dAtA
|
||
|
}
|
||
|
msg := &MapStdTypes{}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += len(datas[i%10000])
|
||
|
if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestOneofProtoTypesProto(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofProtoTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &OneofProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
littlefuzz := make([]byte, len(dAtA))
|
||
|
copy(littlefuzz, dAtA)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
if len(littlefuzz) > 0 {
|
||
|
fuzzamount := 100
|
||
|
for i := 0; i < fuzzamount; i++ {
|
||
|
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
|
||
|
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
|
||
|
}
|
||
|
// shouldn't panic
|
||
|
_ = proto.Unmarshal(littlefuzz, msg)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestOneofProtoTypesMarshalTo(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofProtoTypes(popr, false)
|
||
|
size := p.Size()
|
||
|
dAtA := make([]byte, size)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
_, err := p.MarshalTo(dAtA)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &OneofProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkOneofProtoTypesProtoMarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*OneofProtoTypes, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
pops[i] = NewPopulatedOneofProtoTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
dAtA, err := proto.Marshal(pops[i%10000])
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
total += len(dAtA)
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func BenchmarkOneofProtoTypesProtoUnmarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
datas := make([][]byte, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
dAtA, err := proto.Marshal(NewPopulatedOneofProtoTypes(popr, false))
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
datas[i] = dAtA
|
||
|
}
|
||
|
msg := &OneofProtoTypes{}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += len(datas[i%10000])
|
||
|
if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestOneofStdTypesProto(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofStdTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &OneofStdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
littlefuzz := make([]byte, len(dAtA))
|
||
|
copy(littlefuzz, dAtA)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
if len(littlefuzz) > 0 {
|
||
|
fuzzamount := 100
|
||
|
for i := 0; i < fuzzamount; i++ {
|
||
|
littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
|
||
|
littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
|
||
|
}
|
||
|
// shouldn't panic
|
||
|
_ = proto.Unmarshal(littlefuzz, msg)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestOneofStdTypesMarshalTo(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofStdTypes(popr, false)
|
||
|
size := p.Size()
|
||
|
dAtA := make([]byte, size)
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
_, err := p.MarshalTo(dAtA)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &OneofStdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
for i := range dAtA {
|
||
|
dAtA[i] = byte(popr.Intn(256))
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkOneofStdTypesProtoMarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*OneofStdTypes, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
pops[i] = NewPopulatedOneofStdTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
dAtA, err := proto.Marshal(pops[i%10000])
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
total += len(dAtA)
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func BenchmarkOneofStdTypesProtoUnmarshal(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
datas := make([][]byte, 10000)
|
||
|
for i := 0; i < 10000; i++ {
|
||
|
dAtA, err := proto.Marshal(NewPopulatedOneofStdTypes(popr, false))
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
datas[i] = dAtA
|
||
|
}
|
||
|
msg := &OneofStdTypes{}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += len(datas[i%10000])
|
||
|
if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestKnownTypesJSON(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedKnownTypes(popr, true)
|
||
|
marshaler := jsonpb.Marshaler{}
|
||
|
jsondata, err := marshaler.MarshalToString(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &KnownTypes{}
|
||
|
err = jsonpb.UnmarshalString(jsondata, msg)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
func TestProtoTypesJSON(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedProtoTypes(popr, true)
|
||
|
marshaler := jsonpb.Marshaler{}
|
||
|
jsondata, err := marshaler.MarshalToString(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &ProtoTypes{}
|
||
|
err = jsonpb.UnmarshalString(jsondata, msg)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
func TestStdTypesJSON(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedStdTypes(popr, true)
|
||
|
marshaler := jsonpb.Marshaler{}
|
||
|
jsondata, err := marshaler.MarshalToString(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &StdTypes{}
|
||
|
err = jsonpb.UnmarshalString(jsondata, msg)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
func TestRepProtoTypesJSON(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepProtoTypes(popr, true)
|
||
|
marshaler := jsonpb.Marshaler{}
|
||
|
jsondata, err := marshaler.MarshalToString(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &RepProtoTypes{}
|
||
|
err = jsonpb.UnmarshalString(jsondata, msg)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
func TestRepStdTypesJSON(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepStdTypes(popr, true)
|
||
|
marshaler := jsonpb.Marshaler{}
|
||
|
jsondata, err := marshaler.MarshalToString(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &RepStdTypes{}
|
||
|
err = jsonpb.UnmarshalString(jsondata, msg)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
func TestMapProtoTypesJSON(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapProtoTypes(popr, true)
|
||
|
marshaler := jsonpb.Marshaler{}
|
||
|
jsondata, err := marshaler.MarshalToString(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &MapProtoTypes{}
|
||
|
err = jsonpb.UnmarshalString(jsondata, msg)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
func TestMapStdTypesJSON(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapStdTypes(popr, true)
|
||
|
marshaler := jsonpb.Marshaler{}
|
||
|
jsondata, err := marshaler.MarshalToString(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &MapStdTypes{}
|
||
|
err = jsonpb.UnmarshalString(jsondata, msg)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
func TestOneofProtoTypesJSON(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofProtoTypes(popr, true)
|
||
|
marshaler := jsonpb.Marshaler{}
|
||
|
jsondata, err := marshaler.MarshalToString(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &OneofProtoTypes{}
|
||
|
err = jsonpb.UnmarshalString(jsondata, msg)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
func TestOneofStdTypesJSON(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofStdTypes(popr, true)
|
||
|
marshaler := jsonpb.Marshaler{}
|
||
|
jsondata, err := marshaler.MarshalToString(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
msg := &OneofStdTypes{}
|
||
|
err = jsonpb.UnmarshalString(jsondata, msg)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
func TestKnownTypesProtoText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedKnownTypes(popr, true)
|
||
|
dAtA := proto.MarshalTextString(p)
|
||
|
msg := &KnownTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestKnownTypesProtoCompactText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedKnownTypes(popr, true)
|
||
|
dAtA := proto.CompactTextString(p)
|
||
|
msg := &KnownTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestProtoTypesProtoText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedProtoTypes(popr, true)
|
||
|
dAtA := proto.MarshalTextString(p)
|
||
|
msg := &ProtoTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestProtoTypesProtoCompactText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedProtoTypes(popr, true)
|
||
|
dAtA := proto.CompactTextString(p)
|
||
|
msg := &ProtoTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestStdTypesProtoText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedStdTypes(popr, true)
|
||
|
dAtA := proto.MarshalTextString(p)
|
||
|
msg := &StdTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestStdTypesProtoCompactText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedStdTypes(popr, true)
|
||
|
dAtA := proto.CompactTextString(p)
|
||
|
msg := &StdTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestRepProtoTypesProtoText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepProtoTypes(popr, true)
|
||
|
dAtA := proto.MarshalTextString(p)
|
||
|
msg := &RepProtoTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestRepProtoTypesProtoCompactText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepProtoTypes(popr, true)
|
||
|
dAtA := proto.CompactTextString(p)
|
||
|
msg := &RepProtoTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestRepStdTypesProtoText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepStdTypes(popr, true)
|
||
|
dAtA := proto.MarshalTextString(p)
|
||
|
msg := &RepStdTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestRepStdTypesProtoCompactText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepStdTypes(popr, true)
|
||
|
dAtA := proto.CompactTextString(p)
|
||
|
msg := &RepStdTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestMapProtoTypesProtoText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapProtoTypes(popr, true)
|
||
|
dAtA := proto.MarshalTextString(p)
|
||
|
msg := &MapProtoTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestMapProtoTypesProtoCompactText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapProtoTypes(popr, true)
|
||
|
dAtA := proto.CompactTextString(p)
|
||
|
msg := &MapProtoTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestMapStdTypesProtoText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapStdTypes(popr, true)
|
||
|
dAtA := proto.MarshalTextString(p)
|
||
|
msg := &MapStdTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestMapStdTypesProtoCompactText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapStdTypes(popr, true)
|
||
|
dAtA := proto.CompactTextString(p)
|
||
|
msg := &MapStdTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestOneofProtoTypesProtoText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofProtoTypes(popr, true)
|
||
|
dAtA := proto.MarshalTextString(p)
|
||
|
msg := &OneofProtoTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestOneofProtoTypesProtoCompactText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofProtoTypes(popr, true)
|
||
|
dAtA := proto.CompactTextString(p)
|
||
|
msg := &OneofProtoTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestOneofStdTypesProtoText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofStdTypes(popr, true)
|
||
|
dAtA := proto.MarshalTextString(p)
|
||
|
msg := &OneofStdTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestOneofStdTypesProtoCompactText(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofStdTypes(popr, true)
|
||
|
dAtA := proto.CompactTextString(p)
|
||
|
msg := &OneofStdTypes{}
|
||
|
if err := proto.UnmarshalText(dAtA, msg); err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
|
||
|
}
|
||
|
if !p.Equal(msg) {
|
||
|
t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestKnownTypesCompare(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedKnownTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &KnownTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if c := p.Compare(msg); c != 0 {
|
||
|
t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
|
||
|
}
|
||
|
p2 := NewPopulatedKnownTypes(popr, false)
|
||
|
c := p.Compare(p2)
|
||
|
c2 := p2.Compare(p)
|
||
|
if c != (-1 * c2) {
|
||
|
t.Errorf("p.Compare(p2) = %d", c)
|
||
|
t.Errorf("p2.Compare(p) = %d", c2)
|
||
|
t.Errorf("p = %#v", p)
|
||
|
t.Errorf("p2 = %#v", p2)
|
||
|
}
|
||
|
}
|
||
|
func TestProtoTypesCompare(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedProtoTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &ProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if c := p.Compare(msg); c != 0 {
|
||
|
t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
|
||
|
}
|
||
|
p2 := NewPopulatedProtoTypes(popr, false)
|
||
|
c := p.Compare(p2)
|
||
|
c2 := p2.Compare(p)
|
||
|
if c != (-1 * c2) {
|
||
|
t.Errorf("p.Compare(p2) = %d", c)
|
||
|
t.Errorf("p2.Compare(p) = %d", c2)
|
||
|
t.Errorf("p = %#v", p)
|
||
|
t.Errorf("p2 = %#v", p2)
|
||
|
}
|
||
|
}
|
||
|
func TestRepProtoTypesCompare(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedRepProtoTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &RepProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if c := p.Compare(msg); c != 0 {
|
||
|
t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
|
||
|
}
|
||
|
p2 := NewPopulatedRepProtoTypes(popr, false)
|
||
|
c := p.Compare(p2)
|
||
|
c2 := p2.Compare(p)
|
||
|
if c != (-1 * c2) {
|
||
|
t.Errorf("p.Compare(p2) = %d", c)
|
||
|
t.Errorf("p2.Compare(p) = %d", c2)
|
||
|
t.Errorf("p = %#v", p)
|
||
|
t.Errorf("p2 = %#v", p2)
|
||
|
}
|
||
|
}
|
||
|
func TestKnownTypesVerboseEqual(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedKnownTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &KnownTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
|
||
|
}
|
||
|
}
|
||
|
func TestProtoTypesVerboseEqual(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedProtoTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &ProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
|
||
|
}
|
||
|
}
|
||
|
func TestStdTypesVerboseEqual(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedStdTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &StdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
|
||
|
}
|
||
|
}
|
||
|
func TestRepProtoTypesVerboseEqual(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedRepProtoTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &RepProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
|
||
|
}
|
||
|
}
|
||
|
func TestRepStdTypesVerboseEqual(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedRepStdTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &RepStdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
|
||
|
}
|
||
|
}
|
||
|
func TestMapProtoTypesVerboseEqual(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedMapProtoTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &MapProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
|
||
|
}
|
||
|
}
|
||
|
func TestMapStdTypesVerboseEqual(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedMapStdTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &MapStdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
|
||
|
}
|
||
|
}
|
||
|
func TestOneofProtoTypesVerboseEqual(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedOneofProtoTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &OneofProtoTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
|
||
|
}
|
||
|
}
|
||
|
func TestOneofStdTypesVerboseEqual(t *testing.T) {
|
||
|
popr := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
p := NewPopulatedOneofStdTypes(popr, false)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
msg := &OneofStdTypes{}
|
||
|
if err := proto.Unmarshal(dAtA, msg); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
if err := p.VerboseEqual(msg); err != nil {
|
||
|
t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
|
||
|
}
|
||
|
}
|
||
|
func TestKnownTypesSize(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedKnownTypes(popr, true)
|
||
|
size2 := proto.Size(p)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
size := p.Size()
|
||
|
if len(dAtA) != size {
|
||
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
||
|
}
|
||
|
if size2 != size {
|
||
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
||
|
}
|
||
|
size3 := proto.Size(p)
|
||
|
if size3 != size {
|
||
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkKnownTypesSize(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*KnownTypes, 1000)
|
||
|
for i := 0; i < 1000; i++ {
|
||
|
pops[i] = NewPopulatedKnownTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += pops[i%1000].Size()
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestProtoTypesSize(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedProtoTypes(popr, true)
|
||
|
size2 := proto.Size(p)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
size := p.Size()
|
||
|
if len(dAtA) != size {
|
||
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
||
|
}
|
||
|
if size2 != size {
|
||
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
||
|
}
|
||
|
size3 := proto.Size(p)
|
||
|
if size3 != size {
|
||
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkProtoTypesSize(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*ProtoTypes, 1000)
|
||
|
for i := 0; i < 1000; i++ {
|
||
|
pops[i] = NewPopulatedProtoTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += pops[i%1000].Size()
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestStdTypesSize(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedStdTypes(popr, true)
|
||
|
size2 := proto.Size(p)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
size := p.Size()
|
||
|
if len(dAtA) != size {
|
||
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
||
|
}
|
||
|
if size2 != size {
|
||
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
||
|
}
|
||
|
size3 := proto.Size(p)
|
||
|
if size3 != size {
|
||
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkStdTypesSize(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*StdTypes, 1000)
|
||
|
for i := 0; i < 1000; i++ {
|
||
|
pops[i] = NewPopulatedStdTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += pops[i%1000].Size()
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestRepProtoTypesSize(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepProtoTypes(popr, true)
|
||
|
size2 := proto.Size(p)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
size := p.Size()
|
||
|
if len(dAtA) != size {
|
||
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
||
|
}
|
||
|
if size2 != size {
|
||
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
||
|
}
|
||
|
size3 := proto.Size(p)
|
||
|
if size3 != size {
|
||
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkRepProtoTypesSize(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*RepProtoTypes, 1000)
|
||
|
for i := 0; i < 1000; i++ {
|
||
|
pops[i] = NewPopulatedRepProtoTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += pops[i%1000].Size()
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestRepStdTypesSize(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedRepStdTypes(popr, true)
|
||
|
size2 := proto.Size(p)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
size := p.Size()
|
||
|
if len(dAtA) != size {
|
||
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
||
|
}
|
||
|
if size2 != size {
|
||
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
||
|
}
|
||
|
size3 := proto.Size(p)
|
||
|
if size3 != size {
|
||
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkRepStdTypesSize(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*RepStdTypes, 1000)
|
||
|
for i := 0; i < 1000; i++ {
|
||
|
pops[i] = NewPopulatedRepStdTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += pops[i%1000].Size()
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestMapProtoTypesSize(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapProtoTypes(popr, true)
|
||
|
size2 := proto.Size(p)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
size := p.Size()
|
||
|
if len(dAtA) != size {
|
||
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
||
|
}
|
||
|
if size2 != size {
|
||
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
||
|
}
|
||
|
size3 := proto.Size(p)
|
||
|
if size3 != size {
|
||
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkMapProtoTypesSize(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*MapProtoTypes, 1000)
|
||
|
for i := 0; i < 1000; i++ {
|
||
|
pops[i] = NewPopulatedMapProtoTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += pops[i%1000].Size()
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestMapStdTypesSize(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedMapStdTypes(popr, true)
|
||
|
size2 := proto.Size(p)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
size := p.Size()
|
||
|
if len(dAtA) != size {
|
||
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
||
|
}
|
||
|
if size2 != size {
|
||
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
||
|
}
|
||
|
size3 := proto.Size(p)
|
||
|
if size3 != size {
|
||
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkMapStdTypesSize(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*MapStdTypes, 1000)
|
||
|
for i := 0; i < 1000; i++ {
|
||
|
pops[i] = NewPopulatedMapStdTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += pops[i%1000].Size()
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestOneofProtoTypesSize(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofProtoTypes(popr, true)
|
||
|
size2 := proto.Size(p)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
size := p.Size()
|
||
|
if len(dAtA) != size {
|
||
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
||
|
}
|
||
|
if size2 != size {
|
||
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
||
|
}
|
||
|
size3 := proto.Size(p)
|
||
|
if size3 != size {
|
||
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkOneofProtoTypesSize(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*OneofProtoTypes, 1000)
|
||
|
for i := 0; i < 1000; i++ {
|
||
|
pops[i] = NewPopulatedOneofProtoTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += pops[i%1000].Size()
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
func TestOneofStdTypesSize(t *testing.T) {
|
||
|
seed := time.Now().UnixNano()
|
||
|
popr := rand.New(rand.NewSource(seed))
|
||
|
p := NewPopulatedOneofStdTypes(popr, true)
|
||
|
size2 := proto.Size(p)
|
||
|
dAtA, err := proto.Marshal(p)
|
||
|
if err != nil {
|
||
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
||
|
}
|
||
|
size := p.Size()
|
||
|
if len(dAtA) != size {
|
||
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
||
|
}
|
||
|
if size2 != size {
|
||
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
||
|
}
|
||
|
size3 := proto.Size(p)
|
||
|
if size3 != size {
|
||
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func BenchmarkOneofStdTypesSize(b *testing.B) {
|
||
|
popr := rand.New(rand.NewSource(616))
|
||
|
total := 0
|
||
|
pops := make([]*OneofStdTypes, 1000)
|
||
|
for i := 0; i < 1000; i++ {
|
||
|
pops[i] = NewPopulatedOneofStdTypes(popr, false)
|
||
|
}
|
||
|
b.ResetTimer()
|
||
|
for i := 0; i < b.N; i++ {
|
||
|
total += pops[i%1000].Size()
|
||
|
}
|
||
|
b.SetBytes(int64(total / b.N))
|
||
|
}
|
||
|
|
||
|
//These tests are generated by github.com/gogo/protobuf/plugin/testgen
|