From 243dfbd5856616ff76eb4ddc95f66f5bb59b6def Mon Sep 17 00:00:00 2001 From: Marko Date: Wed, 13 May 2020 16:30:33 +0200 Subject: [PATCH] proto: remove test files ## Description remove test files for proto stubs Closes: #XXX --- abci/types/types.pb.go | 3938 ++--------------------- abci/types/types.proto | 4 - abci/types/typespb_test.go | 6228 ------------------------------------ crypto/merkle/merkle.pb.go | 184 +- crypto/merkle/merkle.proto | 3 - libs/kv/types.pb.go | 132 +- libs/kv/types.proto | 4 - libs/kv/typespb_test.go | 149 - rpc/grpc/types.pb.go | 267 +- rpc/grpc/types.proto | 6 +- rpc/grpc/typespb_test.go | 522 --- 11 files changed, 219 insertions(+), 11218 deletions(-) delete mode 100644 abci/types/typespb_test.go delete mode 100644 libs/kv/typespb_test.go delete mode 100644 rpc/grpc/typespb_test.go diff --git a/abci/types/types.pb.go b/abci/types/types.pb.go index 51defa3af..a64d87a12 100644 --- a/abci/types/types.pb.go +++ b/abci/types/types.pb.go @@ -4,7 +4,6 @@ package types import ( - bytes "bytes" context "context" fmt "fmt" _ "github.com/gogo/protobuf/gogoproto" @@ -187,7 +186,6 @@ var xxx_messageInfo_Request proto.InternalMessageInfo type isRequest_Value interface { isRequest_Value() - Equal(interface{}) bool MarshalTo([]byte) (int, error) Size() int } @@ -1284,7 +1282,6 @@ var xxx_messageInfo_Response proto.InternalMessageInfo type isResponse_Value interface { isResponse_Value() - Equal(interface{}) bool MarshalTo([]byte) (int, error) Size() int } @@ -3742,2630 +3739,194 @@ func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa func init() { golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa49c51fa1ac) } var fileDescriptor_9f1eaa49c51fa1ac = []byte{ - // 2961 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x4d, 0x70, 0x23, 0x47, - 0xf5, 0xf7, 0x48, 0xb2, 0xa4, 0x79, 0xb2, 0x3e, 0xb6, 0xd7, 0xd9, 0x28, 0xfa, 0x27, 0xf6, 0xd6, - 0x6c, 0xf6, 0x2b, 0xc9, 0xdf, 0xde, 0x38, 0x15, 0x2a, 0x61, 0x43, 0x28, 0xcb, 0xeb, 0x20, 0x91, - 0x5d, 0xaf, 0x33, 0xf6, 0x2e, 0x09, 0x54, 0x65, 0x68, 0x69, 0xda, 0xd2, 0x64, 0xa5, 0x99, 0xc9, - 0x4c, 0xcb, 0xb1, 0x28, 0x0e, 0x14, 0x17, 0x8a, 0x1b, 0x1c, 0xa8, 0xe2, 0xc2, 0x91, 0x2a, 0x8e, - 0x1c, 0xa8, 0x4a, 0x8e, 0x5c, 0xa8, 0xca, 0x91, 0x03, 0xe7, 0x04, 0x0c, 0x27, 0xe0, 0xc8, 0x81, - 0x23, 0xd5, 0x1f, 0xf3, 0x25, 0xeb, 0x63, 0x14, 0xf6, 0xc6, 0xc5, 0x9e, 0x7e, 0xf3, 0xde, 0xeb, - 0xee, 0xd7, 0xd3, 0xbf, 0xf7, 0xeb, 0xa7, 0x86, 0x2b, 0xb8, 0xd3, 0xb5, 0xb6, 0xe9, 0xd8, 0x25, - 0xbe, 0xf8, 0xbb, 0xe5, 0x7a, 0x0e, 0x75, 0xd0, 0x33, 0x94, 0xd8, 0x26, 0xf1, 0x86, 0x96, 0x4d, - 0xb7, 0x98, 0xca, 0x16, 0x7f, 0xd9, 0x68, 0x74, 0xbd, 0xb1, 0x4b, 0x9d, 0xed, 0x21, 0xf1, 0x9e, - 0x0c, 0x88, 0xfc, 0x27, 0x4c, 0x1a, 0x1b, 0x3d, 0xc7, 0xe9, 0x0d, 0xc8, 0x36, 0x6f, 0x75, 0x46, - 0x27, 0xdb, 0xe6, 0xc8, 0xc3, 0xd4, 0x72, 0x6c, 0xf9, 0x7e, 0x73, 0xf2, 0x3d, 0xb5, 0x86, 0xc4, - 0xa7, 0x78, 0xe8, 0x4a, 0x85, 0x1b, 0xb4, 0x6f, 0x79, 0xa6, 0xe1, 0x62, 0x8f, 0x8e, 0x85, 0xd6, - 0x76, 0xcf, 0xe9, 0x39, 0xd1, 0x93, 0xd0, 0xd3, 0xfe, 0x51, 0x84, 0x82, 0x4e, 0x3e, 0x1e, 0x11, - 0x9f, 0xa2, 0x37, 0x20, 0x47, 0xba, 0x7d, 0xa7, 0x9e, 0xb9, 0xaa, 0xdc, 0x2a, 0xed, 0x68, 0x5b, - 0x53, 0x87, 0xbd, 0x25, 0xb5, 0xf7, 0xbb, 0x7d, 0xa7, 0xb5, 0xa2, 0x73, 0x0b, 0x74, 0x17, 0x56, - 0x4f, 0x06, 0x23, 0xbf, 0x5f, 0xcf, 0x72, 0xd3, 0x6b, 0xf3, 0x4d, 0xdf, 0x61, 0xaa, 0xad, 0x15, - 0x5d, 0xd8, 0xb0, 0x6e, 0x2d, 0xfb, 0xc4, 0xa9, 0xe7, 0xd2, 0x74, 0xdb, 0xb6, 0x4f, 0x78, 0xb7, - 0xcc, 0x02, 0xb5, 0x00, 0x7c, 0x42, 0x0d, 0xc7, 0x65, 0x91, 0xa9, 0xaf, 0x72, 0xfb, 0x9b, 0xf3, - 0xed, 0x8f, 0x08, 0x7d, 0xc8, 0xd5, 0x5b, 0x2b, 0xba, 0xea, 0x07, 0x0d, 0xe6, 0xc9, 0xb2, 0x2d, - 0x6a, 0x74, 0xfb, 0xd8, 0xb2, 0xeb, 0xf9, 0x34, 0x9e, 0xda, 0xb6, 0x45, 0xf7, 0x98, 0x3a, 0xf3, - 0x64, 0x05, 0x0d, 0x16, 0x8a, 0x8f, 0x47, 0xc4, 0x1b, 0xd7, 0x0b, 0x69, 0x42, 0xf1, 0x1e, 0x53, - 0x65, 0xa1, 0xe0, 0x36, 0xe8, 0x5d, 0x28, 0x75, 0x48, 0xcf, 0xb2, 0x8d, 0xce, 0xc0, 0xe9, 0x3e, - 0xa9, 0x17, 0xb9, 0x8b, 0x5b, 0xf3, 0x5d, 0x34, 0x99, 0x41, 0x93, 0xe9, 0xb7, 0x56, 0x74, 0xe8, - 0x84, 0x2d, 0xd4, 0x84, 0x62, 0xb7, 0x4f, 0xba, 0x4f, 0x0c, 0x7a, 0x56, 0x57, 0xb9, 0xa7, 0xeb, - 0xf3, 0x3d, 0xed, 0x31, 0xed, 0xe3, 0xb3, 0xd6, 0x8a, 0x5e, 0xe8, 0x8a, 0x47, 0x16, 0x17, 0x93, - 0x0c, 0xac, 0x53, 0xe2, 0x31, 0x2f, 0x97, 0xd3, 0xc4, 0xe5, 0x9e, 0xd0, 0xe7, 0x7e, 0x54, 0x33, - 0x68, 0xa0, 0x7d, 0x50, 0x89, 0x6d, 0xca, 0x89, 0x95, 0xb8, 0xa3, 0x1b, 0x0b, 0xbe, 0x30, 0xdb, - 0x0c, 0xa6, 0x55, 0x24, 0xf2, 0x19, 0xbd, 0x0d, 0xf9, 0xae, 0x33, 0x1c, 0x5a, 0xb4, 0xbe, 0xc6, - 0x7d, 0xbc, 0xb8, 0x60, 0x4a, 0x5c, 0xb7, 0xb5, 0xa2, 0x4b, 0x2b, 0x74, 0x0c, 0x95, 0x81, 0xe5, - 0x53, 0xc3, 0xb7, 0xb1, 0xeb, 0xf7, 0x1d, 0xea, 0xd7, 0xcb, 0xdc, 0xcf, 0xcb, 0xf3, 0xfd, 0xdc, - 0xb7, 0x7c, 0x7a, 0x14, 0x98, 0xb4, 0x56, 0xf4, 0xf2, 0x20, 0x2e, 0x60, 0x5e, 0x9d, 0x93, 0x13, - 0xe2, 0x85, 0x6e, 0xeb, 0x95, 0x34, 0x5e, 0x1f, 0x32, 0x9b, 0xc0, 0x0b, 0xf3, 0xea, 0xc4, 0x05, - 0x08, 0xc3, 0xe5, 0x81, 0x83, 0xcd, 0xd0, 0xa9, 0xd1, 0xed, 0x8f, 0xec, 0x27, 0xf5, 0x2a, 0x77, - 0xbd, 0xbd, 0x60, 0xc0, 0x0e, 0x36, 0x03, 0x47, 0x7b, 0xcc, 0xac, 0xb5, 0xa2, 0x5f, 0x1a, 0x4c, - 0x0a, 0x91, 0x09, 0xeb, 0xd8, 0x75, 0x07, 0xe3, 0xc9, 0x3e, 0x6a, 0xbc, 0x8f, 0x3b, 0xf3, 0xfb, - 0xd8, 0x65, 0x96, 0x93, 0x9d, 0x20, 0x7c, 0x41, 0xda, 0x2c, 0xc0, 0xea, 0x29, 0x1e, 0x8c, 0x88, - 0x76, 0x13, 0x4a, 0x31, 0xf8, 0x40, 0x75, 0x28, 0x0c, 0x89, 0xef, 0xe3, 0x1e, 0xa9, 0x2b, 0x57, - 0x95, 0x5b, 0xaa, 0x1e, 0x34, 0xb5, 0x0a, 0xac, 0xc5, 0xc1, 0x42, 0x1b, 0x86, 0x86, 0x0c, 0x00, - 0x98, 0xe1, 0x29, 0xf1, 0x7c, 0xb6, 0xeb, 0xa5, 0xa1, 0x6c, 0xa2, 0x6b, 0x50, 0xe6, 0x9f, 0x98, - 0x11, 0xbc, 0x67, 0x60, 0x96, 0xd3, 0xd7, 0xb8, 0xf0, 0xb1, 0x54, 0xda, 0x84, 0x92, 0xbb, 0xe3, - 0x86, 0x2a, 0x59, 0xae, 0x02, 0xee, 0x8e, 0x2b, 0x15, 0xb4, 0xaf, 0x43, 0x6d, 0x12, 0x2f, 0x50, - 0x0d, 0xb2, 0x4f, 0xc8, 0x58, 0xf6, 0xc7, 0x1e, 0xd1, 0xba, 0x9c, 0x16, 0xef, 0x43, 0xd5, 0xe5, - 0x1c, 0x7f, 0x9b, 0x09, 0x8d, 0x43, 0x88, 0x60, 0x18, 0xc7, 0x10, 0x9a, 0x5b, 0x97, 0x76, 0x1a, - 0x5b, 0x02, 0xbe, 0xb7, 0x02, 0xf8, 0xde, 0x3a, 0x0e, 0xe0, 0xbb, 0x59, 0xfc, 0xfc, 0x8b, 0xcd, - 0x95, 0x9f, 0x7d, 0xb9, 0xa9, 0xe8, 0xdc, 0x02, 0x3d, 0xc7, 0x76, 0x31, 0xb6, 0x6c, 0xc3, 0x32, - 0x65, 0x3f, 0x05, 0xde, 0x6e, 0x9b, 0xe8, 0x3d, 0xa8, 0x75, 0x1d, 0xdb, 0x27, 0xb6, 0x3f, 0xf2, - 0x19, 0xd2, 0xe3, 0xa1, 0x2f, 0x01, 0x78, 0xd6, 0xce, 0xda, 0x0b, 0xd4, 0x0f, 0xb9, 0xb6, 0x5e, - 0xed, 0x26, 0x05, 0xe8, 0x3e, 0xc0, 0x29, 0x1e, 0x58, 0x26, 0xa6, 0x8e, 0xe7, 0xd7, 0x73, 0x57, - 0xb3, 0x73, 0x9c, 0x3d, 0x0e, 0x14, 0x1f, 0xb9, 0x26, 0xa6, 0xa4, 0x99, 0x63, 0x23, 0xd7, 0x63, - 0xf6, 0xe8, 0x06, 0x54, 0xb1, 0xeb, 0x1a, 0x3e, 0xc5, 0x94, 0x18, 0x9d, 0x31, 0x25, 0x3e, 0x07, - 0xe9, 0x35, 0xbd, 0x8c, 0x5d, 0xf7, 0x88, 0x49, 0x9b, 0x4c, 0xa8, 0x99, 0xe1, 0x6a, 0x73, 0x3c, - 0x44, 0x08, 0x72, 0x26, 0xa6, 0x98, 0x47, 0x6b, 0x4d, 0xe7, 0xcf, 0x4c, 0xe6, 0x62, 0xda, 0x97, - 0x31, 0xe0, 0xcf, 0xe8, 0x0a, 0xe4, 0xfb, 0xc4, 0xea, 0xf5, 0x29, 0x9f, 0x76, 0x56, 0x97, 0x2d, - 0xb6, 0x30, 0xae, 0xe7, 0x9c, 0x12, 0x9e, 0x52, 0x8a, 0xba, 0x68, 0x68, 0xbf, 0xc8, 0xc0, 0xa5, - 0x0b, 0x98, 0xc9, 0xfc, 0xf6, 0xb1, 0xdf, 0x0f, 0xfa, 0x62, 0xcf, 0xe8, 0x2e, 0xf3, 0x8b, 0x4d, - 0xe2, 0xc9, 0x54, 0xf8, 0xc2, 0x8c, 0x08, 0xb4, 0xb8, 0x92, 0x9c, 0xb8, 0x34, 0x41, 0x8f, 0xa0, - 0x36, 0xc0, 0x3e, 0x35, 0x04, 0xe0, 0x18, 0x3c, 0xb5, 0x65, 0xe7, 0xc2, 0xef, 0x7d, 0x1c, 0x00, - 0x15, 0xfb, 0xb8, 0xa5, 0xbb, 0xca, 0x20, 0x21, 0x45, 0xef, 0xc3, 0x7a, 0x67, 0xfc, 0x03, 0x6c, - 0x53, 0xcb, 0x26, 0xc6, 0x85, 0x35, 0xda, 0x9c, 0xe1, 0x7a, 0xff, 0xd4, 0x32, 0x89, 0xdd, 0x0d, - 0x16, 0xe7, 0x72, 0xe8, 0x22, 0x5c, 0x3c, 0x5f, 0x7b, 0x1f, 0x2a, 0xc9, 0x04, 0x80, 0x2a, 0x90, - 0xa1, 0x67, 0x32, 0x22, 0x19, 0x7a, 0x86, 0xbe, 0x06, 0x39, 0xe6, 0x8e, 0x47, 0xa3, 0x32, 0x33, - 0x43, 0x4b, 0xeb, 0xe3, 0xb1, 0x4b, 0x74, 0xae, 0xaf, 0x69, 0xe1, 0x4e, 0x08, 0x93, 0xc2, 0xa4, - 0x6f, 0xed, 0x36, 0x54, 0x27, 0xf0, 0x3e, 0xb6, 0xac, 0x4a, 0x7c, 0x59, 0xb5, 0x2a, 0x94, 0x13, - 0xb0, 0xae, 0x5d, 0x81, 0xf5, 0x69, 0xf8, 0xac, 0xd9, 0xa1, 0x3c, 0x81, 0xb0, 0xe8, 0x2e, 0x14, - 0x43, 0x80, 0x16, 0x3b, 0x71, 0x56, 0xdc, 0x02, 0x13, 0x3d, 0x34, 0x60, 0x1b, 0x91, 0x7d, 0xcc, - 0xfc, 0x63, 0xc9, 0xf0, 0xe1, 0x17, 0xb0, 0xeb, 0xb6, 0xb0, 0xdf, 0xd7, 0xbe, 0x0f, 0xf5, 0x59, - 0xb0, 0x3b, 0x31, 0x99, 0x5c, 0xf8, 0x8d, 0x5e, 0x81, 0xfc, 0x89, 0xe3, 0x0d, 0x31, 0xe5, 0xce, - 0xca, 0xba, 0x6c, 0xb1, 0x6f, 0x57, 0x40, 0x70, 0x96, 0x8b, 0x45, 0x43, 0x33, 0xe0, 0xb9, 0x99, - 0xa0, 0xcb, 0x4c, 0x2c, 0xdb, 0x24, 0x22, 0xaa, 0x65, 0x5d, 0x34, 0x22, 0x47, 0x62, 0xb0, 0xa2, - 0xc1, 0xba, 0xf5, 0xf9, 0x8c, 0xb9, 0x7f, 0x55, 0x97, 0x2d, 0xed, 0x0f, 0x2a, 0x14, 0x75, 0xe2, - 0xbb, 0x0c, 0x0f, 0x50, 0x0b, 0x54, 0x72, 0xd6, 0x25, 0x82, 0x56, 0x29, 0x0b, 0x48, 0x88, 0xb0, - 0xd9, 0x0f, 0xf4, 0x59, 0xd6, 0x0f, 0x8d, 0xd1, 0x9b, 0x09, 0x4a, 0x79, 0x6d, 0x91, 0x93, 0x38, - 0xa7, 0x7c, 0x2b, 0xc9, 0x29, 0x5f, 0x5c, 0x60, 0x3b, 0x41, 0x2a, 0xdf, 0x4c, 0x90, 0xca, 0x45, - 0x1d, 0x27, 0x58, 0x65, 0x7b, 0x0a, 0xab, 0x5c, 0x34, 0xfd, 0x19, 0xb4, 0xb2, 0x3d, 0x85, 0x56, - 0xde, 0x5a, 0x38, 0x96, 0xa9, 0xbc, 0xf2, 0xad, 0x24, 0xaf, 0x5c, 0x14, 0x8e, 0x09, 0x62, 0x79, - 0x7f, 0x1a, 0xb1, 0xbc, 0xbd, 0xc0, 0xc7, 0x4c, 0x66, 0xb9, 0x77, 0x81, 0x59, 0xde, 0x58, 0xe0, - 0x6a, 0x0a, 0xb5, 0x6c, 0x27, 0xa8, 0x25, 0xa4, 0x8a, 0xcd, 0x0c, 0x6e, 0xf9, 0xce, 0x45, 0x6e, - 0x79, 0x73, 0xd1, 0xa7, 0x36, 0x8d, 0x5c, 0x7e, 0x73, 0x82, 0x5c, 0x5e, 0x5f, 0x34, 0xab, 0x49, - 0x76, 0xf9, 0x68, 0x06, 0xbb, 0x7c, 0x65, 0x81, 0xa3, 0x05, 0xf4, 0xf2, 0xd1, 0x0c, 0x7a, 0xb9, - 0xc8, 0xed, 0x02, 0x7e, 0xd9, 0x99, 0xc7, 0x2f, 0xef, 0x2c, 0x1a, 0x72, 0x3a, 0x82, 0x49, 0xe6, - 0x12, 0xcc, 0x57, 0x17, 0x74, 0xb2, 0x3c, 0xc3, 0xbc, 0xcd, 0x72, 0xfc, 0x04, 0x24, 0x31, 0x28, - 0x24, 0x9e, 0xe7, 0x78, 0x92, 0xbc, 0x89, 0x86, 0x76, 0x8b, 0xb1, 0x8e, 0x08, 0x78, 0xe6, 0xb0, - 0x51, 0x9e, 0x78, 0x62, 0x30, 0xa3, 0x7d, 0xa6, 0x44, 0xb6, 0x3c, 0x3b, 0xc7, 0x19, 0x8b, 0x2a, - 0x19, 0x4b, 0x8c, 0xa4, 0x66, 0x92, 0x24, 0x75, 0x13, 0x4a, 0x2c, 0x95, 0x4c, 0xf0, 0x4f, 0xec, - 0x06, 0xfc, 0x13, 0xbd, 0x04, 0x97, 0x38, 0x87, 0x10, 0x54, 0x56, 0xe6, 0x8f, 0x1c, 0x4f, 0x86, - 0x55, 0xf6, 0x42, 0x7c, 0xba, 0x22, 0x91, 0xfc, 0x3f, 0x5c, 0x8e, 0xe9, 0x86, 0x29, 0x4a, 0x10, - 0xad, 0x5a, 0xa8, 0xbd, 0x2b, 0x73, 0xd5, 0x83, 0x28, 0x40, 0x11, 0xb7, 0x45, 0x90, 0xeb, 0x3a, - 0x26, 0x91, 0x09, 0x84, 0x3f, 0x33, 0xbe, 0x3b, 0x70, 0x7a, 0x32, 0x4d, 0xb0, 0x47, 0xa6, 0x15, - 0x62, 0xaa, 0x2a, 0xc0, 0x52, 0xfb, 0x9d, 0x12, 0xf9, 0x8b, 0xe8, 0xee, 0x34, 0x66, 0xaa, 0x3c, - 0x4d, 0x66, 0x9a, 0xf9, 0xef, 0x98, 0xa9, 0xf6, 0x2f, 0x25, 0x5a, 0xd2, 0x90, 0x73, 0x7e, 0xb5, - 0x10, 0x44, 0xe9, 0x77, 0x95, 0x2f, 0x90, 0x4c, 0xbf, 0xf2, 0xb8, 0x90, 0xe7, 0xcb, 0x90, 0x3c, - 0x2e, 0x14, 0x44, 0x42, 0xe6, 0x0d, 0xf4, 0x3a, 0xe7, 0xaa, 0xce, 0x89, 0xc4, 0xe4, 0x04, 0x21, - 0x11, 0x05, 0xa2, 0x2d, 0x59, 0x19, 0x3a, 0x64, 0x6a, 0xba, 0xd0, 0x8e, 0xd1, 0x0a, 0x35, 0x41, - 0x7d, 0x9f, 0x07, 0x95, 0x0d, 0xdd, 0x77, 0x71, 0x97, 0x70, 0x50, 0x55, 0xf5, 0x48, 0xa0, 0x99, - 0x80, 0x2e, 0x82, 0x3b, 0x3a, 0x80, 0x3c, 0x39, 0x25, 0x36, 0x65, 0x6b, 0xc4, 0xc2, 0xfa, 0xfc, - 0x4c, 0x32, 0x49, 0x6c, 0xda, 0xac, 0xb3, 0x60, 0xfe, 0xfd, 0x8b, 0xcd, 0x9a, 0xb0, 0x79, 0xc5, - 0x19, 0x5a, 0x94, 0x0c, 0x5d, 0x3a, 0xd6, 0xa5, 0x17, 0xed, 0x27, 0x19, 0xc6, 0xe9, 0x12, 0xc0, - 0x3f, 0x35, 0xbc, 0xc1, 0xa6, 0xc9, 0xc4, 0x68, 0x7e, 0xba, 0x90, 0xbf, 0x00, 0xd0, 0xc3, 0xbe, - 0xf1, 0x09, 0xb6, 0x29, 0x31, 0x65, 0xdc, 0xd5, 0x1e, 0xf6, 0xbf, 0xc3, 0x05, 0x8c, 0xaa, 0xb1, - 0xd7, 0x23, 0x9f, 0x98, 0x7c, 0x01, 0xb2, 0x7a, 0xa1, 0x87, 0xfd, 0x47, 0x3e, 0x31, 0x63, 0x73, - 0x2d, 0x3c, 0x8d, 0xb9, 0x26, 0xe3, 0x5d, 0x9c, 0x8c, 0xf7, 0x4f, 0x33, 0xd1, 0xee, 0x88, 0x28, - 0xf0, 0xff, 0x66, 0x2c, 0x7e, 0xc5, 0xcf, 0xc5, 0xc9, 0xec, 0x8b, 0x3e, 0x80, 0x4b, 0xe1, 0xae, - 0x34, 0x46, 0x7c, 0xb7, 0x06, 0x5f, 0xe1, 0x72, 0x9b, 0xbb, 0x76, 0x9a, 0x14, 0xfb, 0xe8, 0x43, - 0x78, 0x76, 0x02, 0x83, 0xc2, 0x0e, 0x32, 0x4b, 0x41, 0xd1, 0x33, 0x49, 0x28, 0x0a, 0xfc, 0x47, - 0xd1, 0xcb, 0x3e, 0x95, 0x5d, 0xd3, 0x66, 0xc7, 0xb0, 0x38, 0xaf, 0x98, 0xfa, 0x4d, 0x5c, 0x83, - 0xb2, 0x47, 0x28, 0xb6, 0x6c, 0x23, 0x71, 0xf2, 0x5d, 0x13, 0x42, 0x91, 0x12, 0xb4, 0xc7, 0xf0, - 0xcc, 0x54, 0x66, 0x81, 0xbe, 0x01, 0x6a, 0x44, 0x4d, 0x94, 0xb9, 0x27, 0xc7, 0xf0, 0x04, 0x14, - 0x59, 0x68, 0x9f, 0x2a, 0x91, 0xe3, 0xe4, 0xc9, 0xea, 0x5d, 0xc8, 0x7b, 0xc4, 0x1f, 0x0d, 0xc4, - 0x29, 0xa7, 0xb2, 0xf3, 0xda, 0x32, 0xcc, 0x84, 0x49, 0x47, 0x03, 0xaa, 0x4b, 0x17, 0xda, 0x7b, - 0x90, 0x17, 0x12, 0x04, 0x90, 0xdf, 0xdd, 0xdb, 0xdb, 0x3f, 0x3c, 0xae, 0xad, 0x20, 0x15, 0x56, - 0x77, 0x9b, 0x0f, 0xf5, 0xe3, 0x9a, 0xc2, 0xc4, 0xfa, 0xfe, 0xb7, 0xf7, 0xf7, 0x8e, 0x6b, 0x19, - 0x74, 0x09, 0xca, 0xe2, 0xd9, 0x78, 0xe7, 0xa1, 0xfe, 0x60, 0xf7, 0xb8, 0x96, 0x8d, 0x89, 0x8e, - 0xf6, 0x0f, 0xee, 0xed, 0xeb, 0xb5, 0x9c, 0xf6, 0x2a, 0x3b, 0x3f, 0xcd, 0x20, 0x2e, 0xd1, 0x49, - 0x49, 0x89, 0x9d, 0x94, 0xb4, 0x9f, 0x67, 0xa0, 0x31, 0x9b, 0x87, 0xa0, 0xc3, 0x89, 0x19, 0xbf, - 0xb1, 0x34, 0x95, 0x99, 0x98, 0x36, 0xba, 0x0e, 0x15, 0x8f, 0x9c, 0x10, 0xda, 0xed, 0x0b, 0x8e, - 0x24, 0xb2, 0x5c, 0x59, 0x2f, 0x4b, 0x29, 0x37, 0xf2, 0x85, 0xda, 0x47, 0xa4, 0x4b, 0x0d, 0x71, - 0x74, 0x13, 0xdf, 0x9f, 0xca, 0xd4, 0x98, 0xf4, 0x48, 0x08, 0xb5, 0xa3, 0x45, 0x41, 0x54, 0x61, - 0x55, 0xdf, 0x3f, 0xd6, 0x3f, 0xa8, 0x65, 0x10, 0x82, 0x0a, 0x7f, 0x34, 0x8e, 0x0e, 0x76, 0x0f, - 0x8f, 0x5a, 0x0f, 0x59, 0x10, 0x2f, 0x43, 0x35, 0x08, 0x62, 0x20, 0xcc, 0x69, 0x7f, 0x52, 0xa0, - 0x3a, 0xb1, 0x3d, 0xd0, 0x1b, 0xb0, 0x2a, 0x88, 0xb7, 0x32, 0xb7, 0x7e, 0xcf, 0xf7, 0xbb, 0xdc, - 0x51, 0xc2, 0x00, 0xed, 0x42, 0x91, 0xc8, 0xfa, 0x84, 0xdc, 0x92, 0xd7, 0x17, 0x94, 0x31, 0xa4, - 0x7d, 0x68, 0x86, 0xee, 0x81, 0x1a, 0x6e, 0xfc, 0x05, 0xb5, 0xaf, 0x10, 0x37, 0xa4, 0x93, 0xc8, - 0x50, 0xdb, 0x83, 0x52, 0x6c, 0x78, 0xe8, 0xff, 0x40, 0x1d, 0xe2, 0x33, 0x59, 0xb0, 0x12, 0x25, - 0x88, 0xe2, 0x10, 0x9f, 0xf1, 0x5a, 0x15, 0x7a, 0x16, 0x0a, 0xec, 0x65, 0x0f, 0x0b, 0x18, 0xc9, - 0xea, 0xf9, 0x21, 0x3e, 0xfb, 0x16, 0xf6, 0xb5, 0x5f, 0x2b, 0x50, 0x49, 0x8e, 0x13, 0xbd, 0x0c, - 0x88, 0xe9, 0xe2, 0x1e, 0x31, 0xec, 0xd1, 0x50, 0x30, 0xb4, 0xc0, 0x63, 0x75, 0x88, 0xcf, 0x76, - 0x7b, 0xe4, 0x60, 0x34, 0xe4, 0x5d, 0xfb, 0xe8, 0x01, 0xd4, 0x02, 0xe5, 0xe0, 0xc7, 0x1e, 0x19, - 0x95, 0xe7, 0x2e, 0x94, 0x0b, 0xef, 0x49, 0x05, 0x51, 0x2d, 0xfc, 0xe5, 0x97, 0x9b, 0x8a, 0x5e, - 0x11, 0xfe, 0x82, 0x37, 0xc1, 0x38, 0xed, 0xd1, 0x50, 0x56, 0x12, 0xd8, 0x38, 0x0f, 0x46, 0x43, - 0xed, 0x75, 0xa8, 0x4e, 0x84, 0x02, 0x69, 0x50, 0x76, 0x47, 0x1d, 0xe3, 0x09, 0x19, 0x1b, 0x3c, - 0x56, 0x1c, 0x1a, 0x54, 0xbd, 0xe4, 0x8e, 0x3a, 0xef, 0x92, 0xf1, 0x31, 0x13, 0x69, 0x5d, 0xa8, - 0x24, 0xeb, 0x54, 0x6c, 0xdb, 0x78, 0xce, 0xc8, 0x36, 0xf9, 0x84, 0x56, 0x75, 0xd1, 0x40, 0x77, - 0x61, 0xf5, 0xd4, 0x11, 0x20, 0x3b, 0x0f, 0x5e, 0x1e, 0x3b, 0x94, 0xc4, 0xaa, 0x5d, 0xc2, 0x46, - 0x3b, 0x60, 0x21, 0x24, 0x36, 0xdd, 0xa5, 0xd4, 0xb3, 0x3a, 0x23, 0x4a, 0xe2, 0x55, 0xd7, 0xb5, - 0x29, 0x55, 0xd7, 0x90, 0x46, 0x85, 0x24, 0x2c, 0x2b, 0x4a, 0x7e, 0xbc, 0xa1, 0xfd, 0x48, 0x81, - 0x55, 0xee, 0x90, 0x61, 0x29, 0x2f, 0x61, 0x49, 0x82, 0xce, 0x9e, 0x51, 0x17, 0x00, 0x07, 0x1d, - 0x05, 0xe3, 0xbd, 0x3e, 0x0f, 0xc5, 0xc3, 0x61, 0x35, 0x9f, 0x97, 0x70, 0xbe, 0x1e, 0x39, 0x88, - 0x41, 0x7a, 0xcc, 0xad, 0xf6, 0xcf, 0x1c, 0xe4, 0x45, 0x9d, 0x10, 0xbd, 0x9d, 0xac, 0x5a, 0x97, - 0x76, 0x36, 0x66, 0x05, 0x47, 0x68, 0xc9, 0xd8, 0x84, 0xc7, 0x86, 0x1b, 0x93, 0xa5, 0xe0, 0x66, - 0xe9, 0xfc, 0x8b, 0xcd, 0x02, 0xa7, 0xdc, 0xed, 0x7b, 0x51, 0x5d, 0x78, 0x56, 0x59, 0x34, 0x28, - 0x42, 0xe7, 0x96, 0x2e, 0x42, 0xb7, 0xa0, 0x1c, 0x3b, 0x63, 0x58, 0xa6, 0xac, 0x8a, 0x6c, 0xcc, - 0xdb, 0xeb, 0xed, 0x7b, 0x72, 0xfc, 0xa5, 0xf0, 0x0c, 0xd2, 0x36, 0xd1, 0xad, 0x64, 0x75, 0x94, - 0x1f, 0x55, 0x04, 0x47, 0x8e, 0x15, 0x3c, 0xd9, 0x41, 0x85, 0xed, 0x42, 0x96, 0xf1, 0x84, 0x8a, - 0xa0, 0xcc, 0x45, 0x26, 0xe0, 0x2f, 0x6f, 0x42, 0x35, 0x62, 0xf3, 0x42, 0xa5, 0x28, 0xbc, 0x44, - 0x62, 0xae, 0x78, 0x07, 0xd6, 0x6d, 0x72, 0x46, 0x8d, 0x49, 0x6d, 0x95, 0x6b, 0x23, 0xf6, 0xee, - 0x71, 0xd2, 0xe2, 0x3a, 0x54, 0x22, 0xde, 0xc0, 0x75, 0x41, 0xd4, 0xac, 0x43, 0x29, 0x57, 0x8b, - 0x97, 0x03, 0x4b, 0x89, 0x72, 0x60, 0x78, 0x7a, 0x13, 0xb8, 0x2e, 0x9d, 0xac, 0x71, 0x1d, 0x7e, - 0x7a, 0x13, 0xb8, 0x2c, 0xdc, 0x5c, 0x83, 0x72, 0x00, 0x66, 0x42, 0xaf, 0xcc, 0xf5, 0xd6, 0x02, - 0x21, 0x57, 0xba, 0x0d, 0x35, 0xd7, 0x73, 0x5c, 0xc7, 0x27, 0x9e, 0x81, 0x4d, 0xd3, 0x23, 0xbe, - 0xcf, 0x2b, 0x00, 0x6b, 0x7a, 0x35, 0x90, 0xef, 0x0a, 0xb1, 0xf6, 0x2a, 0x14, 0x82, 0x43, 0xe4, - 0x3a, 0xac, 0x36, 0x43, 0x60, 0xce, 0xe9, 0xa2, 0xc1, 0x36, 0xd4, 0xae, 0xeb, 0xca, 0x9f, 0x45, - 0xd8, 0xa3, 0x36, 0x80, 0x82, 0x5c, 0xb0, 0xa9, 0xc5, 0xf0, 0x07, 0xb0, 0xe6, 0x62, 0x8f, 0x4d, - 0x23, 0x5e, 0x12, 0x9f, 0x55, 0x7f, 0x3a, 0xc4, 0x1e, 0x3d, 0x22, 0x34, 0x51, 0x19, 0x2f, 0x71, - 0x7b, 0x21, 0xd2, 0xde, 0x84, 0x72, 0x42, 0x87, 0x0d, 0x93, 0x3a, 0x14, 0x0f, 0x02, 0x18, 0xe1, - 0x8d, 0x70, 0x24, 0x99, 0x68, 0x24, 0xda, 0x5d, 0x50, 0xc3, 0xb5, 0x62, 0xa7, 0xeb, 0x20, 0x14, - 0x8a, 0x0c, 0xbf, 0x68, 0xf2, 0xea, 0xbf, 0xf3, 0x89, 0xac, 0x70, 0x66, 0x75, 0xd1, 0xd0, 0x48, - 0x0c, 0xf6, 0x04, 0x85, 0x43, 0x6f, 0x41, 0x41, 0xc2, 0x9e, 0xdc, 0x8f, 0xb3, 0xea, 0xfc, 0x87, - 0x1c, 0x07, 0x83, 0x3a, 0xbf, 0x40, 0xc5, 0xa8, 0x9b, 0x4c, 0xbc, 0x9b, 0x1f, 0x42, 0x31, 0x80, - 0xb6, 0x64, 0x72, 0x12, 0x3d, 0x5c, 0x5d, 0x94, 0x9c, 0x64, 0x27, 0x91, 0x21, 0xfb, 0x9a, 0x7c, - 0xab, 0x67, 0x13, 0xd3, 0x88, 0xb6, 0x20, 0xef, 0xb3, 0xa8, 0x57, 0xc5, 0x8b, 0xfb, 0xc1, 0xfe, - 0xd2, 0xee, 0x40, 0x5e, 0x8c, 0x75, 0x2a, 0xde, 0x4d, 0xe1, 0x93, 0xda, 0xdf, 0x14, 0x28, 0x06, - 0x59, 0x6b, 0xaa, 0x51, 0x62, 0x12, 0x99, 0xaf, 0x3a, 0x89, 0xa7, 0x0f, 0x49, 0xaf, 0x00, 0xe2, - 0x5f, 0x8a, 0x71, 0xea, 0x50, 0xcb, 0xee, 0x19, 0x62, 0x2d, 0xc4, 0xf1, 0xa7, 0xc6, 0xdf, 0x3c, - 0xe6, 0x2f, 0x0e, 0xf9, 0xb2, 0xfc, 0x58, 0x81, 0x62, 0x48, 0x56, 0x97, 0x2d, 0xc9, 0x5f, 0x81, - 0xbc, 0x24, 0x64, 0x32, 0x93, 0x8a, 0x56, 0xf8, 0x8d, 0xe6, 0x62, 0xbb, 0xa5, 0x01, 0xc5, 0x21, - 0xa1, 0x98, 0xc7, 0x59, 0x94, 0x60, 0xc2, 0xf6, 0x4b, 0xd7, 0xa0, 0x14, 0xfb, 0x8d, 0x04, 0x15, - 0x20, 0x7b, 0x40, 0x3e, 0xa9, 0xad, 0xa0, 0x12, 0x14, 0x74, 0xc2, 0xcb, 0xa2, 0x35, 0x65, 0xe7, - 0xd3, 0x12, 0x54, 0x77, 0x9b, 0x7b, 0x6d, 0xc6, 0x17, 0xad, 0xae, 0xc8, 0xe5, 0x0f, 0x21, 0xc7, - 0x2b, 0x54, 0x29, 0xae, 0x64, 0x34, 0xd2, 0xd4, 0xd8, 0x91, 0x0e, 0xab, 0xbc, 0x90, 0x85, 0xd2, - 0xdc, 0xd4, 0x68, 0xa4, 0x2a, 0xbd, 0xb3, 0x41, 0xf2, 0xaf, 0x3e, 0xc5, 0x05, 0x8e, 0x46, 0x9a, - 0x7a, 0x3c, 0xfa, 0x10, 0xd4, 0xa8, 0x42, 0x95, 0xf6, 0x5a, 0x47, 0x23, 0x75, 0xa5, 0x9e, 0xf9, - 0x8f, 0xce, 0xe4, 0x69, 0x2f, 0x35, 0x34, 0x52, 0x97, 0xa8, 0xd1, 0xfb, 0x50, 0x08, 0xaa, 0x1f, - 0xe9, 0x2e, 0x5e, 0x34, 0x52, 0x56, 0xd1, 0xd9, 0xf2, 0x89, 0xa2, 0x55, 0x9a, 0xdb, 0x25, 0x8d, - 0x54, 0x3f, 0x15, 0xa0, 0x47, 0x90, 0x97, 0xc7, 0xce, 0x54, 0x57, 0x2a, 0x1a, 0xe9, 0x6a, 0xe3, - 0x2c, 0xc8, 0x51, 0x59, 0x30, 0xed, 0x8d, 0x9a, 0x46, 0xea, 0xdf, 0x48, 0x10, 0x06, 0x88, 0x55, - 0xb2, 0x52, 0x5f, 0x95, 0x69, 0xa4, 0xff, 0xed, 0x03, 0x7d, 0x0f, 0x8a, 0x61, 0xbd, 0x22, 0xe5, - 0x95, 0x95, 0x46, 0xda, 0x9f, 0x1f, 0xd0, 0x47, 0x50, 0x4e, 0x1e, 0xd1, 0x97, 0xb9, 0x88, 0xd2, - 0x58, 0xea, 0x77, 0x05, 0xd6, 0x57, 0xf2, 0xd4, 0xbe, 0xcc, 0xf5, 0x94, 0xc6, 0x52, 0x3f, 0x36, - 0xa0, 0x53, 0xb8, 0x74, 0xf1, 0xa0, 0xbd, 0xec, 0x9d, 0x95, 0xc6, 0xd2, 0x3f, 0x42, 0xa0, 0x31, - 0xa0, 0x29, 0x87, 0xf5, 0xa5, 0x2f, 0xb2, 0x34, 0x96, 0xff, 0x65, 0xa2, 0xd9, 0xfe, 0xf7, 0x5f, - 0x36, 0x94, 0xdf, 0x9c, 0x6f, 0x28, 0x9f, 0x9d, 0x6f, 0x28, 0x9f, 0x9f, 0x6f, 0x28, 0x7f, 0x3c, - 0xdf, 0x50, 0xfe, 0x7c, 0xbe, 0xa1, 0xfc, 0xfe, 0xaf, 0x1b, 0xca, 0x77, 0x5f, 0xee, 0x59, 0xb4, - 0x3f, 0xea, 0x6c, 0x75, 0x9d, 0xe1, 0x76, 0xe4, 0x3a, 0xfe, 0x18, 0xdd, 0x1e, 0xec, 0xe4, 0x79, - 0x02, 0x7c, 0xed, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x66, 0xbd, 0x92, 0x78, 0x52, 0x28, 0x00, + // 2945 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xcd, 0x73, 0x23, 0x47, + 0x15, 0xf7, 0x48, 0xb2, 0xa4, 0x79, 0xb2, 0x3e, 0xb6, 0xd7, 0xd9, 0x28, 0x22, 0xb1, 0xb7, 0x66, + 0xb3, 0x5f, 0x49, 0xb0, 0x37, 0x4e, 0x85, 0x4a, 0xd8, 0x24, 0x94, 0xe4, 0x75, 0x90, 0xc9, 0xae, + 0xd7, 0x19, 0x7b, 0x97, 0x04, 0xaa, 0x32, 0xb4, 0x34, 0x6d, 0x69, 0x62, 0x69, 0x66, 0x32, 0xd3, + 0x72, 0x2c, 0x8a, 0x03, 0xc5, 0x85, 0xe2, 0x06, 0x07, 0xaa, 0xb8, 0x70, 0xe4, 0xce, 0x81, 0xaa, + 0x70, 0xe4, 0x42, 0x55, 0x8e, 0x1c, 0x38, 0x6f, 0xa8, 0x85, 0x13, 0x70, 0xe4, 0x0f, 0xa0, 0xfa, + 0x63, 0xbe, 0x64, 0x7d, 0x8c, 0xc2, 0xde, 0xb8, 0xd8, 0xd3, 0x6f, 0xde, 0x7b, 0xdd, 0xfd, 0x7a, + 0xfa, 0xf7, 0x7e, 0xfd, 0xd4, 0x70, 0x05, 0x77, 0xba, 0xd6, 0x36, 0x1d, 0xbb, 0xc4, 0x17, 0x7f, + 0xb7, 0x5c, 0xcf, 0xa1, 0x0e, 0x7a, 0x8e, 0x12, 0xdb, 0x24, 0xde, 0xd0, 0xb2, 0xe9, 0x16, 0x53, + 0xd9, 0xe2, 0x2f, 0x1b, 0x8d, 0xae, 0x37, 0x76, 0xa9, 0xb3, 0x3d, 0x24, 0xde, 0xe9, 0x80, 0xc8, + 0x7f, 0xc2, 0xa4, 0xb1, 0xd1, 0x73, 0x9c, 0xde, 0x80, 0x6c, 0xf3, 0x56, 0x67, 0x74, 0xb2, 0x6d, + 0x8e, 0x3c, 0x4c, 0x2d, 0xc7, 0x96, 0xef, 0x37, 0x27, 0xdf, 0x53, 0x6b, 0x48, 0x7c, 0x8a, 0x87, + 0xae, 0x54, 0xb8, 0x41, 0xfb, 0x96, 0x67, 0x1a, 0x2e, 0xf6, 0xe8, 0x58, 0x68, 0x6d, 0xf7, 0x9c, + 0x9e, 0x13, 0x3d, 0x09, 0x3d, 0xed, 0x5f, 0x45, 0x28, 0xe8, 0xe4, 0xb3, 0x11, 0xf1, 0x29, 0x7a, + 0x0b, 0x72, 0xa4, 0xdb, 0x77, 0xea, 0x99, 0xab, 0xca, 0xad, 0xd2, 0x8e, 0xb6, 0x35, 0x75, 0xd8, + 0x5b, 0x52, 0x7b, 0xaf, 0xdb, 0x77, 0xda, 0x2b, 0x3a, 0xb7, 0x40, 0x77, 0x61, 0xf5, 0x64, 0x30, + 0xf2, 0xfb, 0xf5, 0x2c, 0x37, 0xbd, 0x36, 0xdf, 0xf4, 0x7d, 0xa6, 0xda, 0x5e, 0xd1, 0x85, 0x0d, + 0xeb, 0xd6, 0xb2, 0x4f, 0x9c, 0x7a, 0x2e, 0x4d, 0xb7, 0xfb, 0xf6, 0x09, 0xef, 0x96, 0x59, 0xa0, + 0x36, 0x80, 0x4f, 0xa8, 0xe1, 0xb8, 0x2c, 0x32, 0xf5, 0x55, 0x6e, 0x7f, 0x73, 0xbe, 0xfd, 0x11, + 0xa1, 0x0f, 0xb9, 0x7a, 0x7b, 0x45, 0x57, 0xfd, 0xa0, 0xc1, 0x3c, 0x59, 0xb6, 0x45, 0x8d, 0x6e, + 0x1f, 0x5b, 0x76, 0x3d, 0x9f, 0xc6, 0xd3, 0xbe, 0x6d, 0xd1, 0x5d, 0xa6, 0xce, 0x3c, 0x59, 0x41, + 0x83, 0x85, 0xe2, 0xb3, 0x11, 0xf1, 0xc6, 0xf5, 0x42, 0x9a, 0x50, 0x7c, 0xc8, 0x54, 0x59, 0x28, + 0xb8, 0x0d, 0xfa, 0x00, 0x4a, 0x1d, 0xd2, 0xb3, 0x6c, 0xa3, 0x33, 0x70, 0xba, 0xa7, 0xf5, 0x22, + 0x77, 0x71, 0x6b, 0xbe, 0x8b, 0x16, 0x33, 0x68, 0x31, 0xfd, 0xf6, 0x8a, 0x0e, 0x9d, 0xb0, 0x85, + 0x5a, 0x50, 0xec, 0xf6, 0x49, 0xf7, 0xd4, 0xa0, 0xe7, 0x75, 0x95, 0x7b, 0xba, 0x3e, 0xdf, 0xd3, + 0x2e, 0xd3, 0x3e, 0x3e, 0x6f, 0xaf, 0xe8, 0x85, 0xae, 0x78, 0x64, 0x71, 0x31, 0xc9, 0xc0, 0x3a, + 0x23, 0x1e, 0xf3, 0x72, 0x39, 0x4d, 0x5c, 0xee, 0x09, 0x7d, 0xee, 0x47, 0x35, 0x83, 0x06, 0xda, + 0x03, 0x95, 0xd8, 0xa6, 0x9c, 0x58, 0x89, 0x3b, 0xba, 0xb1, 0xe0, 0x0b, 0xb3, 0xcd, 0x60, 0x5a, + 0x45, 0x22, 0x9f, 0xd1, 0x7b, 0x90, 0xef, 0x3a, 0xc3, 0xa1, 0x45, 0xeb, 0x6b, 0xdc, 0xc7, 0xcb, + 0x0b, 0xa6, 0xc4, 0x75, 0xdb, 0x2b, 0xba, 0xb4, 0x42, 0xc7, 0x50, 0x19, 0x58, 0x3e, 0x35, 0x7c, + 0x1b, 0xbb, 0x7e, 0xdf, 0xa1, 0x7e, 0xbd, 0xcc, 0xfd, 0xbc, 0x3a, 0xdf, 0xcf, 0x7d, 0xcb, 0xa7, + 0x47, 0x81, 0x49, 0x7b, 0x45, 0x2f, 0x0f, 0xe2, 0x02, 0xe6, 0xd5, 0x39, 0x39, 0x21, 0x5e, 0xe8, + 0xb6, 0x5e, 0x49, 0xe3, 0xf5, 0x21, 0xb3, 0x09, 0xbc, 0x30, 0xaf, 0x4e, 0x5c, 0x80, 0x30, 0x5c, + 0x1e, 0x38, 0xd8, 0x0c, 0x9d, 0x1a, 0xdd, 0xfe, 0xc8, 0x3e, 0xad, 0x57, 0xb9, 0xeb, 0xed, 0x05, + 0x03, 0x76, 0xb0, 0x19, 0x38, 0xda, 0x65, 0x66, 0xed, 0x15, 0xfd, 0xd2, 0x60, 0x52, 0x88, 0x4c, + 0x58, 0xc7, 0xae, 0x3b, 0x18, 0x4f, 0xf6, 0x51, 0xe3, 0x7d, 0xdc, 0x99, 0xdf, 0x47, 0x93, 0x59, + 0x4e, 0x76, 0x82, 0xf0, 0x05, 0x69, 0xab, 0x00, 0xab, 0x67, 0x78, 0x30, 0x22, 0xda, 0x4d, 0x28, + 0xc5, 0xe0, 0x03, 0xd5, 0xa1, 0x30, 0x24, 0xbe, 0x8f, 0x7b, 0xa4, 0xae, 0x5c, 0x55, 0x6e, 0xa9, + 0x7a, 0xd0, 0xd4, 0x2a, 0xb0, 0x16, 0x07, 0x0b, 0x6d, 0x18, 0x1a, 0x32, 0x00, 0x60, 0x86, 0x67, + 0xc4, 0xf3, 0xd9, 0xae, 0x97, 0x86, 0xb2, 0x89, 0xae, 0x41, 0x99, 0x7f, 0x62, 0x46, 0xf0, 0x9e, + 0x81, 0x59, 0x4e, 0x5f, 0xe3, 0xc2, 0xc7, 0x52, 0x69, 0x13, 0x4a, 0xee, 0x8e, 0x1b, 0xaa, 0x64, + 0xb9, 0x0a, 0xb8, 0x3b, 0xae, 0x54, 0xd0, 0xbe, 0x0d, 0xb5, 0x49, 0xbc, 0x40, 0x35, 0xc8, 0x9e, + 0x92, 0xb1, 0xec, 0x8f, 0x3d, 0xa2, 0x75, 0x39, 0x2d, 0xde, 0x87, 0xaa, 0xcb, 0x39, 0xfe, 0x3e, + 0x13, 0x1a, 0x87, 0x10, 0xc1, 0x30, 0x8e, 0x21, 0x34, 0xb7, 0x2e, 0xed, 0x34, 0xb6, 0x04, 0x7c, + 0x6f, 0x05, 0xf0, 0xbd, 0x75, 0x1c, 0xc0, 0x77, 0xab, 0xf8, 0xe5, 0x93, 0xcd, 0x95, 0x5f, 0x7e, + 0xb5, 0xa9, 0xe8, 0xdc, 0x02, 0xbd, 0xc0, 0x76, 0x31, 0xb6, 0x6c, 0xc3, 0x32, 0x65, 0x3f, 0x05, + 0xde, 0xde, 0x37, 0xd1, 0x87, 0x50, 0xeb, 0x3a, 0xb6, 0x4f, 0x6c, 0x7f, 0xe4, 0x33, 0xa4, 0xc7, + 0x43, 0x5f, 0x02, 0xf0, 0xac, 0x9d, 0xb5, 0x1b, 0xa8, 0x1f, 0x72, 0x6d, 0xbd, 0xda, 0x4d, 0x0a, + 0xd0, 0x7d, 0x80, 0x33, 0x3c, 0xb0, 0x4c, 0x4c, 0x1d, 0xcf, 0xaf, 0xe7, 0xae, 0x66, 0xe7, 0x38, + 0x7b, 0x1c, 0x28, 0x3e, 0x72, 0x4d, 0x4c, 0x49, 0x2b, 0xc7, 0x46, 0xae, 0xc7, 0xec, 0xd1, 0x0d, + 0xa8, 0x62, 0xd7, 0x35, 0x7c, 0x8a, 0x29, 0x31, 0x3a, 0x63, 0x4a, 0x7c, 0x0e, 0xd2, 0x6b, 0x7a, + 0x19, 0xbb, 0xee, 0x11, 0x93, 0xb6, 0x98, 0x50, 0x33, 0xc3, 0xd5, 0xe6, 0x78, 0x88, 0x10, 0xe4, + 0x4c, 0x4c, 0x31, 0x8f, 0xd6, 0x9a, 0xce, 0x9f, 0x99, 0xcc, 0xc5, 0xb4, 0x2f, 0x63, 0xc0, 0x9f, + 0xd1, 0x15, 0xc8, 0xf7, 0x89, 0xd5, 0xeb, 0x53, 0x3e, 0xed, 0xac, 0x2e, 0x5b, 0x6c, 0x61, 0x5c, + 0xcf, 0x39, 0x23, 0x3c, 0xa5, 0x14, 0x75, 0xd1, 0xd0, 0x7e, 0x9d, 0x81, 0x4b, 0x17, 0x30, 0x93, + 0xf9, 0xed, 0x63, 0xbf, 0x1f, 0xf4, 0xc5, 0x9e, 0xd1, 0x5d, 0xe6, 0x17, 0x9b, 0xc4, 0x93, 0xa9, + 0xf0, 0xa5, 0x19, 0x11, 0x68, 0x73, 0x25, 0x39, 0x71, 0x69, 0x82, 0x1e, 0x41, 0x6d, 0x80, 0x7d, + 0x6a, 0x08, 0xc0, 0x31, 0x78, 0x6a, 0xcb, 0xce, 0x85, 0xdf, 0xfb, 0x38, 0x00, 0x2a, 0xf6, 0x71, + 0x4b, 0x77, 0x95, 0x41, 0x42, 0x8a, 0x3e, 0x82, 0xf5, 0xce, 0xf8, 0xc7, 0xd8, 0xa6, 0x96, 0x4d, + 0x8c, 0x0b, 0x6b, 0xb4, 0x39, 0xc3, 0xf5, 0xde, 0x99, 0x65, 0x12, 0xbb, 0x1b, 0x2c, 0xce, 0xe5, + 0xd0, 0x45, 0xb8, 0x78, 0xbe, 0xf6, 0x11, 0x54, 0x92, 0x09, 0x00, 0x55, 0x20, 0x43, 0xcf, 0x65, + 0x44, 0x32, 0xf4, 0x1c, 0x7d, 0x0b, 0x72, 0xcc, 0x1d, 0x8f, 0x46, 0x65, 0x66, 0x86, 0x96, 0xd6, + 0xc7, 0x63, 0x97, 0xe8, 0x5c, 0x5f, 0xd3, 0xc2, 0x9d, 0x10, 0x26, 0x85, 0x49, 0xdf, 0xda, 0x6d, + 0xa8, 0x4e, 0xe0, 0x7d, 0x6c, 0x59, 0x95, 0xf8, 0xb2, 0x6a, 0x55, 0x28, 0x27, 0x60, 0x5d, 0xbb, + 0x02, 0xeb, 0xd3, 0xf0, 0x59, 0xb3, 0x43, 0x79, 0x02, 0x61, 0xd1, 0x5d, 0x28, 0x86, 0x00, 0x2d, + 0x76, 0xe2, 0xac, 0xb8, 0x05, 0x26, 0x7a, 0x68, 0xc0, 0x36, 0x22, 0xfb, 0x98, 0xf9, 0xc7, 0x92, + 0xe1, 0xc3, 0x2f, 0x60, 0xd7, 0x6d, 0x63, 0xbf, 0xaf, 0xfd, 0x08, 0xea, 0xb3, 0x60, 0x77, 0x62, + 0x32, 0xb9, 0xf0, 0x1b, 0xbd, 0x02, 0xf9, 0x13, 0xc7, 0x1b, 0x62, 0xca, 0x9d, 0x95, 0x75, 0xd9, + 0x62, 0xdf, 0xae, 0x80, 0xe0, 0x2c, 0x17, 0x8b, 0x86, 0x66, 0xc0, 0x0b, 0x33, 0x41, 0x97, 0x99, + 0x58, 0xb6, 0x49, 0x44, 0x54, 0xcb, 0xba, 0x68, 0x44, 0x8e, 0xc4, 0x60, 0x45, 0x83, 0x75, 0xeb, + 0xf3, 0x19, 0x73, 0xff, 0xaa, 0x2e, 0x5b, 0xda, 0x9f, 0x55, 0x28, 0xea, 0xc4, 0x77, 0x19, 0x1e, + 0xa0, 0x36, 0xa8, 0xe4, 0xbc, 0x4b, 0x04, 0xad, 0x52, 0x16, 0x90, 0x10, 0x61, 0xb3, 0x17, 0xe8, + 0xb3, 0xac, 0x1f, 0x1a, 0xa3, 0xb7, 0x13, 0x94, 0xf2, 0xda, 0x22, 0x27, 0x71, 0x4e, 0xf9, 0x4e, + 0x92, 0x53, 0xbe, 0xbc, 0xc0, 0x76, 0x82, 0x54, 0xbe, 0x9d, 0x20, 0x95, 0x8b, 0x3a, 0x4e, 0xb0, + 0xca, 0xfd, 0x29, 0xac, 0x72, 0xd1, 0xf4, 0x67, 0xd0, 0xca, 0xfd, 0x29, 0xb4, 0xf2, 0xd6, 0xc2, + 0xb1, 0x4c, 0xe5, 0x95, 0xef, 0x24, 0x79, 0xe5, 0xa2, 0x70, 0x4c, 0x10, 0xcb, 0xfb, 0xd3, 0x88, + 0xe5, 0xed, 0x05, 0x3e, 0x66, 0x32, 0xcb, 0xdd, 0x0b, 0xcc, 0xf2, 0xc6, 0x02, 0x57, 0x53, 0xa8, + 0xe5, 0x7e, 0x82, 0x5a, 0x42, 0xaa, 0xd8, 0xcc, 0xe0, 0x96, 0xef, 0x5f, 0xe4, 0x96, 0x37, 0x17, + 0x7d, 0x6a, 0xd3, 0xc8, 0xe5, 0x77, 0x26, 0xc8, 0xe5, 0xf5, 0x45, 0xb3, 0x9a, 0x64, 0x97, 0x8f, + 0x66, 0xb0, 0xcb, 0xd7, 0x16, 0x38, 0x5a, 0x40, 0x2f, 0x1f, 0xcd, 0xa0, 0x97, 0x8b, 0xdc, 0x2e, + 0xe0, 0x97, 0x9d, 0x79, 0xfc, 0xf2, 0xce, 0xa2, 0x21, 0xa7, 0x23, 0x98, 0x64, 0x2e, 0xc1, 0x7c, + 0x7d, 0x41, 0x27, 0xcb, 0x33, 0xcc, 0xdb, 0x2c, 0xc7, 0x4f, 0x40, 0x12, 0x83, 0x42, 0xe2, 0x79, + 0x8e, 0x27, 0xc9, 0x9b, 0x68, 0x68, 0xb7, 0x18, 0xeb, 0x88, 0x80, 0x67, 0x0e, 0x1b, 0xe5, 0x89, + 0x27, 0x06, 0x33, 0xda, 0x1f, 0x95, 0xc8, 0x96, 0x67, 0xe7, 0x38, 0x63, 0x51, 0x25, 0x63, 0x89, + 0x91, 0xd4, 0x4c, 0x92, 0xa4, 0x6e, 0x42, 0x89, 0xa5, 0x92, 0x09, 0xfe, 0x89, 0xdd, 0x80, 0x7f, + 0xa2, 0x57, 0xe0, 0x12, 0xe7, 0x10, 0x82, 0xca, 0xca, 0xfc, 0x91, 0xe3, 0xc9, 0xb0, 0xca, 0x5e, + 0x88, 0x4f, 0x57, 0x24, 0x92, 0x6f, 0xc2, 0xe5, 0x98, 0x6e, 0x98, 0xa2, 0x04, 0xd1, 0xaa, 0x85, + 0xda, 0x4d, 0x99, 0xab, 0x1e, 0x44, 0x01, 0x8a, 0xb8, 0x2d, 0x82, 0x5c, 0xd7, 0x31, 0x89, 0x4c, + 0x20, 0xfc, 0x99, 0xf1, 0xdd, 0x81, 0xd3, 0x93, 0x69, 0x82, 0x3d, 0x32, 0xad, 0x10, 0x53, 0x55, + 0x01, 0x96, 0xda, 0x1f, 0x94, 0xc8, 0x5f, 0x44, 0x77, 0xa7, 0x31, 0x53, 0xe5, 0x59, 0x32, 0xd3, + 0xcc, 0xff, 0xc6, 0x4c, 0xb5, 0xff, 0x28, 0xd1, 0x92, 0x86, 0x9c, 0xf3, 0xeb, 0x85, 0x20, 0x4a, + 0xbf, 0xab, 0x7c, 0x81, 0x64, 0xfa, 0x95, 0xc7, 0x85, 0x3c, 0x5f, 0x86, 0xe4, 0x71, 0xa1, 0x20, + 0x12, 0x32, 0x6f, 0xa0, 0x37, 0x39, 0x57, 0x75, 0x4e, 0x24, 0x26, 0x27, 0x08, 0x89, 0x28, 0x10, + 0x6d, 0xc9, 0xca, 0xd0, 0x21, 0x53, 0xd3, 0x85, 0x76, 0x8c, 0x56, 0xa8, 0x09, 0xea, 0xfb, 0x22, + 0xa8, 0x6c, 0xe8, 0xbe, 0x8b, 0xbb, 0x84, 0x83, 0xaa, 0xaa, 0x47, 0x02, 0xcd, 0x04, 0x74, 0x11, + 0xdc, 0xd1, 0x01, 0xe4, 0xc9, 0x19, 0xb1, 0x29, 0x5b, 0x23, 0x16, 0xd6, 0x17, 0x67, 0x92, 0x49, + 0x62, 0xd3, 0x56, 0x9d, 0x05, 0xf3, 0x9f, 0x4f, 0x36, 0x6b, 0xc2, 0xe6, 0x35, 0x67, 0x68, 0x51, + 0x32, 0x74, 0xe9, 0x58, 0x97, 0x5e, 0xb4, 0x9f, 0x67, 0x18, 0xa7, 0x4b, 0x00, 0xff, 0xd4, 0xf0, + 0x06, 0x9b, 0x26, 0x13, 0xa3, 0xf9, 0xe9, 0x42, 0xfe, 0x12, 0x40, 0x0f, 0xfb, 0xc6, 0xe7, 0xd8, + 0xa6, 0xc4, 0x94, 0x71, 0x57, 0x7b, 0xd8, 0xff, 0x3e, 0x17, 0x30, 0xaa, 0xc6, 0x5e, 0x8f, 0x7c, + 0x62, 0xf2, 0x05, 0xc8, 0xea, 0x85, 0x1e, 0xf6, 0x1f, 0xf9, 0xc4, 0x8c, 0xcd, 0xb5, 0xf0, 0x2c, + 0xe6, 0x9a, 0x8c, 0x77, 0x71, 0x32, 0xde, 0xbf, 0xc8, 0x44, 0xbb, 0x23, 0xa2, 0xc0, 0xff, 0x9f, + 0xb1, 0xf8, 0x2d, 0x3f, 0x17, 0x27, 0xb3, 0x2f, 0xfa, 0x18, 0x2e, 0x85, 0xbb, 0xd2, 0x18, 0xf1, + 0xdd, 0x1a, 0x7c, 0x85, 0xcb, 0x6d, 0xee, 0xda, 0x59, 0x52, 0xec, 0xa3, 0x4f, 0xe0, 0xf9, 0x09, + 0x0c, 0x0a, 0x3b, 0xc8, 0x2c, 0x05, 0x45, 0xcf, 0x25, 0xa1, 0x28, 0xf0, 0x1f, 0x45, 0x2f, 0xfb, + 0x4c, 0x76, 0xcd, 0x3e, 0x3b, 0x86, 0xc5, 0x79, 0xc5, 0xd4, 0x6f, 0xe2, 0x1a, 0x94, 0x3d, 0x42, + 0xb1, 0x65, 0x1b, 0x89, 0x93, 0xef, 0x9a, 0x10, 0x8a, 0x94, 0xa0, 0x3d, 0x86, 0xe7, 0xa6, 0x32, + 0x0b, 0xf4, 0x2e, 0xa8, 0x11, 0x35, 0x51, 0xe6, 0x9e, 0x1c, 0xc3, 0x13, 0x50, 0x64, 0xa1, 0x7d, + 0xa1, 0x44, 0x8e, 0x93, 0x27, 0xab, 0x0f, 0x20, 0xef, 0x11, 0x7f, 0x34, 0x10, 0xa7, 0x9c, 0xca, + 0xce, 0x1b, 0xcb, 0x30, 0x13, 0x26, 0x1d, 0x0d, 0xa8, 0x2e, 0x5d, 0x68, 0x1f, 0x42, 0x5e, 0x48, + 0x10, 0x40, 0xbe, 0xb9, 0xbb, 0xbb, 0x77, 0x78, 0x5c, 0x5b, 0x41, 0x2a, 0xac, 0x36, 0x5b, 0x0f, + 0xf5, 0xe3, 0x9a, 0xc2, 0xc4, 0xfa, 0xde, 0xf7, 0xf6, 0x76, 0x8f, 0x6b, 0x19, 0x74, 0x09, 0xca, + 0xe2, 0xd9, 0x78, 0xff, 0xa1, 0xfe, 0xa0, 0x79, 0x5c, 0xcb, 0xc6, 0x44, 0x47, 0x7b, 0x07, 0xf7, + 0xf6, 0xf4, 0x5a, 0x4e, 0x7b, 0x9d, 0x9d, 0x9f, 0x66, 0x10, 0x97, 0xe8, 0xa4, 0xa4, 0xc4, 0x4e, + 0x4a, 0xda, 0xaf, 0x32, 0xd0, 0x98, 0xcd, 0x43, 0xd0, 0xe1, 0xc4, 0x8c, 0xdf, 0x5a, 0x9a, 0xca, + 0x4c, 0x4c, 0x1b, 0x5d, 0x87, 0x8a, 0x47, 0x4e, 0x08, 0xed, 0xf6, 0x05, 0x47, 0x12, 0x59, 0xae, + 0xac, 0x97, 0xa5, 0x94, 0x1b, 0xf9, 0x42, 0xed, 0x53, 0xd2, 0xa5, 0x86, 0x38, 0xba, 0x89, 0xef, + 0x4f, 0x65, 0x6a, 0x4c, 0x7a, 0x24, 0x84, 0xda, 0xd1, 0xa2, 0x20, 0xaa, 0xb0, 0xaa, 0xef, 0x1d, + 0xeb, 0x1f, 0xd7, 0x32, 0x08, 0x41, 0x85, 0x3f, 0x1a, 0x47, 0x07, 0xcd, 0xc3, 0xa3, 0xf6, 0x43, + 0x16, 0xc4, 0xcb, 0x50, 0x0d, 0x82, 0x18, 0x08, 0x73, 0xda, 0x5f, 0x15, 0xa8, 0x4e, 0x6c, 0x0f, + 0xf4, 0x16, 0xac, 0x0a, 0xe2, 0xad, 0xcc, 0xad, 0xdf, 0xf3, 0xfd, 0x2e, 0x77, 0x94, 0x30, 0x40, + 0x4d, 0x28, 0x12, 0x59, 0x9f, 0x90, 0x5b, 0xf2, 0xfa, 0x82, 0x32, 0x86, 0xb4, 0x0f, 0xcd, 0xd0, + 0x3d, 0x50, 0xc3, 0x8d, 0xbf, 0xa0, 0xf6, 0x15, 0xe2, 0x86, 0x74, 0x12, 0x19, 0x6a, 0xbb, 0x50, + 0x8a, 0x0d, 0x0f, 0x7d, 0x03, 0xd4, 0x21, 0x3e, 0x97, 0x05, 0x2b, 0x51, 0x82, 0x28, 0x0e, 0xf1, + 0x39, 0xaf, 0x55, 0xa1, 0xe7, 0xa1, 0xc0, 0x5e, 0xf6, 0xb0, 0x80, 0x91, 0xac, 0x9e, 0x1f, 0xe2, + 0xf3, 0xef, 0x62, 0x5f, 0xfb, 0x9d, 0x02, 0x95, 0xe4, 0x38, 0xd1, 0xab, 0x80, 0x98, 0x2e, 0xee, + 0x11, 0xc3, 0x1e, 0x0d, 0x05, 0x43, 0x0b, 0x3c, 0x56, 0x87, 0xf8, 0xbc, 0xd9, 0x23, 0x07, 0xa3, + 0x21, 0xef, 0xda, 0x47, 0x0f, 0xa0, 0x16, 0x28, 0x07, 0x3f, 0xf6, 0xc8, 0xa8, 0xbc, 0x70, 0xa1, + 0x5c, 0x78, 0x4f, 0x2a, 0x88, 0x6a, 0xe1, 0x6f, 0xbe, 0xda, 0x54, 0xf4, 0x8a, 0xf0, 0x17, 0xbc, + 0x09, 0xc6, 0x69, 0x8f, 0x86, 0xb2, 0x92, 0xc0, 0xc6, 0x79, 0x30, 0x1a, 0x6a, 0x6f, 0x42, 0x75, + 0x22, 0x14, 0x48, 0x83, 0xb2, 0x3b, 0xea, 0x18, 0xa7, 0x64, 0x6c, 0xf0, 0x58, 0x71, 0x68, 0x50, + 0xf5, 0x92, 0x3b, 0xea, 0x7c, 0x40, 0xc6, 0xc7, 0x4c, 0xa4, 0x75, 0xa1, 0x92, 0xac, 0x53, 0xb1, + 0x6d, 0xe3, 0x39, 0x23, 0xdb, 0xe4, 0x13, 0x5a, 0xd5, 0x45, 0x03, 0xdd, 0x85, 0xd5, 0x33, 0x47, + 0x80, 0xec, 0x3c, 0x78, 0x79, 0xec, 0x50, 0x12, 0xab, 0x76, 0x09, 0x1b, 0xed, 0x80, 0x85, 0x90, + 0xd8, 0xb4, 0x49, 0xa9, 0x67, 0x75, 0x46, 0x94, 0xc4, 0xab, 0xae, 0x6b, 0x53, 0xaa, 0xae, 0x21, + 0x8d, 0x0a, 0x49, 0x58, 0x56, 0x94, 0xfc, 0x78, 0x43, 0xfb, 0xa9, 0x02, 0xab, 0xdc, 0x21, 0xc3, + 0x52, 0x5e, 0xc2, 0x92, 0x04, 0x9d, 0x3d, 0xa3, 0x2e, 0x00, 0x0e, 0x3a, 0x0a, 0xc6, 0x7b, 0x7d, + 0x1e, 0x8a, 0x87, 0xc3, 0x6a, 0xbd, 0x28, 0xe1, 0x7c, 0x3d, 0x72, 0x10, 0x83, 0xf4, 0x98, 0x5b, + 0xed, 0xdf, 0x39, 0xc8, 0x8b, 0x3a, 0x21, 0x7a, 0x2f, 0x59, 0xb5, 0x2e, 0xed, 0x6c, 0xcc, 0x0a, + 0x8e, 0xd0, 0x92, 0xb1, 0x09, 0x8f, 0x0d, 0x37, 0x26, 0x4b, 0xc1, 0xad, 0xd2, 0xd3, 0x27, 0x9b, + 0x05, 0x4e, 0xb9, 0xf7, 0xef, 0x45, 0x75, 0xe1, 0x59, 0x65, 0xd1, 0xa0, 0x08, 0x9d, 0x5b, 0xba, + 0x08, 0xdd, 0x86, 0x72, 0xec, 0x8c, 0x61, 0x99, 0xb2, 0x2a, 0xb2, 0x31, 0x6f, 0xaf, 0xef, 0xdf, + 0x93, 0xe3, 0x2f, 0x85, 0x67, 0x90, 0x7d, 0x13, 0xdd, 0x4a, 0x56, 0x47, 0xf9, 0x51, 0x45, 0x70, + 0xe4, 0x58, 0xc1, 0x93, 0x1d, 0x54, 0xd8, 0x2e, 0x64, 0x19, 0x4f, 0xa8, 0x08, 0xca, 0x5c, 0x64, + 0x02, 0xfe, 0xf2, 0x26, 0x54, 0x23, 0x36, 0x2f, 0x54, 0x8a, 0xc2, 0x4b, 0x24, 0xe6, 0x8a, 0x77, + 0x60, 0xdd, 0x26, 0xe7, 0xd4, 0x98, 0xd4, 0x56, 0xb9, 0x36, 0x62, 0xef, 0x1e, 0x27, 0x2d, 0xae, + 0x43, 0x25, 0xe2, 0x0d, 0x5c, 0x17, 0x44, 0xcd, 0x3a, 0x94, 0x72, 0xb5, 0x78, 0x39, 0xb0, 0x94, + 0x28, 0x07, 0x86, 0xa7, 0x37, 0x81, 0xeb, 0xd2, 0xc9, 0x1a, 0xd7, 0xe1, 0xa7, 0x37, 0x81, 0xcb, + 0xc2, 0xcd, 0x35, 0x28, 0x07, 0x60, 0x26, 0xf4, 0xca, 0x5c, 0x6f, 0x2d, 0x10, 0x72, 0xa5, 0xdb, + 0x50, 0x73, 0x3d, 0xc7, 0x75, 0x7c, 0xe2, 0x19, 0xd8, 0x34, 0x3d, 0xe2, 0xfb, 0xbc, 0x02, 0xb0, + 0xa6, 0x57, 0x03, 0x79, 0x53, 0x88, 0xb5, 0xd7, 0xa1, 0x10, 0x1c, 0x22, 0xd7, 0x61, 0xb5, 0x15, + 0x02, 0x73, 0x4e, 0x17, 0x0d, 0xb6, 0xa1, 0x9a, 0xae, 0x2b, 0x7f, 0x16, 0x61, 0x8f, 0xda, 0x00, + 0x0a, 0x72, 0xc1, 0xa6, 0x16, 0xc3, 0x1f, 0xc0, 0x9a, 0x8b, 0x3d, 0x36, 0x8d, 0x78, 0x49, 0x7c, + 0x56, 0xfd, 0xe9, 0x10, 0x7b, 0xf4, 0x88, 0xd0, 0x44, 0x65, 0xbc, 0xc4, 0xed, 0x85, 0x48, 0x7b, + 0x1b, 0xca, 0x09, 0x1d, 0x36, 0x4c, 0xea, 0x50, 0x3c, 0x08, 0x60, 0x84, 0x37, 0xc2, 0x91, 0x64, + 0xa2, 0x91, 0x68, 0x77, 0x41, 0x0d, 0xd7, 0x8a, 0x9d, 0xae, 0x83, 0x50, 0x28, 0x32, 0xfc, 0xa2, + 0xc9, 0xab, 0xff, 0xce, 0xe7, 0xb2, 0xc2, 0x99, 0xd5, 0x45, 0x43, 0x23, 0x31, 0xd8, 0x13, 0x14, + 0x0e, 0xbd, 0x03, 0x05, 0x09, 0x7b, 0x72, 0x3f, 0xce, 0xaa, 0xf3, 0x1f, 0x72, 0x1c, 0x0c, 0xea, + 0xfc, 0x02, 0x15, 0xa3, 0x6e, 0x32, 0xf1, 0x6e, 0x7e, 0x02, 0xc5, 0x00, 0xda, 0x92, 0xc9, 0x49, + 0xf4, 0x70, 0x75, 0x51, 0x72, 0x92, 0x9d, 0x44, 0x86, 0xec, 0x6b, 0xf2, 0xad, 0x9e, 0x4d, 0x4c, + 0x23, 0xda, 0x82, 0xbc, 0xcf, 0xa2, 0x5e, 0x15, 0x2f, 0xee, 0x07, 0xfb, 0x4b, 0xbb, 0x03, 0x79, + 0x31, 0xd6, 0xa9, 0x78, 0x37, 0x85, 0x4f, 0x6a, 0xff, 0x50, 0xa0, 0x18, 0x64, 0xad, 0xa9, 0x46, + 0x89, 0x49, 0x64, 0xbe, 0xee, 0x24, 0x9e, 0x3d, 0x24, 0xbd, 0x06, 0x88, 0x7f, 0x29, 0xc6, 0x99, + 0x43, 0x2d, 0xbb, 0x67, 0x88, 0xb5, 0x10, 0xc7, 0x9f, 0x1a, 0x7f, 0xf3, 0x98, 0xbf, 0x38, 0xe4, + 0xcb, 0xf2, 0x33, 0x05, 0x8a, 0x21, 0x59, 0x5d, 0xb6, 0x24, 0x7f, 0x05, 0xf2, 0x92, 0x90, 0xc9, + 0x4c, 0x2a, 0x5a, 0xe1, 0x37, 0x9a, 0x8b, 0xed, 0x96, 0x06, 0x14, 0x87, 0x84, 0x62, 0x1e, 0x67, + 0x51, 0x82, 0x09, 0xdb, 0xaf, 0x5c, 0x83, 0x52, 0xec, 0x37, 0x12, 0x54, 0x80, 0xec, 0x01, 0xf9, + 0xbc, 0xb6, 0x82, 0x4a, 0x50, 0xd0, 0x09, 0x2f, 0x8b, 0xd6, 0x94, 0x9d, 0x2f, 0x4a, 0x50, 0x6d, + 0xb6, 0x76, 0xf7, 0x19, 0x5f, 0xb4, 0xba, 0x22, 0x97, 0x3f, 0x84, 0x1c, 0xaf, 0x50, 0xa5, 0xb8, + 0x92, 0xd1, 0x48, 0x53, 0x63, 0x47, 0x3a, 0xac, 0xf2, 0x42, 0x16, 0x4a, 0x73, 0x53, 0xa3, 0x91, + 0xaa, 0xf4, 0xce, 0x06, 0xc9, 0xbf, 0xfa, 0x14, 0x17, 0x38, 0x1a, 0x69, 0xea, 0xf1, 0xe8, 0x13, + 0x50, 0xa3, 0x0a, 0x55, 0xda, 0x6b, 0x1d, 0x8d, 0xd4, 0x95, 0x7a, 0xe6, 0x3f, 0x3a, 0x93, 0xa7, + 0xbd, 0xd4, 0xd0, 0x48, 0x5d, 0xa2, 0x46, 0x1f, 0x41, 0x21, 0xa8, 0x7e, 0xa4, 0xbb, 0x78, 0xd1, + 0x48, 0x59, 0x45, 0x67, 0xcb, 0x27, 0x8a, 0x56, 0x69, 0x6e, 0x97, 0x34, 0x52, 0xfd, 0x54, 0x80, + 0x1e, 0x41, 0x5e, 0x1e, 0x3b, 0x53, 0x5d, 0xa9, 0x68, 0xa4, 0xab, 0x8d, 0xb3, 0x20, 0x47, 0x65, + 0xc1, 0xb4, 0x37, 0x6a, 0x1a, 0xa9, 0x7f, 0x23, 0x41, 0x18, 0x20, 0x56, 0xc9, 0x4a, 0x7d, 0x55, + 0xa6, 0x91, 0xfe, 0xb7, 0x0f, 0xf4, 0x43, 0x28, 0x86, 0xf5, 0x8a, 0x94, 0x57, 0x56, 0x1a, 0x69, + 0x7f, 0x7e, 0x40, 0x9f, 0x42, 0x39, 0x79, 0x44, 0x5f, 0xe6, 0x22, 0x4a, 0x63, 0xa9, 0xdf, 0x15, + 0x58, 0x5f, 0xc9, 0x53, 0xfb, 0x32, 0xd7, 0x53, 0x1a, 0x4b, 0xfd, 0xd8, 0x80, 0xce, 0xe0, 0xd2, + 0xc5, 0x83, 0xf6, 0xb2, 0x77, 0x56, 0x1a, 0x4b, 0xff, 0x08, 0x81, 0xc6, 0x80, 0xa6, 0x1c, 0xd6, + 0x97, 0xbe, 0xc8, 0xd2, 0x58, 0xfe, 0x97, 0x89, 0xd6, 0xbb, 0x5f, 0x3e, 0xdd, 0x50, 0xfe, 0xf2, + 0x74, 0x43, 0xf9, 0xdb, 0xd3, 0x0d, 0xe5, 0x4f, 0x7f, 0xdf, 0x50, 0x7e, 0xf0, 0x6a, 0xcf, 0xa2, + 0xfd, 0x51, 0x67, 0xab, 0xeb, 0x0c, 0xb7, 0x23, 0x77, 0xf1, 0xc7, 0xe8, 0xc6, 0x60, 0x27, 0xcf, + 0x93, 0xde, 0x1b, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x7c, 0xe1, 0x09, 0x39, 0x46, 0x28, 0x00, 0x00, } -func (this *Request) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request) - if !ok { - that2, ok := that.(Request) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if that1.Value == nil { - if this.Value != nil { - return false - } - } else if this.Value == nil { - return false - } else if !this.Value.Equal(that1.Value) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *Request_Echo) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_Echo) - if !ok { - that2, ok := that.(Request_Echo) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Echo.Equal(that1.Echo) { - return false - } - return true -} -func (this *Request_Flush) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_Flush) - if !ok { - that2, ok := that.(Request_Flush) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Flush.Equal(that1.Flush) { - return false - } - return true -} -func (this *Request_Info) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_Info) - if !ok { - that2, ok := that.(Request_Info) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Info.Equal(that1.Info) { - return false - } - return true -} -func (this *Request_SetOption) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_SetOption) - if !ok { - that2, ok := that.(Request_SetOption) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.SetOption.Equal(that1.SetOption) { - return false - } - return true -} -func (this *Request_InitChain) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_InitChain) - if !ok { - that2, ok := that.(Request_InitChain) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.InitChain.Equal(that1.InitChain) { - return false - } - return true -} -func (this *Request_Query) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_Query) - if !ok { - that2, ok := that.(Request_Query) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Query.Equal(that1.Query) { - return false - } - return true -} -func (this *Request_BeginBlock) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_BeginBlock) - if !ok { - that2, ok := that.(Request_BeginBlock) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.BeginBlock.Equal(that1.BeginBlock) { - return false - } - return true -} -func (this *Request_CheckTx) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_CheckTx) - if !ok { - that2, ok := that.(Request_CheckTx) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.CheckTx.Equal(that1.CheckTx) { - return false - } - return true -} -func (this *Request_DeliverTx) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_DeliverTx) - if !ok { - that2, ok := that.(Request_DeliverTx) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.DeliverTx.Equal(that1.DeliverTx) { - return false - } - return true -} -func (this *Request_EndBlock) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_EndBlock) - if !ok { - that2, ok := that.(Request_EndBlock) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.EndBlock.Equal(that1.EndBlock) { - return false - } - return true -} -func (this *Request_Commit) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_Commit) - if !ok { - that2, ok := that.(Request_Commit) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Commit.Equal(that1.Commit) { - return false - } - return true -} -func (this *Request_ListSnapshots) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_ListSnapshots) - if !ok { - that2, ok := that.(Request_ListSnapshots) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.ListSnapshots.Equal(that1.ListSnapshots) { - return false - } - return true -} -func (this *Request_OfferSnapshot) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_OfferSnapshot) - if !ok { - that2, ok := that.(Request_OfferSnapshot) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.OfferSnapshot.Equal(that1.OfferSnapshot) { - return false - } - return true -} -func (this *Request_LoadSnapshotChunk) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_LoadSnapshotChunk) - if !ok { - that2, ok := that.(Request_LoadSnapshotChunk) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.LoadSnapshotChunk.Equal(that1.LoadSnapshotChunk) { - return false - } - return true -} -func (this *Request_ApplySnapshotChunk) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Request_ApplySnapshotChunk) - if !ok { - that2, ok := that.(Request_ApplySnapshotChunk) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.ApplySnapshotChunk.Equal(that1.ApplySnapshotChunk) { - return false - } - return true -} -func (this *RequestEcho) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestEcho) - if !ok { - that2, ok := that.(RequestEcho) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Message != that1.Message { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestFlush) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestFlush) - if !ok { - that2, ok := that.(RequestFlush) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestInfo) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestInfo) - if !ok { - that2, ok := that.(RequestInfo) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Version != that1.Version { - return false - } - if this.BlockVersion != that1.BlockVersion { - return false - } - if this.P2PVersion != that1.P2PVersion { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestSetOption) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestSetOption) - if !ok { - that2, ok := that.(RequestSetOption) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Key != that1.Key { - return false - } - if this.Value != that1.Value { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestInitChain) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestInitChain) - if !ok { - that2, ok := that.(RequestInitChain) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Time.Equal(that1.Time) { - return false - } - if this.ChainId != that1.ChainId { - return false - } - if !this.ConsensusParams.Equal(that1.ConsensusParams) { - return false - } - if len(this.Validators) != len(that1.Validators) { - return false - } - for i := range this.Validators { - if !this.Validators[i].Equal(&that1.Validators[i]) { - return false - } - } - if !bytes.Equal(this.AppStateBytes, that1.AppStateBytes) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestQuery) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestQuery) - if !ok { - that2, ok := that.(RequestQuery) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Data, that1.Data) { - return false - } - if this.Path != that1.Path { - return false - } - if this.Height != that1.Height { - return false - } - if this.Prove != that1.Prove { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestBeginBlock) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestBeginBlock) - if !ok { - that2, ok := that.(RequestBeginBlock) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Hash, that1.Hash) { - return false - } - if !this.Header.Equal(&that1.Header) { - return false - } - if !this.LastCommitInfo.Equal(&that1.LastCommitInfo) { - return false - } - if len(this.ByzantineValidators) != len(that1.ByzantineValidators) { - return false - } - for i := range this.ByzantineValidators { - if !this.ByzantineValidators[i].Equal(&that1.ByzantineValidators[i]) { - return false - } - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestCheckTx) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestCheckTx) - if !ok { - that2, ok := that.(RequestCheckTx) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Tx, that1.Tx) { - return false - } - if this.Type != that1.Type { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestDeliverTx) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestDeliverTx) - if !ok { - that2, ok := that.(RequestDeliverTx) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Tx, that1.Tx) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestEndBlock) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestEndBlock) - if !ok { - that2, ok := that.(RequestEndBlock) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Height != that1.Height { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestCommit) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestCommit) - if !ok { - that2, ok := that.(RequestCommit) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestListSnapshots) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestListSnapshots) - if !ok { - that2, ok := that.(RequestListSnapshots) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestOfferSnapshot) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestOfferSnapshot) - if !ok { - that2, ok := that.(RequestOfferSnapshot) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Snapshot.Equal(that1.Snapshot) { - return false - } - if !bytes.Equal(this.AppHash, that1.AppHash) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestLoadSnapshotChunk) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestLoadSnapshotChunk) - if !ok { - that2, ok := that.(RequestLoadSnapshotChunk) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Height != that1.Height { - return false - } - if this.Format != that1.Format { - return false - } - if this.Chunk != that1.Chunk { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestApplySnapshotChunk) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestApplySnapshotChunk) - if !ok { - that2, ok := that.(RequestApplySnapshotChunk) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Index != that1.Index { - return false - } - if !bytes.Equal(this.Chunk, that1.Chunk) { - return false - } - if this.Sender != that1.Sender { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *Response) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response) - if !ok { - that2, ok := that.(Response) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if that1.Value == nil { - if this.Value != nil { - return false - } - } else if this.Value == nil { - return false - } else if !this.Value.Equal(that1.Value) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *Response_Exception) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_Exception) - if !ok { - that2, ok := that.(Response_Exception) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Exception.Equal(that1.Exception) { - return false - } - return true -} -func (this *Response_Echo) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_Echo) - if !ok { - that2, ok := that.(Response_Echo) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Echo.Equal(that1.Echo) { - return false - } - return true -} -func (this *Response_Flush) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_Flush) - if !ok { - that2, ok := that.(Response_Flush) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Flush.Equal(that1.Flush) { - return false - } - return true -} -func (this *Response_Info) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_Info) - if !ok { - that2, ok := that.(Response_Info) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Info.Equal(that1.Info) { - return false - } - return true -} -func (this *Response_SetOption) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_SetOption) - if !ok { - that2, ok := that.(Response_SetOption) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.SetOption.Equal(that1.SetOption) { - return false - } - return true -} -func (this *Response_InitChain) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_InitChain) - if !ok { - that2, ok := that.(Response_InitChain) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.InitChain.Equal(that1.InitChain) { - return false - } - return true -} -func (this *Response_Query) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_Query) - if !ok { - that2, ok := that.(Response_Query) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Query.Equal(that1.Query) { - return false - } - return true -} -func (this *Response_BeginBlock) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_BeginBlock) - if !ok { - that2, ok := that.(Response_BeginBlock) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.BeginBlock.Equal(that1.BeginBlock) { - return false - } - return true -} -func (this *Response_CheckTx) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_CheckTx) - if !ok { - that2, ok := that.(Response_CheckTx) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.CheckTx.Equal(that1.CheckTx) { - return false - } - return true -} -func (this *Response_DeliverTx) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_DeliverTx) - if !ok { - that2, ok := that.(Response_DeliverTx) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.DeliverTx.Equal(that1.DeliverTx) { - return false - } - return true -} -func (this *Response_EndBlock) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_EndBlock) - if !ok { - that2, ok := that.(Response_EndBlock) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.EndBlock.Equal(that1.EndBlock) { - return false - } - return true -} -func (this *Response_Commit) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_Commit) - if !ok { - that2, ok := that.(Response_Commit) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Commit.Equal(that1.Commit) { - return false - } - return true -} -func (this *Response_ListSnapshots) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_ListSnapshots) - if !ok { - that2, ok := that.(Response_ListSnapshots) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.ListSnapshots.Equal(that1.ListSnapshots) { - return false - } - return true -} -func (this *Response_OfferSnapshot) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_OfferSnapshot) - if !ok { - that2, ok := that.(Response_OfferSnapshot) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.OfferSnapshot.Equal(that1.OfferSnapshot) { - return false - } - return true -} -func (this *Response_LoadSnapshotChunk) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_LoadSnapshotChunk) - if !ok { - that2, ok := that.(Response_LoadSnapshotChunk) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.LoadSnapshotChunk.Equal(that1.LoadSnapshotChunk) { - return false - } - return true -} -func (this *Response_ApplySnapshotChunk) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Response_ApplySnapshotChunk) - if !ok { - that2, ok := that.(Response_ApplySnapshotChunk) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.ApplySnapshotChunk.Equal(that1.ApplySnapshotChunk) { - return false - } - return true -} -func (this *ResponseException) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseException) - if !ok { - that2, ok := that.(ResponseException) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Error != that1.Error { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseEcho) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseEcho) - if !ok { - that2, ok := that.(ResponseEcho) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Message != that1.Message { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseFlush) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseFlush) - if !ok { - that2, ok := that.(ResponseFlush) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseInfo) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseInfo) - if !ok { - that2, ok := that.(ResponseInfo) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Data != that1.Data { - return false - } - if this.Version != that1.Version { - return false - } - if this.AppVersion != that1.AppVersion { - return false - } - if this.LastBlockHeight != that1.LastBlockHeight { - return false - } - if !bytes.Equal(this.LastBlockAppHash, that1.LastBlockAppHash) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseSetOption) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseSetOption) - if !ok { - that2, ok := that.(ResponseSetOption) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Code != that1.Code { - return false - } - if this.Log != that1.Log { - return false - } - if this.Info != that1.Info { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseInitChain) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseInitChain) - if !ok { - that2, ok := that.(ResponseInitChain) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.ConsensusParams.Equal(that1.ConsensusParams) { - return false - } - if len(this.Validators) != len(that1.Validators) { - return false - } - for i := range this.Validators { - if !this.Validators[i].Equal(&that1.Validators[i]) { - return false - } - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseQuery) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseQuery) - if !ok { - that2, ok := that.(ResponseQuery) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Code != that1.Code { - return false - } - if this.Log != that1.Log { - return false - } - if this.Info != that1.Info { - return false - } - if this.Index != that1.Index { - return false - } - if !bytes.Equal(this.Key, that1.Key) { - return false - } - if !bytes.Equal(this.Value, that1.Value) { - return false - } - if !this.Proof.Equal(that1.Proof) { - return false - } - if this.Height != that1.Height { - return false - } - if this.Codespace != that1.Codespace { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseBeginBlock) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseBeginBlock) - if !ok { - that2, ok := that.(ResponseBeginBlock) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if len(this.Events) != len(that1.Events) { - return false - } - for i := range this.Events { - if !this.Events[i].Equal(&that1.Events[i]) { - return false - } - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseCheckTx) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseCheckTx) - if !ok { - that2, ok := that.(ResponseCheckTx) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Code != that1.Code { - return false - } - if !bytes.Equal(this.Data, that1.Data) { - return false - } - if this.Log != that1.Log { - return false - } - if this.Info != that1.Info { - return false - } - if this.GasWanted != that1.GasWanted { - return false - } - if this.GasUsed != that1.GasUsed { - return false - } - if len(this.Events) != len(that1.Events) { - return false - } - for i := range this.Events { - if !this.Events[i].Equal(&that1.Events[i]) { - return false - } - } - if this.Codespace != that1.Codespace { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseDeliverTx) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseDeliverTx) - if !ok { - that2, ok := that.(ResponseDeliverTx) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Code != that1.Code { - return false - } - if !bytes.Equal(this.Data, that1.Data) { - return false - } - if this.Log != that1.Log { - return false - } - if this.Info != that1.Info { - return false - } - if this.GasWanted != that1.GasWanted { - return false - } - if this.GasUsed != that1.GasUsed { - return false - } - if len(this.Events) != len(that1.Events) { - return false - } - for i := range this.Events { - if !this.Events[i].Equal(&that1.Events[i]) { - return false - } - } - if this.Codespace != that1.Codespace { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseEndBlock) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseEndBlock) - if !ok { - that2, ok := that.(ResponseEndBlock) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if len(this.ValidatorUpdates) != len(that1.ValidatorUpdates) { - return false - } - for i := range this.ValidatorUpdates { - if !this.ValidatorUpdates[i].Equal(&that1.ValidatorUpdates[i]) { - return false - } - } - if !this.ConsensusParamUpdates.Equal(that1.ConsensusParamUpdates) { - return false - } - if len(this.Events) != len(that1.Events) { - return false - } - for i := range this.Events { - if !this.Events[i].Equal(&that1.Events[i]) { - return false - } - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseCommit) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseCommit) - if !ok { - that2, ok := that.(ResponseCommit) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Data, that1.Data) { - return false - } - if this.RetainHeight != that1.RetainHeight { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseListSnapshots) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseListSnapshots) - if !ok { - that2, ok := that.(ResponseListSnapshots) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if len(this.Snapshots) != len(that1.Snapshots) { - return false - } - for i := range this.Snapshots { - if !this.Snapshots[i].Equal(that1.Snapshots[i]) { - return false - } - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseOfferSnapshot) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseOfferSnapshot) - if !ok { - that2, ok := that.(ResponseOfferSnapshot) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Result != that1.Result { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseLoadSnapshotChunk) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseLoadSnapshotChunk) - if !ok { - that2, ok := that.(ResponseLoadSnapshotChunk) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Chunk, that1.Chunk) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseApplySnapshotChunk) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseApplySnapshotChunk) - if !ok { - that2, ok := that.(ResponseApplySnapshotChunk) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Result != that1.Result { - return false - } - if len(this.RefetchChunks) != len(that1.RefetchChunks) { - return false - } - for i := range this.RefetchChunks { - if this.RefetchChunks[i] != that1.RefetchChunks[i] { - return false - } - } - if len(this.RejectSenders) != len(that1.RejectSenders) { - return false - } - for i := range this.RejectSenders { - if this.RejectSenders[i] != that1.RejectSenders[i] { - return false - } - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ConsensusParams) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ConsensusParams) - if !ok { - that2, ok := that.(ConsensusParams) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Block.Equal(that1.Block) { - return false - } - if !this.Evidence.Equal(that1.Evidence) { - return false - } - if !this.Validator.Equal(that1.Validator) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *BlockParams) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*BlockParams) - if !ok { - that2, ok := that.(BlockParams) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.MaxBytes != that1.MaxBytes { - return false - } - if this.MaxGas != that1.MaxGas { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *EvidenceParams) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*EvidenceParams) - if !ok { - that2, ok := that.(EvidenceParams) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.MaxAgeNumBlocks != that1.MaxAgeNumBlocks { - return false - } - if this.MaxAgeDuration != that1.MaxAgeDuration { - return false - } - if this.MaxNum != that1.MaxNum { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ValidatorParams) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ValidatorParams) - if !ok { - that2, ok := that.(ValidatorParams) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if len(this.PubKeyTypes) != len(that1.PubKeyTypes) { - return false - } - for i := range this.PubKeyTypes { - if this.PubKeyTypes[i] != that1.PubKeyTypes[i] { - return false - } - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *LastCommitInfo) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*LastCommitInfo) - if !ok { - that2, ok := that.(LastCommitInfo) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Round != that1.Round { - return false - } - if len(this.Votes) != len(that1.Votes) { - return false - } - for i := range this.Votes { - if !this.Votes[i].Equal(&that1.Votes[i]) { - return false - } - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *EventAttribute) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*EventAttribute) - if !ok { - that2, ok := that.(EventAttribute) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Key, that1.Key) { - return false - } - if !bytes.Equal(this.Value, that1.Value) { - return false - } - if this.Index != that1.Index { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *Event) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Event) - if !ok { - that2, ok := that.(Event) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Type != that1.Type { - return false - } - if len(this.Attributes) != len(that1.Attributes) { - return false - } - for i := range this.Attributes { - if !this.Attributes[i].Equal(&that1.Attributes[i]) { - return false - } - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *Header) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Header) - if !ok { - that2, ok := that.(Header) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Version.Equal(&that1.Version) { - return false - } - if this.ChainID != that1.ChainID { - return false - } - if this.Height != that1.Height { - return false - } - if !this.Time.Equal(that1.Time) { - return false - } - if !this.LastBlockId.Equal(&that1.LastBlockId) { - return false - } - if !bytes.Equal(this.LastCommitHash, that1.LastCommitHash) { - return false - } - if !bytes.Equal(this.DataHash, that1.DataHash) { - return false - } - if !bytes.Equal(this.ValidatorsHash, that1.ValidatorsHash) { - return false - } - if !bytes.Equal(this.NextValidatorsHash, that1.NextValidatorsHash) { - return false - } - if !bytes.Equal(this.ConsensusHash, that1.ConsensusHash) { - return false - } - if !bytes.Equal(this.AppHash, that1.AppHash) { - return false - } - if !bytes.Equal(this.LastResultsHash, that1.LastResultsHash) { - return false - } - if !bytes.Equal(this.EvidenceHash, that1.EvidenceHash) { - return false - } - if !bytes.Equal(this.ProposerAddress, that1.ProposerAddress) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *Version) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Version) - if !ok { - that2, ok := that.(Version) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Block != that1.Block { - return false - } - if this.App != that1.App { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *BlockID) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*BlockID) - if !ok { - that2, ok := that.(BlockID) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Hash, that1.Hash) { - return false - } - if !this.PartsHeader.Equal(&that1.PartsHeader) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *PartSetHeader) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*PartSetHeader) - if !ok { - that2, ok := that.(PartSetHeader) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Total != that1.Total { - return false - } - if !bytes.Equal(this.Hash, that1.Hash) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *Validator) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Validator) - if !ok { - that2, ok := that.(Validator) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Address, that1.Address) { - return false - } - if this.Power != that1.Power { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ValidatorUpdate) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ValidatorUpdate) - if !ok { - that2, ok := that.(ValidatorUpdate) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.PubKey.Equal(&that1.PubKey) { - return false - } - if this.Power != that1.Power { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *VoteInfo) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*VoteInfo) - if !ok { - that2, ok := that.(VoteInfo) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.Validator.Equal(&that1.Validator) { - return false - } - if this.SignedLastBlock != that1.SignedLastBlock { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *PubKey) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*PubKey) - if !ok { - that2, ok := that.(PubKey) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Type != that1.Type { - return false - } - if !bytes.Equal(this.Data, that1.Data) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *Evidence) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Evidence) - if !ok { - that2, ok := that.(Evidence) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Type != that1.Type { - return false - } - if !this.Validator.Equal(&that1.Validator) { - return false - } - if this.Height != that1.Height { - return false - } - if !this.Time.Equal(that1.Time) { - return false - } - if this.TotalVotingPower != that1.TotalVotingPower { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *Snapshot) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Snapshot) - if !ok { - that2, ok := that.(Snapshot) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Height != that1.Height { - return false - } - if this.Format != that1.Format { - return false - } - if this.Chunks != that1.Chunks { - return false - } - if !bytes.Equal(this.Hash, that1.Hash) { - return false - } - if !bytes.Equal(this.Metadata, that1.Metadata) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} - // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn @@ -10013,1135 +7574,6 @@ func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } -func NewPopulatedRequest(r randyTypes, easy bool) *Request { - this := &Request{} - oneofNumber_Value := []int32{2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 19}[r.Intn(15)] - switch oneofNumber_Value { - case 2: - this.Value = NewPopulatedRequest_Echo(r, easy) - case 3: - this.Value = NewPopulatedRequest_Flush(r, easy) - case 4: - this.Value = NewPopulatedRequest_Info(r, easy) - case 5: - this.Value = NewPopulatedRequest_SetOption(r, easy) - case 6: - this.Value = NewPopulatedRequest_InitChain(r, easy) - case 7: - this.Value = NewPopulatedRequest_Query(r, easy) - case 8: - this.Value = NewPopulatedRequest_BeginBlock(r, easy) - case 9: - this.Value = NewPopulatedRequest_CheckTx(r, easy) - case 11: - this.Value = NewPopulatedRequest_EndBlock(r, easy) - case 12: - this.Value = NewPopulatedRequest_Commit(r, easy) - case 13: - this.Value = NewPopulatedRequest_ListSnapshots(r, easy) - case 14: - this.Value = NewPopulatedRequest_OfferSnapshot(r, easy) - case 15: - this.Value = NewPopulatedRequest_LoadSnapshotChunk(r, easy) - case 16: - this.Value = NewPopulatedRequest_ApplySnapshotChunk(r, easy) - case 19: - this.Value = NewPopulatedRequest_DeliverTx(r, easy) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 20) - } - return this -} - -func NewPopulatedRequest_Echo(r randyTypes, easy bool) *Request_Echo { - this := &Request_Echo{} - this.Echo = NewPopulatedRequestEcho(r, easy) - return this -} -func NewPopulatedRequest_Flush(r randyTypes, easy bool) *Request_Flush { - this := &Request_Flush{} - this.Flush = NewPopulatedRequestFlush(r, easy) - return this -} -func NewPopulatedRequest_Info(r randyTypes, easy bool) *Request_Info { - this := &Request_Info{} - this.Info = NewPopulatedRequestInfo(r, easy) - return this -} -func NewPopulatedRequest_SetOption(r randyTypes, easy bool) *Request_SetOption { - this := &Request_SetOption{} - this.SetOption = NewPopulatedRequestSetOption(r, easy) - return this -} -func NewPopulatedRequest_InitChain(r randyTypes, easy bool) *Request_InitChain { - this := &Request_InitChain{} - this.InitChain = NewPopulatedRequestInitChain(r, easy) - return this -} -func NewPopulatedRequest_Query(r randyTypes, easy bool) *Request_Query { - this := &Request_Query{} - this.Query = NewPopulatedRequestQuery(r, easy) - return this -} -func NewPopulatedRequest_BeginBlock(r randyTypes, easy bool) *Request_BeginBlock { - this := &Request_BeginBlock{} - this.BeginBlock = NewPopulatedRequestBeginBlock(r, easy) - return this -} -func NewPopulatedRequest_CheckTx(r randyTypes, easy bool) *Request_CheckTx { - this := &Request_CheckTx{} - this.CheckTx = NewPopulatedRequestCheckTx(r, easy) - return this -} -func NewPopulatedRequest_EndBlock(r randyTypes, easy bool) *Request_EndBlock { - this := &Request_EndBlock{} - this.EndBlock = NewPopulatedRequestEndBlock(r, easy) - return this -} -func NewPopulatedRequest_Commit(r randyTypes, easy bool) *Request_Commit { - this := &Request_Commit{} - this.Commit = NewPopulatedRequestCommit(r, easy) - return this -} -func NewPopulatedRequest_ListSnapshots(r randyTypes, easy bool) *Request_ListSnapshots { - this := &Request_ListSnapshots{} - this.ListSnapshots = NewPopulatedRequestListSnapshots(r, easy) - return this -} -func NewPopulatedRequest_OfferSnapshot(r randyTypes, easy bool) *Request_OfferSnapshot { - this := &Request_OfferSnapshot{} - this.OfferSnapshot = NewPopulatedRequestOfferSnapshot(r, easy) - return this -} -func NewPopulatedRequest_LoadSnapshotChunk(r randyTypes, easy bool) *Request_LoadSnapshotChunk { - this := &Request_LoadSnapshotChunk{} - this.LoadSnapshotChunk = NewPopulatedRequestLoadSnapshotChunk(r, easy) - return this -} -func NewPopulatedRequest_ApplySnapshotChunk(r randyTypes, easy bool) *Request_ApplySnapshotChunk { - this := &Request_ApplySnapshotChunk{} - this.ApplySnapshotChunk = NewPopulatedRequestApplySnapshotChunk(r, easy) - return this -} -func NewPopulatedRequest_DeliverTx(r randyTypes, easy bool) *Request_DeliverTx { - this := &Request_DeliverTx{} - this.DeliverTx = NewPopulatedRequestDeliverTx(r, easy) - return this -} -func NewPopulatedRequestEcho(r randyTypes, easy bool) *RequestEcho { - this := &RequestEcho{} - this.Message = string(randStringTypes(r)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedRequestFlush(r randyTypes, easy bool) *RequestFlush { - this := &RequestFlush{} - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 1) - } - return this -} - -func NewPopulatedRequestInfo(r randyTypes, easy bool) *RequestInfo { - this := &RequestInfo{} - this.Version = string(randStringTypes(r)) - this.BlockVersion = uint64(uint64(r.Uint32())) - this.P2PVersion = uint64(uint64(r.Uint32())) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) - } - return this -} - -func NewPopulatedRequestSetOption(r randyTypes, easy bool) *RequestSetOption { - this := &RequestSetOption{} - this.Key = string(randStringTypes(r)) - this.Value = string(randStringTypes(r)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedRequestInitChain(r randyTypes, easy bool) *RequestInitChain { - this := &RequestInitChain{} - v1 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy) - this.Time = *v1 - this.ChainId = string(randStringTypes(r)) - if r.Intn(5) != 0 { - this.ConsensusParams = NewPopulatedConsensusParams(r, easy) - } - if r.Intn(5) != 0 { - v2 := r.Intn(5) - this.Validators = make([]ValidatorUpdate, v2) - for i := 0; i < v2; i++ { - v3 := NewPopulatedValidatorUpdate(r, easy) - this.Validators[i] = *v3 - } - } - v4 := r.Intn(100) - this.AppStateBytes = make([]byte, v4) - for i := 0; i < v4; i++ { - this.AppStateBytes[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 6) - } - return this -} - -func NewPopulatedRequestQuery(r randyTypes, easy bool) *RequestQuery { - this := &RequestQuery{} - v5 := r.Intn(100) - this.Data = make([]byte, v5) - for i := 0; i < v5; i++ { - this.Data[i] = byte(r.Intn(256)) - } - this.Path = string(randStringTypes(r)) - this.Height = int64(r.Int63()) - if r.Intn(2) == 0 { - this.Height *= -1 - } - this.Prove = bool(bool(r.Intn(2) == 0)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 5) - } - return this -} - -func NewPopulatedRequestBeginBlock(r randyTypes, easy bool) *RequestBeginBlock { - this := &RequestBeginBlock{} - v6 := r.Intn(100) - this.Hash = make([]byte, v6) - for i := 0; i < v6; i++ { - this.Hash[i] = byte(r.Intn(256)) - } - v7 := NewPopulatedHeader(r, easy) - this.Header = *v7 - v8 := NewPopulatedLastCommitInfo(r, easy) - this.LastCommitInfo = *v8 - if r.Intn(5) != 0 { - v9 := r.Intn(5) - this.ByzantineValidators = make([]Evidence, v9) - for i := 0; i < v9; i++ { - v10 := NewPopulatedEvidence(r, easy) - this.ByzantineValidators[i] = *v10 - } - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 5) - } - return this -} - -func NewPopulatedRequestCheckTx(r randyTypes, easy bool) *RequestCheckTx { - this := &RequestCheckTx{} - v11 := r.Intn(100) - this.Tx = make([]byte, v11) - for i := 0; i < v11; i++ { - this.Tx[i] = byte(r.Intn(256)) - } - this.Type = CheckTxType([]int32{0, 1}[r.Intn(2)]) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedRequestDeliverTx(r randyTypes, easy bool) *RequestDeliverTx { - this := &RequestDeliverTx{} - v12 := r.Intn(100) - this.Tx = make([]byte, v12) - for i := 0; i < v12; i++ { - this.Tx[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedRequestEndBlock(r randyTypes, easy bool) *RequestEndBlock { - this := &RequestEndBlock{} - this.Height = int64(r.Int63()) - if r.Intn(2) == 0 { - this.Height *= -1 - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedRequestCommit(r randyTypes, easy bool) *RequestCommit { - this := &RequestCommit{} - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 1) - } - return this -} - -func NewPopulatedRequestListSnapshots(r randyTypes, easy bool) *RequestListSnapshots { - this := &RequestListSnapshots{} - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 1) - } - return this -} - -func NewPopulatedRequestOfferSnapshot(r randyTypes, easy bool) *RequestOfferSnapshot { - this := &RequestOfferSnapshot{} - if r.Intn(5) != 0 { - this.Snapshot = NewPopulatedSnapshot(r, easy) - } - v13 := r.Intn(100) - this.AppHash = make([]byte, v13) - for i := 0; i < v13; i++ { - this.AppHash[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedRequestLoadSnapshotChunk(r randyTypes, easy bool) *RequestLoadSnapshotChunk { - this := &RequestLoadSnapshotChunk{} - this.Height = uint64(uint64(r.Uint32())) - this.Format = uint32(r.Uint32()) - this.Chunk = uint32(r.Uint32()) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) - } - return this -} - -func NewPopulatedRequestApplySnapshotChunk(r randyTypes, easy bool) *RequestApplySnapshotChunk { - this := &RequestApplySnapshotChunk{} - this.Index = uint32(r.Uint32()) - v14 := r.Intn(100) - this.Chunk = make([]byte, v14) - for i := 0; i < v14; i++ { - this.Chunk[i] = byte(r.Intn(256)) - } - this.Sender = string(randStringTypes(r)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) - } - return this -} - -func NewPopulatedResponse(r randyTypes, easy bool) *Response { - this := &Response{} - oneofNumber_Value := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] - switch oneofNumber_Value { - case 1: - this.Value = NewPopulatedResponse_Exception(r, easy) - case 2: - this.Value = NewPopulatedResponse_Echo(r, easy) - case 3: - this.Value = NewPopulatedResponse_Flush(r, easy) - case 4: - this.Value = NewPopulatedResponse_Info(r, easy) - case 5: - this.Value = NewPopulatedResponse_SetOption(r, easy) - case 6: - this.Value = NewPopulatedResponse_InitChain(r, easy) - case 7: - this.Value = NewPopulatedResponse_Query(r, easy) - case 8: - this.Value = NewPopulatedResponse_BeginBlock(r, easy) - case 9: - this.Value = NewPopulatedResponse_CheckTx(r, easy) - case 10: - this.Value = NewPopulatedResponse_DeliverTx(r, easy) - case 11: - this.Value = NewPopulatedResponse_EndBlock(r, easy) - case 12: - this.Value = NewPopulatedResponse_Commit(r, easy) - case 13: - this.Value = NewPopulatedResponse_ListSnapshots(r, easy) - case 14: - this.Value = NewPopulatedResponse_OfferSnapshot(r, easy) - case 15: - this.Value = NewPopulatedResponse_LoadSnapshotChunk(r, easy) - case 16: - this.Value = NewPopulatedResponse_ApplySnapshotChunk(r, easy) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 17) - } - return this -} - -func NewPopulatedResponse_Exception(r randyTypes, easy bool) *Response_Exception { - this := &Response_Exception{} - this.Exception = NewPopulatedResponseException(r, easy) - return this -} -func NewPopulatedResponse_Echo(r randyTypes, easy bool) *Response_Echo { - this := &Response_Echo{} - this.Echo = NewPopulatedResponseEcho(r, easy) - return this -} -func NewPopulatedResponse_Flush(r randyTypes, easy bool) *Response_Flush { - this := &Response_Flush{} - this.Flush = NewPopulatedResponseFlush(r, easy) - return this -} -func NewPopulatedResponse_Info(r randyTypes, easy bool) *Response_Info { - this := &Response_Info{} - this.Info = NewPopulatedResponseInfo(r, easy) - return this -} -func NewPopulatedResponse_SetOption(r randyTypes, easy bool) *Response_SetOption { - this := &Response_SetOption{} - this.SetOption = NewPopulatedResponseSetOption(r, easy) - return this -} -func NewPopulatedResponse_InitChain(r randyTypes, easy bool) *Response_InitChain { - this := &Response_InitChain{} - this.InitChain = NewPopulatedResponseInitChain(r, easy) - return this -} -func NewPopulatedResponse_Query(r randyTypes, easy bool) *Response_Query { - this := &Response_Query{} - this.Query = NewPopulatedResponseQuery(r, easy) - return this -} -func NewPopulatedResponse_BeginBlock(r randyTypes, easy bool) *Response_BeginBlock { - this := &Response_BeginBlock{} - this.BeginBlock = NewPopulatedResponseBeginBlock(r, easy) - return this -} -func NewPopulatedResponse_CheckTx(r randyTypes, easy bool) *Response_CheckTx { - this := &Response_CheckTx{} - this.CheckTx = NewPopulatedResponseCheckTx(r, easy) - return this -} -func NewPopulatedResponse_DeliverTx(r randyTypes, easy bool) *Response_DeliverTx { - this := &Response_DeliverTx{} - this.DeliverTx = NewPopulatedResponseDeliverTx(r, easy) - return this -} -func NewPopulatedResponse_EndBlock(r randyTypes, easy bool) *Response_EndBlock { - this := &Response_EndBlock{} - this.EndBlock = NewPopulatedResponseEndBlock(r, easy) - return this -} -func NewPopulatedResponse_Commit(r randyTypes, easy bool) *Response_Commit { - this := &Response_Commit{} - this.Commit = NewPopulatedResponseCommit(r, easy) - return this -} -func NewPopulatedResponse_ListSnapshots(r randyTypes, easy bool) *Response_ListSnapshots { - this := &Response_ListSnapshots{} - this.ListSnapshots = NewPopulatedResponseListSnapshots(r, easy) - return this -} -func NewPopulatedResponse_OfferSnapshot(r randyTypes, easy bool) *Response_OfferSnapshot { - this := &Response_OfferSnapshot{} - this.OfferSnapshot = NewPopulatedResponseOfferSnapshot(r, easy) - return this -} -func NewPopulatedResponse_LoadSnapshotChunk(r randyTypes, easy bool) *Response_LoadSnapshotChunk { - this := &Response_LoadSnapshotChunk{} - this.LoadSnapshotChunk = NewPopulatedResponseLoadSnapshotChunk(r, easy) - return this -} -func NewPopulatedResponse_ApplySnapshotChunk(r randyTypes, easy bool) *Response_ApplySnapshotChunk { - this := &Response_ApplySnapshotChunk{} - this.ApplySnapshotChunk = NewPopulatedResponseApplySnapshotChunk(r, easy) - return this -} -func NewPopulatedResponseException(r randyTypes, easy bool) *ResponseException { - this := &ResponseException{} - this.Error = string(randStringTypes(r)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedResponseEcho(r randyTypes, easy bool) *ResponseEcho { - this := &ResponseEcho{} - this.Message = string(randStringTypes(r)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedResponseFlush(r randyTypes, easy bool) *ResponseFlush { - this := &ResponseFlush{} - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 1) - } - return this -} - -func NewPopulatedResponseInfo(r randyTypes, easy bool) *ResponseInfo { - this := &ResponseInfo{} - this.Data = string(randStringTypes(r)) - this.Version = string(randStringTypes(r)) - this.AppVersion = uint64(uint64(r.Uint32())) - this.LastBlockHeight = int64(r.Int63()) - if r.Intn(2) == 0 { - this.LastBlockHeight *= -1 - } - v15 := r.Intn(100) - this.LastBlockAppHash = make([]byte, v15) - for i := 0; i < v15; i++ { - this.LastBlockAppHash[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 6) - } - return this -} - -func NewPopulatedResponseSetOption(r randyTypes, easy bool) *ResponseSetOption { - this := &ResponseSetOption{} - this.Code = uint32(r.Uint32()) - this.Log = string(randStringTypes(r)) - this.Info = string(randStringTypes(r)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 5) - } - return this -} - -func NewPopulatedResponseInitChain(r randyTypes, easy bool) *ResponseInitChain { - this := &ResponseInitChain{} - if r.Intn(5) != 0 { - this.ConsensusParams = NewPopulatedConsensusParams(r, easy) - } - if r.Intn(5) != 0 { - v16 := r.Intn(5) - this.Validators = make([]ValidatorUpdate, v16) - for i := 0; i < v16; i++ { - v17 := NewPopulatedValidatorUpdate(r, easy) - this.Validators[i] = *v17 - } - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedResponseQuery(r randyTypes, easy bool) *ResponseQuery { - this := &ResponseQuery{} - this.Code = uint32(r.Uint32()) - this.Log = string(randStringTypes(r)) - this.Info = string(randStringTypes(r)) - this.Index = int64(r.Int63()) - if r.Intn(2) == 0 { - this.Index *= -1 - } - v18 := r.Intn(100) - this.Key = make([]byte, v18) - for i := 0; i < v18; i++ { - this.Key[i] = byte(r.Intn(256)) - } - v19 := r.Intn(100) - this.Value = make([]byte, v19) - for i := 0; i < v19; i++ { - this.Value[i] = byte(r.Intn(256)) - } - if r.Intn(5) != 0 { - this.Proof = merkle.NewPopulatedProof(r, easy) - } - this.Height = int64(r.Int63()) - if r.Intn(2) == 0 { - this.Height *= -1 - } - this.Codespace = string(randStringTypes(r)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 11) - } - return this -} - -func NewPopulatedResponseBeginBlock(r randyTypes, easy bool) *ResponseBeginBlock { - this := &ResponseBeginBlock{} - if r.Intn(5) != 0 { - v20 := r.Intn(5) - this.Events = make([]Event, v20) - for i := 0; i < v20; i++ { - v21 := NewPopulatedEvent(r, easy) - this.Events[i] = *v21 - } - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedResponseCheckTx(r randyTypes, easy bool) *ResponseCheckTx { - this := &ResponseCheckTx{} - this.Code = uint32(r.Uint32()) - v22 := r.Intn(100) - this.Data = make([]byte, v22) - for i := 0; i < v22; i++ { - this.Data[i] = byte(r.Intn(256)) - } - this.Log = string(randStringTypes(r)) - this.Info = string(randStringTypes(r)) - this.GasWanted = int64(r.Int63()) - if r.Intn(2) == 0 { - this.GasWanted *= -1 - } - this.GasUsed = int64(r.Int63()) - if r.Intn(2) == 0 { - this.GasUsed *= -1 - } - if r.Intn(5) != 0 { - v23 := r.Intn(5) - this.Events = make([]Event, v23) - for i := 0; i < v23; i++ { - v24 := NewPopulatedEvent(r, easy) - this.Events[i] = *v24 - } - } - this.Codespace = string(randStringTypes(r)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 9) - } - return this -} - -func NewPopulatedResponseDeliverTx(r randyTypes, easy bool) *ResponseDeliverTx { - this := &ResponseDeliverTx{} - this.Code = uint32(r.Uint32()) - v25 := r.Intn(100) - this.Data = make([]byte, v25) - for i := 0; i < v25; i++ { - this.Data[i] = byte(r.Intn(256)) - } - this.Log = string(randStringTypes(r)) - this.Info = string(randStringTypes(r)) - this.GasWanted = int64(r.Int63()) - if r.Intn(2) == 0 { - this.GasWanted *= -1 - } - this.GasUsed = int64(r.Int63()) - if r.Intn(2) == 0 { - this.GasUsed *= -1 - } - if r.Intn(5) != 0 { - v26 := r.Intn(5) - this.Events = make([]Event, v26) - for i := 0; i < v26; i++ { - v27 := NewPopulatedEvent(r, easy) - this.Events[i] = *v27 - } - } - this.Codespace = string(randStringTypes(r)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 9) - } - return this -} - -func NewPopulatedResponseEndBlock(r randyTypes, easy bool) *ResponseEndBlock { - this := &ResponseEndBlock{} - if r.Intn(5) != 0 { - v28 := r.Intn(5) - this.ValidatorUpdates = make([]ValidatorUpdate, v28) - for i := 0; i < v28; i++ { - v29 := NewPopulatedValidatorUpdate(r, easy) - this.ValidatorUpdates[i] = *v29 - } - } - if r.Intn(5) != 0 { - this.ConsensusParamUpdates = NewPopulatedConsensusParams(r, easy) - } - if r.Intn(5) != 0 { - v30 := r.Intn(5) - this.Events = make([]Event, v30) - for i := 0; i < v30; i++ { - v31 := NewPopulatedEvent(r, easy) - this.Events[i] = *v31 - } - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) - } - return this -} - -func NewPopulatedResponseCommit(r randyTypes, easy bool) *ResponseCommit { - this := &ResponseCommit{} - v32 := r.Intn(100) - this.Data = make([]byte, v32) - for i := 0; i < v32; i++ { - this.Data[i] = byte(r.Intn(256)) - } - this.RetainHeight = int64(r.Int63()) - if r.Intn(2) == 0 { - this.RetainHeight *= -1 - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) - } - return this -} - -func NewPopulatedResponseListSnapshots(r randyTypes, easy bool) *ResponseListSnapshots { - this := &ResponseListSnapshots{} - if r.Intn(5) != 0 { - v33 := r.Intn(5) - this.Snapshots = make([]*Snapshot, v33) - for i := 0; i < v33; i++ { - this.Snapshots[i] = NewPopulatedSnapshot(r, easy) - } - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedResponseOfferSnapshot(r randyTypes, easy bool) *ResponseOfferSnapshot { - this := &ResponseOfferSnapshot{} - this.Result = ResponseOfferSnapshot_Result([]int32{0, 1, 2, 3, 4}[r.Intn(5)]) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedResponseLoadSnapshotChunk(r randyTypes, easy bool) *ResponseLoadSnapshotChunk { - this := &ResponseLoadSnapshotChunk{} - v34 := r.Intn(100) - this.Chunk = make([]byte, v34) - for i := 0; i < v34; i++ { - this.Chunk[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedResponseApplySnapshotChunk(r randyTypes, easy bool) *ResponseApplySnapshotChunk { - this := &ResponseApplySnapshotChunk{} - this.Result = ResponseApplySnapshotChunk_Result([]int32{0, 1, 2, 3, 4}[r.Intn(5)]) - v35 := r.Intn(10) - this.RefetchChunks = make([]uint32, v35) - for i := 0; i < v35; i++ { - this.RefetchChunks[i] = uint32(r.Uint32()) - } - v36 := r.Intn(10) - this.RejectSenders = make([]string, v36) - for i := 0; i < v36; i++ { - this.RejectSenders[i] = string(randStringTypes(r)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) - } - return this -} - -func NewPopulatedConsensusParams(r randyTypes, easy bool) *ConsensusParams { - this := &ConsensusParams{} - if r.Intn(5) != 0 { - this.Block = NewPopulatedBlockParams(r, easy) - } - if r.Intn(5) != 0 { - this.Evidence = NewPopulatedEvidenceParams(r, easy) - } - if r.Intn(5) != 0 { - this.Validator = NewPopulatedValidatorParams(r, easy) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) - } - return this -} - -func NewPopulatedBlockParams(r randyTypes, easy bool) *BlockParams { - this := &BlockParams{} - this.MaxBytes = int64(r.Int63()) - if r.Intn(2) == 0 { - this.MaxBytes *= -1 - } - this.MaxGas = int64(r.Int63()) - if r.Intn(2) == 0 { - this.MaxGas *= -1 - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedEvidenceParams(r randyTypes, easy bool) *EvidenceParams { - this := &EvidenceParams{} - this.MaxAgeNumBlocks = int64(r.Int63()) - if r.Intn(2) == 0 { - this.MaxAgeNumBlocks *= -1 - } - v37 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy) - this.MaxAgeDuration = *v37 - this.MaxNum = uint32(r.Uint32()) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) - } - return this -} - -func NewPopulatedValidatorParams(r randyTypes, easy bool) *ValidatorParams { - this := &ValidatorParams{} - v38 := r.Intn(10) - this.PubKeyTypes = make([]string, v38) - for i := 0; i < v38; i++ { - this.PubKeyTypes[i] = string(randStringTypes(r)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedLastCommitInfo(r randyTypes, easy bool) *LastCommitInfo { - this := &LastCommitInfo{} - this.Round = int32(r.Int31()) - if r.Intn(2) == 0 { - this.Round *= -1 - } - if r.Intn(5) != 0 { - v39 := r.Intn(5) - this.Votes = make([]VoteInfo, v39) - for i := 0; i < v39; i++ { - v40 := NewPopulatedVoteInfo(r, easy) - this.Votes[i] = *v40 - } - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedEventAttribute(r randyTypes, easy bool) *EventAttribute { - this := &EventAttribute{} - v41 := r.Intn(100) - this.Key = make([]byte, v41) - for i := 0; i < v41; i++ { - this.Key[i] = byte(r.Intn(256)) - } - v42 := r.Intn(100) - this.Value = make([]byte, v42) - for i := 0; i < v42; i++ { - this.Value[i] = byte(r.Intn(256)) - } - this.Index = bool(bool(r.Intn(2) == 0)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) - } - return this -} - -func NewPopulatedEvent(r randyTypes, easy bool) *Event { - this := &Event{} - this.Type = string(randStringTypes(r)) - if r.Intn(5) != 0 { - v43 := r.Intn(5) - this.Attributes = make([]EventAttribute, v43) - for i := 0; i < v43; i++ { - v44 := NewPopulatedEventAttribute(r, easy) - this.Attributes[i] = *v44 - } - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedHeader(r randyTypes, easy bool) *Header { - this := &Header{} - v45 := NewPopulatedVersion(r, easy) - this.Version = *v45 - this.ChainID = string(randStringTypes(r)) - this.Height = int64(r.Int63()) - if r.Intn(2) == 0 { - this.Height *= -1 - } - v46 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy) - this.Time = *v46 - v47 := NewPopulatedBlockID(r, easy) - this.LastBlockId = *v47 - v48 := r.Intn(100) - this.LastCommitHash = make([]byte, v48) - for i := 0; i < v48; i++ { - this.LastCommitHash[i] = byte(r.Intn(256)) - } - v49 := r.Intn(100) - this.DataHash = make([]byte, v49) - for i := 0; i < v49; i++ { - this.DataHash[i] = byte(r.Intn(256)) - } - v50 := r.Intn(100) - this.ValidatorsHash = make([]byte, v50) - for i := 0; i < v50; i++ { - this.ValidatorsHash[i] = byte(r.Intn(256)) - } - v51 := r.Intn(100) - this.NextValidatorsHash = make([]byte, v51) - for i := 0; i < v51; i++ { - this.NextValidatorsHash[i] = byte(r.Intn(256)) - } - v52 := r.Intn(100) - this.ConsensusHash = make([]byte, v52) - for i := 0; i < v52; i++ { - this.ConsensusHash[i] = byte(r.Intn(256)) - } - v53 := r.Intn(100) - this.AppHash = make([]byte, v53) - for i := 0; i < v53; i++ { - this.AppHash[i] = byte(r.Intn(256)) - } - v54 := r.Intn(100) - this.LastResultsHash = make([]byte, v54) - for i := 0; i < v54; i++ { - this.LastResultsHash[i] = byte(r.Intn(256)) - } - v55 := r.Intn(100) - this.EvidenceHash = make([]byte, v55) - for i := 0; i < v55; i++ { - this.EvidenceHash[i] = byte(r.Intn(256)) - } - v56 := r.Intn(100) - this.ProposerAddress = make([]byte, v56) - for i := 0; i < v56; i++ { - this.ProposerAddress[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 15) - } - return this -} - -func NewPopulatedVersion(r randyTypes, easy bool) *Version { - this := &Version{} - this.Block = uint64(uint64(r.Uint32())) - this.App = uint64(uint64(r.Uint32())) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedBlockID(r randyTypes, easy bool) *BlockID { - this := &BlockID{} - v57 := r.Intn(100) - this.Hash = make([]byte, v57) - for i := 0; i < v57; i++ { - this.Hash[i] = byte(r.Intn(256)) - } - v58 := NewPopulatedPartSetHeader(r, easy) - this.PartsHeader = *v58 - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedPartSetHeader(r randyTypes, easy bool) *PartSetHeader { - this := &PartSetHeader{} - this.Total = int32(r.Int31()) - if r.Intn(2) == 0 { - this.Total *= -1 - } - v59 := r.Intn(100) - this.Hash = make([]byte, v59) - for i := 0; i < v59; i++ { - this.Hash[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedValidator(r randyTypes, easy bool) *Validator { - this := &Validator{} - v60 := r.Intn(100) - this.Address = make([]byte, v60) - for i := 0; i < v60; i++ { - this.Address[i] = byte(r.Intn(256)) - } - this.Power = int64(r.Int63()) - if r.Intn(2) == 0 { - this.Power *= -1 - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) - } - return this -} - -func NewPopulatedValidatorUpdate(r randyTypes, easy bool) *ValidatorUpdate { - this := &ValidatorUpdate{} - v61 := NewPopulatedPubKey(r, easy) - this.PubKey = *v61 - this.Power = int64(r.Int63()) - if r.Intn(2) == 0 { - this.Power *= -1 - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedVoteInfo(r randyTypes, easy bool) *VoteInfo { - this := &VoteInfo{} - v62 := NewPopulatedValidator(r, easy) - this.Validator = *v62 - this.SignedLastBlock = bool(bool(r.Intn(2) == 0)) - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedPubKey(r randyTypes, easy bool) *PubKey { - this := &PubKey{} - this.Type = string(randStringTypes(r)) - v63 := r.Intn(100) - this.Data = make([]byte, v63) - for i := 0; i < v63; i++ { - this.Data[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -func NewPopulatedEvidence(r randyTypes, easy bool) *Evidence { - this := &Evidence{} - this.Type = string(randStringTypes(r)) - v64 := NewPopulatedValidator(r, easy) - this.Validator = *v64 - this.Height = int64(r.Int63()) - if r.Intn(2) == 0 { - this.Height *= -1 - } - v65 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy) - this.Time = *v65 - this.TotalVotingPower = int64(r.Int63()) - if r.Intn(2) == 0 { - this.TotalVotingPower *= -1 - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 6) - } - return this -} - -func NewPopulatedSnapshot(r randyTypes, easy bool) *Snapshot { - this := &Snapshot{} - this.Height = uint64(uint64(r.Uint32())) - this.Format = uint32(r.Uint32()) - this.Chunks = uint32(r.Uint32()) - v66 := r.Intn(100) - this.Hash = make([]byte, v66) - for i := 0; i < v66; i++ { - this.Hash[i] = byte(r.Intn(256)) - } - v67 := r.Intn(100) - this.Metadata = make([]byte, v67) - for i := 0; i < v67; i++ { - this.Metadata[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 6) - } - return this -} - -type randyTypes interface { - Float32() float32 - Float64() float64 - Int63() int64 - Int31() int32 - Uint32() uint32 - Intn(n int) int -} - -func randUTF8RuneTypes(r randyTypes) rune { - ru := r.Intn(62) - if ru < 10 { - return rune(ru + 48) - } else if ru < 36 { - return rune(ru + 55) - } - return rune(ru + 61) -} -func randStringTypes(r randyTypes) string { - v68 := r.Intn(100) - tmps := make([]rune, v68) - for i := 0; i < v68; i++ { - tmps[i] = randUTF8RuneTypes(r) - } - return string(tmps) -} -func randUnrecognizedTypes(r randyTypes, maxFieldNumber int) (dAtA []byte) { - l := r.Intn(5) - for i := 0; i < l; i++ { - wire := r.Intn(4) - if wire == 3 { - wire = 5 - } - fieldNumber := maxFieldNumber + r.Intn(100) - dAtA = randFieldTypes(dAtA, r, fieldNumber, wire) - } - return dAtA -} -func randFieldTypes(dAtA []byte, r randyTypes, fieldNumber int, wire int) []byte { - key := uint32(fieldNumber)<<3 | uint32(wire) - switch wire { - case 0: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - v69 := r.Int63() - if r.Intn(2) == 0 { - v69 *= -1 - } - dAtA = encodeVarintPopulateTypes(dAtA, uint64(v69)) - case 1: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) - case 2: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - ll := r.Intn(100) - dAtA = encodeVarintPopulateTypes(dAtA, uint64(ll)) - for j := 0; j < ll; j++ { - dAtA = append(dAtA, byte(r.Intn(256))) - } - default: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) - } - return dAtA -} -func encodeVarintPopulateTypes(dAtA []byte, v uint64) []byte { - for v >= 1<<7 { - dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) - v >>= 7 - } - dAtA = append(dAtA, uint8(v)) - return dAtA -} func (m *Request) Size() (n int) { if m == nil { return 0 diff --git a/abci/types/types.proto b/abci/types/types.proto index 50c77cde0..bf096706b 100644 --- a/abci/types/types.proto +++ b/abci/types/types.proto @@ -17,10 +17,6 @@ option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.goproto_registration) = true; -// Generate tests -option (gogoproto.populate_all) = true; -option (gogoproto.equal_all) = true; -option (gogoproto.testgen_all) = true; //---------------------------------------- // Request types diff --git a/abci/types/typespb_test.go b/abci/types/typespb_test.go deleted file mode 100644 index fcb8d025f..000000000 --- a/abci/types/typespb_test.go +++ /dev/null @@ -1,6228 +0,0 @@ -// 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/duration" - _ "github.com/golang/protobuf/ptypes/timestamp" - _ "github.com/tendermint/tendermint/crypto/merkle" - 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 TestRequestListSnapshotsProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestListSnapshots(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestListSnapshots{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestRequestListSnapshotsMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestListSnapshots(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestListSnapshots{} - if err := github_com_gogo_protobuf_proto.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 TestRequestOfferSnapshotProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestOfferSnapshot(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestOfferSnapshot{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestRequestOfferSnapshotMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestOfferSnapshot(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestOfferSnapshot{} - if err := github_com_gogo_protobuf_proto.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 TestRequestLoadSnapshotChunkProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestLoadSnapshotChunk(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestLoadSnapshotChunk{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestRequestLoadSnapshotChunkMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestLoadSnapshotChunk(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestLoadSnapshotChunk{} - if err := github_com_gogo_protobuf_proto.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 TestRequestApplySnapshotChunkProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestApplySnapshotChunk(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestApplySnapshotChunk{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestRequestApplySnapshotChunkMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestApplySnapshotChunk(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestApplySnapshotChunk{} - if err := github_com_gogo_protobuf_proto.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 TestResponseListSnapshotsProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseListSnapshots(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseListSnapshots{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestResponseListSnapshotsMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseListSnapshots(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseListSnapshots{} - if err := github_com_gogo_protobuf_proto.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 TestResponseOfferSnapshotProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseOfferSnapshot(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseOfferSnapshot{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestResponseOfferSnapshotMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseOfferSnapshot(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseOfferSnapshot{} - if err := github_com_gogo_protobuf_proto.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 TestResponseLoadSnapshotChunkProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseLoadSnapshotChunk(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseLoadSnapshotChunk{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestResponseLoadSnapshotChunkMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseLoadSnapshotChunk(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseLoadSnapshotChunk{} - if err := github_com_gogo_protobuf_proto.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 TestResponseApplySnapshotChunkProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseApplySnapshotChunk(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseApplySnapshotChunk{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestResponseApplySnapshotChunkMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseApplySnapshotChunk(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseApplySnapshotChunk{} - if err := github_com_gogo_protobuf_proto.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 TestEventAttributeProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEventAttribute(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &EventAttribute{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestEventAttributeMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEventAttribute(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &EventAttribute{} - if err := github_com_gogo_protobuf_proto.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 TestSnapshotProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedSnapshot(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &Snapshot{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestSnapshotMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedSnapshot(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &Snapshot{} - if err := github_com_gogo_protobuf_proto.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 TestRequestListSnapshotsJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestListSnapshots(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestListSnapshots{} - 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 TestRequestOfferSnapshotJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestOfferSnapshot(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestOfferSnapshot{} - 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 TestRequestLoadSnapshotChunkJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestLoadSnapshotChunk(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestLoadSnapshotChunk{} - 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 TestRequestApplySnapshotChunkJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestApplySnapshotChunk(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestApplySnapshotChunk{} - 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 TestResponseListSnapshotsJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseListSnapshots(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseListSnapshots{} - 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 TestResponseOfferSnapshotJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseOfferSnapshot(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseOfferSnapshot{} - 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 TestResponseLoadSnapshotChunkJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseLoadSnapshotChunk(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseLoadSnapshotChunk{} - 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 TestResponseApplySnapshotChunkJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseApplySnapshotChunk(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseApplySnapshotChunk{} - 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 TestEventAttributeJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEventAttribute(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &EventAttribute{} - 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 TestSnapshotJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedSnapshot(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &Snapshot{} - 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 TestRequestListSnapshotsProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestListSnapshots(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &RequestListSnapshots{} - 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 TestRequestListSnapshotsProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestListSnapshots(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &RequestListSnapshots{} - 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 TestRequestOfferSnapshotProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestOfferSnapshot(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &RequestOfferSnapshot{} - 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 TestRequestOfferSnapshotProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestOfferSnapshot(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &RequestOfferSnapshot{} - 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 TestRequestLoadSnapshotChunkProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestLoadSnapshotChunk(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &RequestLoadSnapshotChunk{} - 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 TestRequestLoadSnapshotChunkProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestLoadSnapshotChunk(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &RequestLoadSnapshotChunk{} - 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 TestRequestApplySnapshotChunkProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestApplySnapshotChunk(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &RequestApplySnapshotChunk{} - 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 TestRequestApplySnapshotChunkProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestApplySnapshotChunk(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &RequestApplySnapshotChunk{} - 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 TestResponseListSnapshotsProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseListSnapshots(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseListSnapshots{} - 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 TestResponseListSnapshotsProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseListSnapshots(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseListSnapshots{} - 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 TestResponseOfferSnapshotProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseOfferSnapshot(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseOfferSnapshot{} - 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 TestResponseOfferSnapshotProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseOfferSnapshot(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseOfferSnapshot{} - 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 TestResponseLoadSnapshotChunkProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseLoadSnapshotChunk(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseLoadSnapshotChunk{} - 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 TestResponseLoadSnapshotChunkProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseLoadSnapshotChunk(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseLoadSnapshotChunk{} - 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 TestResponseApplySnapshotChunkProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseApplySnapshotChunk(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseApplySnapshotChunk{} - 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 TestResponseApplySnapshotChunkProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseApplySnapshotChunk(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseApplySnapshotChunk{} - 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 TestEventAttributeProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEventAttribute(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &EventAttribute{} - 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 TestEventAttributeProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEventAttribute(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &EventAttribute{} - 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 TestSnapshotProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedSnapshot(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &Snapshot{} - 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 TestSnapshotProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedSnapshot(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &Snapshot{} - 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 TestRequestListSnapshotsSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestListSnapshots(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -func TestRequestOfferSnapshotSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestOfferSnapshot(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -func TestRequestLoadSnapshotChunkSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestLoadSnapshotChunk(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -func TestRequestApplySnapshotChunkSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestApplySnapshotChunk(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_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 TestResponseListSnapshotsSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseListSnapshots(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -func TestResponseOfferSnapshotSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseOfferSnapshot(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -func TestResponseLoadSnapshotChunkSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseLoadSnapshotChunk(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -func TestResponseApplySnapshotChunkSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseApplySnapshotChunk(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_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 TestEventAttributeSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEventAttribute(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_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) - } -} - -func TestSnapshotSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedSnapshot(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/crypto/merkle/merkle.pb.go b/crypto/merkle/merkle.pb.go index 80823dd2b..79379c86b 100644 --- a/crypto/merkle/merkle.pb.go +++ b/crypto/merkle/merkle.pb.go @@ -4,7 +4,6 @@ package merkle import ( - bytes "bytes" fmt "fmt" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" @@ -146,7 +145,7 @@ func init() { func init() { proto.RegisterFile("crypto/merkle/merkle.proto", fileDescriptor_9c1c2162d560d38e) } var fileDescriptor_9c1c2162d560d38e = []byte{ - // 230 bytes of a gzipped FileDescriptorProto + // 221 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0x2e, 0xaa, 0x2c, 0x28, 0xc9, 0xd7, 0xcf, 0x4d, 0x2d, 0xca, 0xce, 0x49, 0x85, 0x52, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x12, 0x25, 0xa9, 0x79, 0x29, 0xa9, 0x45, 0xb9, 0x99, 0x79, 0x25, 0x7a, 0x10, 0x65, @@ -157,78 +156,12 @@ var fileDescriptor_9c1c2162d560d38e = []byte{ 0xa4, 0xc0, 0xa8, 0xc1, 0x13, 0x04, 0x62, 0x82, 0x54, 0xa5, 0x24, 0x96, 0x24, 0x4a, 0x30, 0x83, 0x85, 0xc0, 0x6c, 0x25, 0x27, 0x2e, 0x56, 0xb0, 0x21, 0x42, 0x96, 0x5c, 0xcc, 0xf9, 0x05, 0xc5, 0x12, 0x8c, 0x0a, 0xcc, 0x1a, 0xdc, 0x46, 0x8a, 0x7a, 0xb8, 0x5c, 0xa7, 0x07, 0xb5, 0xd2, 0x89, - 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0x90, 0x1e, 0x27, 0x97, 0x1f, 0x0f, 0xe5, 0x18, 0x57, 0x3c, - 0x92, 0x63, 0x3c, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0xa3, - 0xf4, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x11, 0xa6, 0x21, 0x33, - 0x51, 0x42, 0x27, 0x89, 0x0d, 0xec, 0x2b, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc8, 0xcc, - 0x2c, 0x91, 0x35, 0x01, 0x00, 0x00, + 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0x90, 0x1e, 0x27, 0x9b, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, + 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x31, 0x4a, 0x2f, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, + 0x39, 0x3f, 0x57, 0x1f, 0x61, 0x0a, 0x32, 0x13, 0x25, 0x54, 0x92, 0xd8, 0xc0, 0xbe, 0x31, 0x06, + 0x04, 0x00, 0x00, 0xff, 0xff, 0xb6, 0x3d, 0x69, 0x56, 0x2d, 0x01, 0x00, 0x00, } -func (this *ProofOp) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ProofOp) - if !ok { - that2, ok := that.(ProofOp) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.Type != that1.Type { - return false - } - if !bytes.Equal(this.Key, that1.Key) { - return false - } - if !bytes.Equal(this.Data, that1.Data) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *Proof) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Proof) - if !ok { - that2, ok := that.(Proof) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if len(this.Ops) != len(that1.Ops) { - return false - } - for i := range this.Ops { - if !this.Ops[i].Equal(&that1.Ops[i]) { - return false - } - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} func (m *ProofOp) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -329,113 +262,6 @@ func encodeVarintMerkle(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } -func NewPopulatedProofOp(r randyMerkle, easy bool) *ProofOp { - this := &ProofOp{} - this.Type = string(randStringMerkle(r)) - v1 := r.Intn(100) - this.Key = make([]byte, v1) - for i := 0; i < v1; i++ { - this.Key[i] = byte(r.Intn(256)) - } - v2 := r.Intn(100) - this.Data = make([]byte, v2) - for i := 0; i < v2; i++ { - this.Data[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedMerkle(r, 4) - } - return this -} - -func NewPopulatedProof(r randyMerkle, easy bool) *Proof { - this := &Proof{} - if r.Intn(5) != 0 { - v3 := r.Intn(5) - this.Ops = make([]ProofOp, v3) - for i := 0; i < v3; i++ { - v4 := NewPopulatedProofOp(r, easy) - this.Ops[i] = *v4 - } - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedMerkle(r, 2) - } - return this -} - -type randyMerkle interface { - Float32() float32 - Float64() float64 - Int63() int64 - Int31() int32 - Uint32() uint32 - Intn(n int) int -} - -func randUTF8RuneMerkle(r randyMerkle) rune { - ru := r.Intn(62) - if ru < 10 { - return rune(ru + 48) - } else if ru < 36 { - return rune(ru + 55) - } - return rune(ru + 61) -} -func randStringMerkle(r randyMerkle) string { - v5 := r.Intn(100) - tmps := make([]rune, v5) - for i := 0; i < v5; i++ { - tmps[i] = randUTF8RuneMerkle(r) - } - return string(tmps) -} -func randUnrecognizedMerkle(r randyMerkle, maxFieldNumber int) (dAtA []byte) { - l := r.Intn(5) - for i := 0; i < l; i++ { - wire := r.Intn(4) - if wire == 3 { - wire = 5 - } - fieldNumber := maxFieldNumber + r.Intn(100) - dAtA = randFieldMerkle(dAtA, r, fieldNumber, wire) - } - return dAtA -} -func randFieldMerkle(dAtA []byte, r randyMerkle, fieldNumber int, wire int) []byte { - key := uint32(fieldNumber)<<3 | uint32(wire) - switch wire { - case 0: - dAtA = encodeVarintPopulateMerkle(dAtA, uint64(key)) - v6 := r.Int63() - if r.Intn(2) == 0 { - v6 *= -1 - } - dAtA = encodeVarintPopulateMerkle(dAtA, uint64(v6)) - case 1: - dAtA = encodeVarintPopulateMerkle(dAtA, uint64(key)) - dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) - case 2: - dAtA = encodeVarintPopulateMerkle(dAtA, uint64(key)) - ll := r.Intn(100) - dAtA = encodeVarintPopulateMerkle(dAtA, uint64(ll)) - for j := 0; j < ll; j++ { - dAtA = append(dAtA, byte(r.Intn(256))) - } - default: - dAtA = encodeVarintPopulateMerkle(dAtA, uint64(key)) - dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) - } - return dAtA -} -func encodeVarintPopulateMerkle(dAtA []byte, v uint64) []byte { - for v >= 1<<7 { - dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) - v >>= 7 - } - dAtA = append(dAtA, uint8(v)) - return dAtA -} func (m *ProofOp) Size() (n int) { if m == nil { return 0 diff --git a/crypto/merkle/merkle.proto b/crypto/merkle/merkle.proto index 159fc58c9..ccf032d57 100644 --- a/crypto/merkle/merkle.proto +++ b/crypto/merkle/merkle.proto @@ -10,9 +10,6 @@ option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (gogoproto.sizer_all) = true; -option (gogoproto.populate_all) = true; -option (gogoproto.equal_all) = true; - //---------------------------------------- // Message types diff --git a/libs/kv/types.pb.go b/libs/kv/types.pb.go index 7a6e6e12e..a1a751862 100644 --- a/libs/kv/types.pb.go +++ b/libs/kv/types.pb.go @@ -4,7 +4,6 @@ package kv import ( - bytes "bytes" fmt "fmt" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" @@ -90,7 +89,7 @@ func init() { proto.RegisterFile("libs/kv/types.proto", fileDescriptor_31432671d func init() { golang_proto.RegisterFile("libs/kv/types.proto", fileDescriptor_31432671d164f444) } var fileDescriptor_31432671d164f444 = []byte{ - // 182 bytes of a gzipped FileDescriptorProto + // 170 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xce, 0xc9, 0x4c, 0x2a, 0xd6, 0xcf, 0x2e, 0xd3, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x2a, 0x49, 0xcd, 0x4b, 0x49, 0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x03, 0xc9, 0xeb, 0x65, @@ -98,43 +97,12 @@ var fileDescriptor_31432671d164f444 = []byte{ 0x95, 0xe9, 0xa7, 0xe7, 0xa7, 0xe7, 0x23, 0x58, 0x10, 0xbd, 0x4a, 0x7a, 0x5c, 0x2c, 0x01, 0x89, 0x99, 0x45, 0x42, 0x02, 0x5c, 0xcc, 0xd9, 0xa9, 0x95, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x3c, 0x41, 0x20, 0xa6, 0x90, 0x08, 0x17, 0x6b, 0x59, 0x62, 0x4e, 0x69, 0xaa, 0x04, 0x13, 0x58, 0x0c, 0xc2, - 0x71, 0x72, 0xfb, 0xf1, 0x50, 0x8e, 0x71, 0xc5, 0x23, 0x39, 0xc6, 0x1d, 0x8f, 0xe4, 0x18, 0x4f, - 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x03, 0x8f, 0xe5, 0x18, - 0xa3, 0x34, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x11, 0x8e, 0x42, - 0x66, 0x42, 0xdd, 0x9f, 0xc4, 0x06, 0xb6, 0xde, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x5d, 0x3a, - 0xdc, 0xba, 0xd1, 0x00, 0x00, 0x00, + 0x71, 0xb2, 0x3a, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x0f, + 0x3c, 0x96, 0x63, 0x8c, 0xd2, 0x48, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, + 0x47, 0x38, 0x04, 0x99, 0x09, 0x75, 0x73, 0x12, 0x1b, 0xd8, 0x4a, 0x63, 0x40, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x44, 0x0a, 0x7f, 0x75, 0xc5, 0x00, 0x00, 0x00, } -func (this *Pair) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*Pair) - if !ok { - that2, ok := that.(Pair) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Key, that1.Key) { - return false - } - if !bytes.Equal(this.Value, that1.Value) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} func (m *Pair) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -187,96 +155,6 @@ func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } -func NewPopulatedPair(r randyTypes, easy bool) *Pair { - this := &Pair{} - v1 := r.Intn(100) - this.Key = make([]byte, v1) - for i := 0; i < v1; i++ { - this.Key[i] = byte(r.Intn(256)) - } - v2 := r.Intn(100) - this.Value = make([]byte, v2) - for i := 0; i < v2; i++ { - this.Value[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -type randyTypes interface { - Float32() float32 - Float64() float64 - Int63() int64 - Int31() int32 - Uint32() uint32 - Intn(n int) int -} - -func randUTF8RuneTypes(r randyTypes) rune { - ru := r.Intn(62) - if ru < 10 { - return rune(ru + 48) - } else if ru < 36 { - return rune(ru + 55) - } - return rune(ru + 61) -} -func randStringTypes(r randyTypes) string { - v3 := r.Intn(100) - tmps := make([]rune, v3) - for i := 0; i < v3; i++ { - tmps[i] = randUTF8RuneTypes(r) - } - return string(tmps) -} -func randUnrecognizedTypes(r randyTypes, maxFieldNumber int) (dAtA []byte) { - l := r.Intn(5) - for i := 0; i < l; i++ { - wire := r.Intn(4) - if wire == 3 { - wire = 5 - } - fieldNumber := maxFieldNumber + r.Intn(100) - dAtA = randFieldTypes(dAtA, r, fieldNumber, wire) - } - return dAtA -} -func randFieldTypes(dAtA []byte, r randyTypes, fieldNumber int, wire int) []byte { - key := uint32(fieldNumber)<<3 | uint32(wire) - switch wire { - case 0: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - v4 := r.Int63() - if r.Intn(2) == 0 { - v4 *= -1 - } - dAtA = encodeVarintPopulateTypes(dAtA, uint64(v4)) - case 1: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) - case 2: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - ll := r.Intn(100) - dAtA = encodeVarintPopulateTypes(dAtA, uint64(ll)) - for j := 0; j < ll; j++ { - dAtA = append(dAtA, byte(r.Intn(256))) - } - default: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) - } - return dAtA -} -func encodeVarintPopulateTypes(dAtA []byte, v uint64) []byte { - for v >= 1<<7 { - dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) - v >>= 7 - } - dAtA = append(dAtA, uint8(v)) - return dAtA -} func (m *Pair) Size() (n int) { if m == nil { return 0 diff --git a/libs/kv/types.proto b/libs/kv/types.proto index e227c37c7..67ab81fd4 100644 --- a/libs/kv/types.proto +++ b/libs/kv/types.proto @@ -8,10 +8,6 @@ option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.goproto_registration) = true; -// Generate tests -option (gogoproto.populate_all) = true; -option (gogoproto.equal_all) = true; -option (gogoproto.testgen_all) = true; //---------------------------------------- // Abstract types diff --git a/libs/kv/typespb_test.go b/libs/kv/typespb_test.go deleted file mode 100644 index dc45bf7f2..000000000 --- a/libs/kv/typespb_test.go +++ /dev/null @@ -1,149 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: libs/kv/types.proto - -package kv - -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" - 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 TestPairProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedPair(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &Pair{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestPairMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedPair(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &Pair{} - if err := github_com_gogo_protobuf_proto.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 TestPairJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedPair(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &Pair{} - 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 TestPairProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedPair(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &Pair{} - 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 TestPairProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedPair(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &Pair{} - 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 TestPairSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedPair(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/rpc/grpc/types.pb.go b/rpc/grpc/types.pb.go index f7fdf6b53..1fc7411c5 100644 --- a/rpc/grpc/types.pb.go +++ b/rpc/grpc/types.pb.go @@ -4,7 +4,6 @@ package coregrpc import ( - bytes "bytes" context "context" fmt "fmt" _ "github.com/gogo/protobuf/gogoproto" @@ -226,135 +225,28 @@ func init() { proto.RegisterFile("rpc/grpc/types.proto", fileDescriptor_15f63baa func init() { golang_proto.RegisterFile("rpc/grpc/types.proto", fileDescriptor_15f63baabf91876a) } var fileDescriptor_15f63baabf91876a = []byte{ - // 344 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0xb1, 0x4e, 0xf3, 0x30, - 0x14, 0x85, 0xe5, 0xea, 0xd7, 0x0f, 0xdc, 0x96, 0x0e, 0x2e, 0x42, 0x28, 0x83, 0x55, 0x2a, 0x54, - 0x3a, 0x39, 0x52, 0x19, 0x99, 0x5a, 0x90, 0x10, 0x62, 0xa9, 0xa2, 0x4e, 0x2c, 0x25, 0x75, 0xac, - 0x34, 0x82, 0xc6, 0xc6, 0x71, 0x51, 0xfa, 0x38, 0x6c, 0x3c, 0x02, 0x0b, 0x12, 0x23, 0x23, 0x8f, - 0x00, 0xe1, 0x25, 0x18, 0x91, 0x93, 0x86, 0x78, 0x80, 0xb2, 0x44, 0x27, 0xd6, 0x39, 0x9f, 0xce, - 0xbd, 0xba, 0xb0, 0xa3, 0x24, 0x73, 0x43, 0xf3, 0xd1, 0x4b, 0xc9, 0x13, 0x2a, 0x95, 0xd0, 0x02, - 0xb7, 0x34, 0x8f, 0x03, 0xae, 0xe6, 0x51, 0xac, 0xa9, 0x92, 0x8c, 0x1a, 0x83, 0xd3, 0xd5, 0xb3, - 0x48, 0x05, 0x13, 0xe9, 0x2b, 0xbd, 0x74, 0x73, 0x9f, 0x1b, 0x8a, 0x50, 0x54, 0xaa, 0x08, 0x3b, - 0xbb, 0xfe, 0x94, 0x45, 0x05, 0xce, 0x86, 0x76, 0xb6, 0xa1, 0xee, 0xf1, 0xdb, 0x05, 0x4f, 0xf4, - 0x28, 0x8a, 0xc3, 0xce, 0x01, 0xe0, 0xd5, 0xef, 0x50, 0x09, 0x3f, 0x60, 0x7e, 0xa2, 0xc7, 0x29, - 0x6e, 0x42, 0x4d, 0xa7, 0x7b, 0xa8, 0x8d, 0x7a, 0x0d, 0xaf, 0xa6, 0xd3, 0x4e, 0x13, 0x1a, 0x1e, - 0x4f, 0xa4, 0x88, 0x13, 0x9e, 0xa7, 0xee, 0x11, 0xb4, 0xca, 0x07, 0x3b, 0x37, 0x80, 0x4d, 0x36, - 0xe3, 0xec, 0x7a, 0xb2, 0x4a, 0xd7, 0xfb, 0x5d, 0x6a, 0x0d, 0x61, 0x2a, 0xd1, 0xa2, 0x4c, 0x99, - 0x3e, 0x31, 0xf6, 0x71, 0xea, 0x6d, 0xb0, 0x42, 0xe0, 0x33, 0x80, 0x80, 0xdf, 0x44, 0x77, 0x5c, - 0x19, 0x48, 0x2d, 0x87, 0xf4, 0xfe, 0x80, 0x9c, 0x16, 0x81, 0x71, 0xea, 0x6d, 0x05, 0xa5, 0xec, - 0x3f, 0x21, 0x68, 0x7c, 0x77, 0x1b, 0x8c, 0xce, 0xf1, 0x05, 0xfc, 0x33, 0xe5, 0x71, 0x9b, 0xfe, - 0xb0, 0x57, 0x6a, 0x2d, 0xc5, 0xd9, 0xff, 0xc5, 0x51, 0x6d, 0x00, 0x5f, 0x41, 0xdd, 0x1e, 0xfc, - 0x70, 0x1d, 0xd3, 0x32, 0x3a, 0xbd, 0xb5, 0x68, 0xcb, 0x39, 0x1c, 0x7d, 0xbe, 0x13, 0xf4, 0x90, - 0x11, 0xf4, 0x98, 0x11, 0xf4, 0x92, 0x11, 0xf4, 0x9a, 0x11, 0xf4, 0x96, 0x11, 0xf4, 0xfc, 0x41, - 0xd0, 0x65, 0x3f, 0x8c, 0xf4, 0x6c, 0x31, 0xa5, 0x4c, 0xcc, 0xdd, 0x8a, 0x68, 0xcb, 0xf2, 0xa4, - 0x8e, 0x99, 0x50, 0xdc, 0x88, 0xe9, 0xff, 0xfc, 0x02, 0x8e, 0xbe, 0x02, 0x00, 0x00, 0xff, 0xff, - 0x30, 0xfd, 0xaa, 0xac, 0x6e, 0x02, 0x00, 0x00, -} - -func (this *RequestPing) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestPing) - if !ok { - that2, ok := that.(RequestPing) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *RequestBroadcastTx) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*RequestBroadcastTx) - if !ok { - that2, ok := that.(RequestBroadcastTx) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.Tx, that1.Tx) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponsePing) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponsePing) - if !ok { - that2, ok := that.(ResponsePing) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true -} -func (this *ResponseBroadcastTx) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*ResponseBroadcastTx) - if !ok { - that2, ok := that.(ResponseBroadcastTx) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if !this.CheckTx.Equal(that1.CheckTx) { - return false - } - if !this.DeliverTx.Equal(that1.DeliverTx) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { - return false - } - return true + // 330 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x4f, 0x4b, 0xc3, 0x30, + 0x18, 0xc6, 0xc9, 0x10, 0xff, 0xbc, 0x9b, 0x3b, 0x64, 0x22, 0xd2, 0x43, 0x99, 0x43, 0xe6, 0x4e, + 0x29, 0xcc, 0xa3, 0xa7, 0xcd, 0x81, 0x88, 0x97, 0x51, 0x76, 0xf2, 0x32, 0xbb, 0x34, 0xb4, 0x41, + 0xd7, 0xc4, 0x34, 0x93, 0xee, 0xe3, 0xf8, 0x41, 0x04, 0x8f, 0x1e, 0xfd, 0x08, 0x52, 0xbf, 0x88, + 0xa4, 0x5d, 0x6d, 0x0e, 0x3a, 0x2f, 0xe5, 0x69, 0x78, 0x9e, 0x1f, 0xcf, 0xfb, 0x26, 0x70, 0xa4, + 0x24, 0xf5, 0x22, 0xf3, 0xd1, 0x6b, 0xc9, 0x52, 0x22, 0x95, 0xd0, 0x02, 0x77, 0x34, 0x4b, 0x42, + 0xa6, 0x96, 0x3c, 0xd1, 0x44, 0x49, 0x4a, 0x8c, 0xc1, 0xe9, 0xeb, 0x98, 0xab, 0x70, 0x2e, 0x03, + 0xa5, 0xd7, 0x5e, 0xe1, 0xf3, 0x22, 0x11, 0x89, 0x5a, 0x95, 0x61, 0xe7, 0x38, 0x58, 0x50, 0x5e, + 0xe2, 0x6c, 0x68, 0xef, 0x10, 0x9a, 0x3e, 0x7b, 0x5a, 0xb1, 0x54, 0x4f, 0x79, 0x12, 0xf5, 0xce, + 0x00, 0x6f, 0x7e, 0xc7, 0x4a, 0x04, 0x21, 0x0d, 0x52, 0x3d, 0xcb, 0x70, 0x1b, 0x1a, 0x3a, 0x3b, + 0x41, 0x5d, 0x34, 0x68, 0xf9, 0x0d, 0x9d, 0xf5, 0xda, 0xd0, 0xf2, 0x59, 0x2a, 0x45, 0x92, 0xb2, + 0x22, 0xf5, 0x82, 0xa0, 0x53, 0x1d, 0xd8, 0xb9, 0x11, 0xec, 0xd3, 0x98, 0xd1, 0x87, 0xf9, 0x26, + 0xdd, 0x1c, 0xf6, 0x89, 0x35, 0x84, 0xa9, 0x44, 0xca, 0x32, 0x55, 0xfa, 0xca, 0xd8, 0x67, 0x99, + 0xbf, 0x47, 0x4b, 0x81, 0xaf, 0x01, 0x42, 0xf6, 0xc8, 0x9f, 0x99, 0x32, 0x90, 0x46, 0x01, 0x19, + 0xfc, 0x03, 0x99, 0x94, 0x81, 0x59, 0xe6, 0x1f, 0x84, 0x95, 0x1c, 0xbe, 0x22, 0x68, 0xfd, 0x74, + 0x1b, 0x4d, 0x6f, 0xf0, 0x2d, 0xec, 0x98, 0xf2, 0xb8, 0x4b, 0x7e, 0xd9, 0x2b, 0xb1, 0x96, 0xe2, + 0x9c, 0xfe, 0xe1, 0xa8, 0x37, 0x80, 0xef, 0xa1, 0x69, 0x0f, 0x7e, 0xbe, 0x8d, 0x69, 0x19, 0x9d, + 0xc1, 0x56, 0xb4, 0xe5, 0x1c, 0x4f, 0xde, 0x73, 0x17, 0x7d, 0xe4, 0x2e, 0xfa, 0xcc, 0x5d, 0xf4, + 0xf6, 0xe5, 0xa2, 0xbb, 0x61, 0xc4, 0x75, 0xbc, 0x5a, 0x10, 0x2a, 0x96, 0x5e, 0x4d, 0xb1, 0x65, + 0xf5, 0x8c, 0x2e, 0xa9, 0x50, 0xcc, 0x88, 0xc5, 0x6e, 0x71, 0xeb, 0x17, 0xdf, 0x01, 0x00, 0x00, + 0xff, 0xff, 0x67, 0x85, 0x6c, 0xf2, 0x62, 0x02, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -623,121 +515,6 @@ func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } -func NewPopulatedRequestPing(r randyTypes, easy bool) *RequestPing { - this := &RequestPing{} - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 1) - } - return this -} - -func NewPopulatedRequestBroadcastTx(r randyTypes, easy bool) *RequestBroadcastTx { - this := &RequestBroadcastTx{} - v1 := r.Intn(100) - this.Tx = make([]byte, v1) - for i := 0; i < v1; i++ { - this.Tx[i] = byte(r.Intn(256)) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 2) - } - return this -} - -func NewPopulatedResponsePing(r randyTypes, easy bool) *ResponsePing { - this := &ResponsePing{} - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 1) - } - return this -} - -func NewPopulatedResponseBroadcastTx(r randyTypes, easy bool) *ResponseBroadcastTx { - this := &ResponseBroadcastTx{} - if r.Intn(5) != 0 { - this.CheckTx = types.NewPopulatedResponseCheckTx(r, easy) - } - if r.Intn(5) != 0 { - this.DeliverTx = types.NewPopulatedResponseDeliverTx(r, easy) - } - if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 3) - } - return this -} - -type randyTypes interface { - Float32() float32 - Float64() float64 - Int63() int64 - Int31() int32 - Uint32() uint32 - Intn(n int) int -} - -func randUTF8RuneTypes(r randyTypes) rune { - ru := r.Intn(62) - if ru < 10 { - return rune(ru + 48) - } else if ru < 36 { - return rune(ru + 55) - } - return rune(ru + 61) -} -func randStringTypes(r randyTypes) string { - v2 := r.Intn(100) - tmps := make([]rune, v2) - for i := 0; i < v2; i++ { - tmps[i] = randUTF8RuneTypes(r) - } - return string(tmps) -} -func randUnrecognizedTypes(r randyTypes, maxFieldNumber int) (dAtA []byte) { - l := r.Intn(5) - for i := 0; i < l; i++ { - wire := r.Intn(4) - if wire == 3 { - wire = 5 - } - fieldNumber := maxFieldNumber + r.Intn(100) - dAtA = randFieldTypes(dAtA, r, fieldNumber, wire) - } - return dAtA -} -func randFieldTypes(dAtA []byte, r randyTypes, fieldNumber int, wire int) []byte { - key := uint32(fieldNumber)<<3 | uint32(wire) - switch wire { - case 0: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - v3 := r.Int63() - if r.Intn(2) == 0 { - v3 *= -1 - } - dAtA = encodeVarintPopulateTypes(dAtA, uint64(v3)) - case 1: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) - case 2: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - ll := r.Intn(100) - dAtA = encodeVarintPopulateTypes(dAtA, uint64(ll)) - for j := 0; j < ll; j++ { - dAtA = append(dAtA, byte(r.Intn(256))) - } - default: - dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) - } - return dAtA -} -func encodeVarintPopulateTypes(dAtA []byte, v uint64) []byte { - for v >= 1<<7 { - dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) - v >>= 7 - } - dAtA = append(dAtA, uint8(v)) - return dAtA -} func (m *RequestPing) Size() (n int) { if m == nil { return 0 diff --git a/rpc/grpc/types.proto b/rpc/grpc/types.proto index fc778cacd..d08719732 100644 --- a/rpc/grpc/types.proto +++ b/rpc/grpc/types.proto @@ -9,10 +9,8 @@ option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.goproto_registration) = true; -// Generate tests -option (gogoproto.populate_all) = true; -option (gogoproto.equal_all) = true; -option (gogoproto.testgen_all) = true; + + //---------------------------------------- // Message types diff --git a/rpc/grpc/typespb_test.go b/rpc/grpc/typespb_test.go deleted file mode 100644 index d0a6c8654..000000000 --- a/rpc/grpc/typespb_test.go +++ /dev/null @@ -1,522 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: rpc/grpc/types.proto - -package coregrpc - -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/tendermint/tendermint/abci/types" - 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 TestRequestPingProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestPing(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestPing{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestRequestPingMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestPing(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestPing{} - if err := github_com_gogo_protobuf_proto.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 TestRequestBroadcastTxProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestBroadcastTx(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestBroadcastTx{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestRequestBroadcastTxMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestBroadcastTx(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestBroadcastTx{} - if err := github_com_gogo_protobuf_proto.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 TestResponsePingProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponsePing(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponsePing{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestResponsePingMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponsePing(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponsePing{} - if err := github_com_gogo_protobuf_proto.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 TestResponseBroadcastTxProto(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBroadcastTx(popr, false) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseBroadcastTx{} - if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { - t.Fatalf("seed = %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 TestResponseBroadcastTxMarshalTo(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBroadcastTx(popr, false) - size := p.Size() - dAtA := make([]byte, size) - for i := range dAtA { - dAtA[i] = byte(popr.Intn(256)) - } - _, err := p.MarshalTo(dAtA) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseBroadcastTx{} - if err := github_com_gogo_protobuf_proto.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 TestRequestPingJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestPing(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestPing{} - 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 TestRequestBroadcastTxJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestBroadcastTx(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &RequestBroadcastTx{} - 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 TestResponsePingJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponsePing(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponsePing{} - 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 TestResponseBroadcastTxJSON(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBroadcastTx(popr, true) - marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} - jsondata, err := marshaler.MarshalToString(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - msg := &ResponseBroadcastTx{} - 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 TestRequestPingProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestPing(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &RequestPing{} - 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 TestRequestPingProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestPing(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &RequestPing{} - 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 TestRequestBroadcastTxProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestBroadcastTx(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &RequestBroadcastTx{} - 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 TestRequestBroadcastTxProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestBroadcastTx(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &RequestBroadcastTx{} - 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 TestResponsePingProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponsePing(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponsePing{} - 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 TestResponsePingProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponsePing(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponsePing{} - 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 TestResponseBroadcastTxProtoText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBroadcastTx(popr, true) - dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseBroadcastTx{} - 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 TestResponseBroadcastTxProtoCompactText(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBroadcastTx(popr, true) - dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseBroadcastTx{} - 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 TestRequestPingSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestPing(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -func TestRequestBroadcastTxSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedRequestBroadcastTx(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -func TestResponsePingSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponsePing(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := github_com_gogo_protobuf_proto.Size(p) - if size3 != size { - t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) - } -} - -func TestResponseBroadcastTxSize(t *testing.T) { - seed := time.Now().UnixNano() - popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBroadcastTx(popr, true) - size2 := github_com_gogo_protobuf_proto.Size(p) - dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) - if err != nil { - t.Fatalf("seed = %d, err = %v", seed, err) - } - size := p.Size() - if len(dAtA) != size { - t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) - } - if size2 != size { - t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) - } - size3 := 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