You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4988 lines
151 KiB
4988 lines
151 KiB
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
|
// source: abci/types/types.proto
|
|
|
|
package types
|
|
|
|
import (
|
|
fmt "fmt"
|
|
_ "github.com/gogo/protobuf/gogoproto"
|
|
github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
|
|
github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
|
|
proto "github.com/gogo/protobuf/proto"
|
|
golang_proto "github.com/golang/protobuf/proto"
|
|
_ "github.com/golang/protobuf/ptypes/timestamp"
|
|
_ "github.com/tendermint/tendermint/crypto/merkle"
|
|
_ "github.com/tendermint/tendermint/libs/kv"
|
|
math "math"
|
|
math_rand "math/rand"
|
|
testing "testing"
|
|
time "time"
|
|
)
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = golang_proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
|
|
func TestRequestProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequest(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Request{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequest(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Request{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestEchoProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEcho(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestEcho{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestEchoMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEcho(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestEcho{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestFlushProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestFlush(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestFlush{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestFlushMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestFlush(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestFlush{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestInfoProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInfo(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestInfo{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestInfoMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInfo(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestInfo{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestSetOptionProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestSetOption(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestSetOption{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestSetOptionMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestSetOption(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestSetOption{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestInitChainProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInitChain(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestInitChain{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestInitChainMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInitChain(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestInitChain{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestQueryProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestQuery(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestQuery{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestQueryMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestQuery(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestQuery{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestBeginBlockProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestBeginBlock(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestBeginBlock{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestBeginBlockMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestBeginBlock(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestBeginBlock{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestCheckTxProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCheckTx(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestCheckTx{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestCheckTxMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCheckTx(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestCheckTx{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestDeliverTxProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestDeliverTx(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestDeliverTx{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestDeliverTxMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestDeliverTx(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestDeliverTx{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestEndBlockProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEndBlock(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestEndBlock{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestEndBlockMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEndBlock(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestEndBlock{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestCommitProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCommit(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestCommit{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestRequestCommitMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCommit(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestCommit{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponse(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Response{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponse(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Response{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseExceptionProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseException(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseException{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseExceptionMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseException(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseException{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseEchoProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEcho(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseEcho{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseEchoMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEcho(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseEcho{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseFlushProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseFlush(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseFlush{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseFlushMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseFlush(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseFlush{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseInfoProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInfo(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseInfo{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseInfoMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInfo(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseInfo{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseSetOptionProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseSetOption(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseSetOption{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseSetOptionMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseSetOption(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseSetOption{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseInitChainProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInitChain(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseInitChain{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseInitChainMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInitChain(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseInitChain{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseQueryProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseQuery(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseQuery{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseQueryMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseQuery(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseQuery{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseBeginBlockProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseBeginBlock(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseBeginBlock{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseBeginBlockMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseBeginBlock(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseBeginBlock{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseCheckTxProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCheckTx(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseCheckTx{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseCheckTxMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCheckTx(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseCheckTx{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseDeliverTxProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseDeliverTx(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseDeliverTx{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseDeliverTxMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseDeliverTx(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseDeliverTx{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseEndBlockProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEndBlock(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseEndBlock{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseEndBlockMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEndBlock(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseEndBlock{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestResponseCommitProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCommit(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseCommit{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestResponseCommitMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCommit(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseCommit{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestConsensusParamsProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedConsensusParams(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ConsensusParams{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestConsensusParamsMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedConsensusParams(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ConsensusParams{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestBlockParamsProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockParams(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &BlockParams{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestBlockParamsMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockParams(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &BlockParams{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestEvidenceParamsProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidenceParams(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &EvidenceParams{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestEvidenceParamsMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidenceParams(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &EvidenceParams{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestValidatorParamsProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorParams(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ValidatorParams{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestValidatorParamsMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorParams(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ValidatorParams{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestLastCommitInfoProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedLastCommitInfo(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &LastCommitInfo{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestLastCommitInfoMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedLastCommitInfo(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &LastCommitInfo{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestEventProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvent(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Event{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestEventMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvent(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Event{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestHeaderProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedHeader(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Header{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestHeaderMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedHeader(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Header{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestVersionProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVersion(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Version{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestVersionMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVersion(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Version{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestBlockIDProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockID(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &BlockID{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestBlockIDMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockID(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &BlockID{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestPartSetHeaderProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPartSetHeader(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &PartSetHeader{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestPartSetHeaderMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPartSetHeader(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &PartSetHeader{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestValidatorProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidator(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Validator{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestValidatorMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidator(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Validator{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestValidatorUpdateProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorUpdate(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ValidatorUpdate{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestValidatorUpdateMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorUpdate(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ValidatorUpdate{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestVoteInfoProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVoteInfo(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &VoteInfo{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestVoteInfoMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVoteInfo(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &VoteInfo{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestPubKeyProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPubKey(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &PubKey{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestPubKeyMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPubKey(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &PubKey{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestEvidenceProto(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidence(popr, false)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Evidence{}
|
|
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
|
|
t.Fatalf("seed = %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 TestEvidenceMarshalTo(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidence(popr, false)
|
|
size := p.Size()
|
|
dAtA := make([]byte, size)
|
|
for i := range dAtA {
|
|
dAtA[i] = byte(popr.Intn(256))
|
|
}
|
|
_, err := p.MarshalTo(dAtA)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Evidence{}
|
|
if err := github_com_gogo_protobuf_proto.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 TestRequestJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequest(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Request{}
|
|
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 TestRequestEchoJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEcho(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestEcho{}
|
|
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 TestRequestFlushJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestFlush(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestFlush{}
|
|
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 TestRequestInfoJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInfo(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestInfo{}
|
|
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 TestRequestSetOptionJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestSetOption(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestSetOption{}
|
|
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 TestRequestInitChainJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInitChain(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestInitChain{}
|
|
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 TestRequestQueryJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestQuery(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestQuery{}
|
|
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 TestRequestBeginBlockJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestBeginBlock(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestBeginBlock{}
|
|
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 TestRequestCheckTxJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCheckTx(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestCheckTx{}
|
|
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 TestRequestDeliverTxJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestDeliverTx(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestDeliverTx{}
|
|
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 TestRequestEndBlockJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEndBlock(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestEndBlock{}
|
|
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 TestRequestCommitJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCommit(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &RequestCommit{}
|
|
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 TestResponseJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponse(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Response{}
|
|
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 TestResponseExceptionJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseException(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseException{}
|
|
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 TestResponseEchoJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEcho(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseEcho{}
|
|
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 TestResponseFlushJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseFlush(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseFlush{}
|
|
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 TestResponseInfoJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInfo(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseInfo{}
|
|
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 TestResponseSetOptionJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseSetOption(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseSetOption{}
|
|
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 TestResponseInitChainJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInitChain(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseInitChain{}
|
|
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 TestResponseQueryJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseQuery(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseQuery{}
|
|
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 TestResponseBeginBlockJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseBeginBlock(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseBeginBlock{}
|
|
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 TestResponseCheckTxJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCheckTx(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseCheckTx{}
|
|
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 TestResponseDeliverTxJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseDeliverTx(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseDeliverTx{}
|
|
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 TestResponseEndBlockJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEndBlock(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseEndBlock{}
|
|
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 TestResponseCommitJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCommit(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ResponseCommit{}
|
|
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 TestConsensusParamsJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedConsensusParams(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ConsensusParams{}
|
|
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 TestBlockParamsJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockParams(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &BlockParams{}
|
|
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 TestEvidenceParamsJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidenceParams(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &EvidenceParams{}
|
|
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 TestValidatorParamsJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorParams(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ValidatorParams{}
|
|
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 TestLastCommitInfoJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedLastCommitInfo(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &LastCommitInfo{}
|
|
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 TestEventJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvent(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Event{}
|
|
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 TestHeaderJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedHeader(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Header{}
|
|
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 TestVersionJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVersion(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Version{}
|
|
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 TestBlockIDJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockID(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &BlockID{}
|
|
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 TestPartSetHeaderJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPartSetHeader(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &PartSetHeader{}
|
|
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 TestValidatorJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidator(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Validator{}
|
|
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 TestValidatorUpdateJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorUpdate(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &ValidatorUpdate{}
|
|
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 TestVoteInfoJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVoteInfo(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &VoteInfo{}
|
|
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 TestPubKeyJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPubKey(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &PubKey{}
|
|
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 TestEvidenceJSON(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidence(popr, true)
|
|
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
|
|
jsondata, err := marshaler.MarshalToString(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
msg := &Evidence{}
|
|
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 TestRequestProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequest(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &Request{}
|
|
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 TestRequestProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequest(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &Request{}
|
|
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 TestRequestEchoProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEcho(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestEcho{}
|
|
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 TestRequestEchoProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEcho(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestEcho{}
|
|
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 TestRequestFlushProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestFlush(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestFlush{}
|
|
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 TestRequestFlushProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestFlush(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestFlush{}
|
|
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 TestRequestInfoProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInfo(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestInfo{}
|
|
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 TestRequestInfoProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInfo(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestInfo{}
|
|
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 TestRequestSetOptionProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestSetOption(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestSetOption{}
|
|
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 TestRequestSetOptionProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestSetOption(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestSetOption{}
|
|
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 TestRequestInitChainProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInitChain(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestInitChain{}
|
|
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 TestRequestInitChainProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInitChain(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestInitChain{}
|
|
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 TestRequestQueryProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestQuery(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestQuery{}
|
|
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 TestRequestQueryProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestQuery(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestQuery{}
|
|
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 TestRequestBeginBlockProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestBeginBlock(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestBeginBlock{}
|
|
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 TestRequestBeginBlockProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestBeginBlock(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestBeginBlock{}
|
|
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 TestRequestCheckTxProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCheckTx(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestCheckTx{}
|
|
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 TestRequestCheckTxProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCheckTx(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestCheckTx{}
|
|
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 TestRequestDeliverTxProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestDeliverTx(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestDeliverTx{}
|
|
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 TestRequestDeliverTxProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestDeliverTx(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestDeliverTx{}
|
|
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 TestRequestEndBlockProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEndBlock(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestEndBlock{}
|
|
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 TestRequestEndBlockProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEndBlock(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestEndBlock{}
|
|
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 TestRequestCommitProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCommit(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &RequestCommit{}
|
|
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 TestRequestCommitProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCommit(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &RequestCommit{}
|
|
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 TestResponseProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponse(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &Response{}
|
|
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 TestResponseProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponse(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &Response{}
|
|
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 TestResponseExceptionProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseException(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseException{}
|
|
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 TestResponseExceptionProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseException(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseException{}
|
|
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 TestResponseEchoProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEcho(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseEcho{}
|
|
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 TestResponseEchoProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEcho(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseEcho{}
|
|
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 TestResponseFlushProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseFlush(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseFlush{}
|
|
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 TestResponseFlushProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseFlush(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseFlush{}
|
|
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 TestResponseInfoProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInfo(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseInfo{}
|
|
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 TestResponseInfoProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInfo(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseInfo{}
|
|
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 TestResponseSetOptionProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseSetOption(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseSetOption{}
|
|
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 TestResponseSetOptionProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseSetOption(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseSetOption{}
|
|
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 TestResponseInitChainProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInitChain(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseInitChain{}
|
|
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 TestResponseInitChainProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInitChain(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseInitChain{}
|
|
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 TestResponseQueryProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseQuery(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseQuery{}
|
|
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 TestResponseQueryProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseQuery(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseQuery{}
|
|
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 TestResponseBeginBlockProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseBeginBlock(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseBeginBlock{}
|
|
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 TestResponseBeginBlockProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseBeginBlock(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseBeginBlock{}
|
|
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 TestResponseCheckTxProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCheckTx(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseCheckTx{}
|
|
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 TestResponseCheckTxProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCheckTx(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseCheckTx{}
|
|
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 TestResponseDeliverTxProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseDeliverTx(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseDeliverTx{}
|
|
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 TestResponseDeliverTxProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseDeliverTx(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseDeliverTx{}
|
|
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 TestResponseEndBlockProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEndBlock(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseEndBlock{}
|
|
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 TestResponseEndBlockProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEndBlock(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseEndBlock{}
|
|
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 TestResponseCommitProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCommit(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ResponseCommit{}
|
|
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 TestResponseCommitProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCommit(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ResponseCommit{}
|
|
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 TestConsensusParamsProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedConsensusParams(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ConsensusParams{}
|
|
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 TestConsensusParamsProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedConsensusParams(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ConsensusParams{}
|
|
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 TestBlockParamsProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockParams(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &BlockParams{}
|
|
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 TestBlockParamsProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockParams(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &BlockParams{}
|
|
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 TestEvidenceParamsProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidenceParams(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &EvidenceParams{}
|
|
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 TestEvidenceParamsProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidenceParams(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &EvidenceParams{}
|
|
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 TestValidatorParamsProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorParams(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ValidatorParams{}
|
|
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 TestValidatorParamsProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorParams(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ValidatorParams{}
|
|
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 TestLastCommitInfoProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedLastCommitInfo(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &LastCommitInfo{}
|
|
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 TestLastCommitInfoProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedLastCommitInfo(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &LastCommitInfo{}
|
|
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 TestEventProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvent(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &Event{}
|
|
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 TestEventProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvent(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &Event{}
|
|
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 TestHeaderProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedHeader(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &Header{}
|
|
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 TestHeaderProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedHeader(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &Header{}
|
|
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 TestVersionProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVersion(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &Version{}
|
|
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 TestVersionProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVersion(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &Version{}
|
|
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 TestBlockIDProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockID(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &BlockID{}
|
|
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 TestBlockIDProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockID(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &BlockID{}
|
|
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 TestPartSetHeaderProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPartSetHeader(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &PartSetHeader{}
|
|
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 TestPartSetHeaderProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPartSetHeader(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &PartSetHeader{}
|
|
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 TestValidatorProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidator(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &Validator{}
|
|
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 TestValidatorProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidator(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &Validator{}
|
|
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 TestValidatorUpdateProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorUpdate(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &ValidatorUpdate{}
|
|
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 TestValidatorUpdateProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorUpdate(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &ValidatorUpdate{}
|
|
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 TestVoteInfoProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVoteInfo(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &VoteInfo{}
|
|
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 TestVoteInfoProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVoteInfo(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &VoteInfo{}
|
|
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 TestPubKeyProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPubKey(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &PubKey{}
|
|
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 TestPubKeyProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPubKey(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &PubKey{}
|
|
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 TestEvidenceProtoText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidence(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
|
|
msg := &Evidence{}
|
|
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 TestEvidenceProtoCompactText(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidence(popr, true)
|
|
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
|
|
msg := &Evidence{}
|
|
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 TestRequestSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequest(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestEchoSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEcho(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestFlushSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestFlush(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestInfoSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInfo(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestSetOptionSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestSetOption(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestInitChainSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestInitChain(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestQuerySize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestQuery(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestBeginBlockSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestBeginBlock(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestCheckTxSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCheckTx(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestDeliverTxSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestDeliverTx(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestEndBlockSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestEndBlock(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestRequestCommitSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedRequestCommit(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponse(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseExceptionSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseException(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseEchoSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEcho(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseFlushSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseFlush(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseInfoSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInfo(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseSetOptionSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseSetOption(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseInitChainSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseInitChain(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseQuerySize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseQuery(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseBeginBlockSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseBeginBlock(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseCheckTxSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCheckTx(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseDeliverTxSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseDeliverTx(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseEndBlockSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseEndBlock(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestResponseCommitSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedResponseCommit(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestConsensusParamsSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedConsensusParams(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestBlockParamsSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockParams(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestEvidenceParamsSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidenceParams(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestValidatorParamsSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorParams(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestLastCommitInfoSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedLastCommitInfo(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestEventSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvent(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestHeaderSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedHeader(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestVersionSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVersion(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestBlockIDSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedBlockID(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestPartSetHeaderSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPartSetHeader(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestValidatorSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidator(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestValidatorUpdateSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedValidatorUpdate(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestVoteInfoSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedVoteInfo(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestPubKeySize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedPubKey(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := github_com_gogo_protobuf_proto.Size(p)
|
|
if size3 != size {
|
|
t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
|
|
}
|
|
}
|
|
|
|
func TestEvidenceSize(t *testing.T) {
|
|
seed := time.Now().UnixNano()
|
|
popr := math_rand.New(math_rand.NewSource(seed))
|
|
p := NewPopulatedEvidence(popr, true)
|
|
size2 := github_com_gogo_protobuf_proto.Size(p)
|
|
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
|
|
if err != nil {
|
|
t.Fatalf("seed = %d, err = %v", seed, err)
|
|
}
|
|
size := p.Size()
|
|
if len(dAtA) != size {
|
|
t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
|
|
}
|
|
if size2 != size {
|
|
t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
|
|
}
|
|
size3 := 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
|