// Code generated by protoc-gen-gogo.
// source: log.proto
// DO NOT EDIT!

package mesosproto

import testing7 "testing"
import math_rand7 "math/rand"
import time7 "time"
import github_com_gogo_protobuf_proto4 "github.com/gogo/protobuf/proto"
import testing8 "testing"
import math_rand8 "math/rand"
import time8 "time"
import encoding_json1 "encoding/json"
import testing9 "testing"
import math_rand9 "math/rand"
import time9 "time"
import github_com_gogo_protobuf_proto5 "github.com/gogo/protobuf/proto"
import math_rand10 "math/rand"
import time10 "time"
import testing10 "testing"
import fmt2 "fmt"
import math_rand11 "math/rand"
import time11 "time"
import testing11 "testing"
import github_com_gogo_protobuf_proto6 "github.com/gogo/protobuf/proto"
import math_rand12 "math/rand"
import time12 "time"
import testing12 "testing"
import fmt3 "fmt"
import go_parser1 "go/parser"
import math_rand13 "math/rand"
import time13 "time"
import testing13 "testing"
import github_com_gogo_protobuf_proto7 "github.com/gogo/protobuf/proto"

func TestPromiseProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedPromise(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Promise{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestPromiseMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedPromise(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &Promise{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkPromiseProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*Promise, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedPromise(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkPromiseProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedPromise(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &Promise{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestActionProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedAction(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestActionMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedAction(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &Action{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkActionProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*Action, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedAction(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkActionProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedAction(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &Action{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestAction_NopProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedAction_Nop(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action_Nop{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestAction_NopMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedAction_Nop(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &Action_Nop{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkAction_NopProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*Action_Nop, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedAction_Nop(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkAction_NopProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedAction_Nop(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &Action_Nop{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestAction_AppendProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedAction_Append(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action_Append{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestAction_AppendMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedAction_Append(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &Action_Append{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkAction_AppendProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*Action_Append, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedAction_Append(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkAction_AppendProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedAction_Append(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &Action_Append{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestAction_TruncateProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedAction_Truncate(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action_Truncate{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestAction_TruncateMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedAction_Truncate(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &Action_Truncate{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkAction_TruncateProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*Action_Truncate, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedAction_Truncate(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkAction_TruncateProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedAction_Truncate(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &Action_Truncate{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestMetadataProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedMetadata(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Metadata{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestMetadataMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedMetadata(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &Metadata{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkMetadataProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*Metadata, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedMetadata(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkMetadataProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedMetadata(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &Metadata{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestRecordProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedRecord(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Record{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestRecordMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedRecord(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &Record{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkRecordProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*Record, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedRecord(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkRecordProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedRecord(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &Record{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestPromiseRequestProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedPromiseRequest(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &PromiseRequest{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestPromiseRequestMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedPromiseRequest(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &PromiseRequest{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkPromiseRequestProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*PromiseRequest, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedPromiseRequest(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkPromiseRequestProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedPromiseRequest(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &PromiseRequest{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestPromiseResponseProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedPromiseResponse(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &PromiseResponse{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestPromiseResponseMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedPromiseResponse(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &PromiseResponse{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkPromiseResponseProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*PromiseResponse, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedPromiseResponse(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkPromiseResponseProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedPromiseResponse(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &PromiseResponse{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestWriteRequestProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedWriteRequest(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &WriteRequest{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestWriteRequestMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedWriteRequest(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &WriteRequest{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkWriteRequestProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*WriteRequest, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedWriteRequest(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkWriteRequestProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedWriteRequest(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &WriteRequest{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestWriteResponseProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedWriteResponse(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &WriteResponse{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestWriteResponseMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedWriteResponse(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &WriteResponse{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkWriteResponseProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*WriteResponse, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedWriteResponse(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkWriteResponseProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedWriteResponse(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &WriteResponse{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestLearnedMessageProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedLearnedMessage(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &LearnedMessage{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestLearnedMessageMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedLearnedMessage(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &LearnedMessage{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkLearnedMessageProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*LearnedMessage, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedLearnedMessage(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkLearnedMessageProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedLearnedMessage(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &LearnedMessage{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestRecoverRequestProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedRecoverRequest(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &RecoverRequest{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestRecoverRequestMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedRecoverRequest(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &RecoverRequest{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkRecoverRequestProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*RecoverRequest, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedRecoverRequest(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkRecoverRequestProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedRecoverRequest(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &RecoverRequest{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestRecoverResponseProto(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedRecoverResponse(popr, false)
	data, err := github_com_gogo_protobuf_proto4.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &RecoverResponse{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestRecoverResponseMarshalTo(t *testing7.T) {
	popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano()))
	p := NewPopulatedRecoverResponse(popr, false)
	size := p.Size()
	data := make([]byte, size)
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	_, err := p.MarshalTo(data)
	if err != nil {
		panic(err)
	}
	msg := &RecoverResponse{}
	if err := github_com_gogo_protobuf_proto4.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	for i := range data {
		data[i] = byte(popr.Intn(256))
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func BenchmarkRecoverResponseProtoMarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	pops := make([]*RecoverResponse, 10000)
	for i := 0; i < 10000; i++ {
		pops[i] = NewPopulatedRecoverResponse(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(pops[i%10000])
		if err != nil {
			panic(err)
		}
		total += len(data)
	}
	b.SetBytes(int64(total / b.N))
}

func BenchmarkRecoverResponseProtoUnmarshal(b *testing7.B) {
	popr := math_rand7.New(math_rand7.NewSource(616))
	total := 0
	datas := make([][]byte, 10000)
	for i := 0; i < 10000; i++ {
		data, err := github_com_gogo_protobuf_proto4.Marshal(NewPopulatedRecoverResponse(popr, false))
		if err != nil {
			panic(err)
		}
		datas[i] = data
	}
	msg := &RecoverResponse{}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += len(datas[i%10000])
		if err := github_com_gogo_protobuf_proto4.Unmarshal(datas[i%10000], msg); err != nil {
			panic(err)
		}
	}
	b.SetBytes(int64(total / b.N))
}

func TestPromiseJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedPromise(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Promise{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestActionJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedAction(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestAction_NopJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedAction_Nop(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action_Nop{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestAction_AppendJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedAction_Append(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action_Append{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestAction_TruncateJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedAction_Truncate(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action_Truncate{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestMetadataJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedMetadata(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Metadata{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestRecordJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedRecord(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Record{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestPromiseRequestJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedPromiseRequest(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &PromiseRequest{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestPromiseResponseJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedPromiseResponse(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &PromiseResponse{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestWriteRequestJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedWriteRequest(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &WriteRequest{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestWriteResponseJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedWriteResponse(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &WriteResponse{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestLearnedMessageJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedLearnedMessage(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &LearnedMessage{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestRecoverRequestJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedRecoverRequest(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &RecoverRequest{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestRecoverResponseJSON(t *testing8.T) {
	popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano()))
	p := NewPopulatedRecoverResponse(popr, true)
	jsondata, err := encoding_json1.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &RecoverResponse{}
	err = encoding_json1.Unmarshal(jsondata, msg)
	if err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Json Equal %#v", msg, p)
	}
}
func TestPromiseProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedPromise(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &Promise{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestPromiseProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedPromise(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &Promise{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestActionProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedAction(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &Action{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestActionProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedAction(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &Action{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestAction_NopProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedAction_Nop(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &Action_Nop{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestAction_NopProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedAction_Nop(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &Action_Nop{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestAction_AppendProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedAction_Append(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &Action_Append{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestAction_AppendProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedAction_Append(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &Action_Append{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestAction_TruncateProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedAction_Truncate(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &Action_Truncate{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestAction_TruncateProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedAction_Truncate(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &Action_Truncate{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestMetadataProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedMetadata(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &Metadata{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestMetadataProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedMetadata(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &Metadata{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestRecordProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedRecord(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &Record{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestRecordProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedRecord(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &Record{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestPromiseRequestProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedPromiseRequest(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &PromiseRequest{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestPromiseRequestProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedPromiseRequest(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &PromiseRequest{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestPromiseResponseProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedPromiseResponse(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &PromiseResponse{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestPromiseResponseProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedPromiseResponse(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &PromiseResponse{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestWriteRequestProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedWriteRequest(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &WriteRequest{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestWriteRequestProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedWriteRequest(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &WriteRequest{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestWriteResponseProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedWriteResponse(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &WriteResponse{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestWriteResponseProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedWriteResponse(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &WriteResponse{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestLearnedMessageProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedLearnedMessage(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &LearnedMessage{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestLearnedMessageProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedLearnedMessage(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &LearnedMessage{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestRecoverRequestProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedRecoverRequest(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &RecoverRequest{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestRecoverRequestProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedRecoverRequest(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &RecoverRequest{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestRecoverResponseProtoText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedRecoverResponse(popr, true)
	data := github_com_gogo_protobuf_proto5.MarshalTextString(p)
	msg := &RecoverResponse{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestRecoverResponseProtoCompactText(t *testing9.T) {
	popr := math_rand9.New(math_rand9.NewSource(time9.Now().UnixNano()))
	p := NewPopulatedRecoverResponse(popr, true)
	data := github_com_gogo_protobuf_proto5.CompactTextString(p)
	msg := &RecoverResponse{}
	if err := github_com_gogo_protobuf_proto5.UnmarshalText(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err)
	}
	if !p.Equal(msg) {
		t.Fatalf("%#v !Proto %#v", msg, p)
	}
}

func TestPromiseStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedPromise(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestActionStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedAction(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestAction_NopStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedAction_Nop(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestAction_AppendStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedAction_Append(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestAction_TruncateStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedAction_Truncate(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestMetadataStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedMetadata(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestRecordStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedRecord(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestPromiseRequestStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedPromiseRequest(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestPromiseResponseStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedPromiseResponse(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestWriteRequestStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedWriteRequest(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestWriteResponseStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedWriteResponse(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestLearnedMessageStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedLearnedMessage(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestRecoverRequestStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedRecoverRequest(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestRecoverResponseStringer(t *testing10.T) {
	popr := math_rand10.New(math_rand10.NewSource(time10.Now().UnixNano()))
	p := NewPopulatedRecoverResponse(popr, false)
	s1 := p.String()
	s2 := fmt2.Sprintf("%v", p)
	if s1 != s2 {
		t.Fatalf("String want %v got %v", s1, s2)
	}
}
func TestPromiseSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedPromise(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkPromiseSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*Promise, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedPromise(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestActionSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedAction(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkActionSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*Action, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedAction(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestAction_NopSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedAction_Nop(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkAction_NopSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*Action_Nop, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedAction_Nop(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestAction_AppendSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedAction_Append(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkAction_AppendSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*Action_Append, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedAction_Append(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestAction_TruncateSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedAction_Truncate(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkAction_TruncateSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*Action_Truncate, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedAction_Truncate(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestMetadataSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedMetadata(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkMetadataSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*Metadata, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedMetadata(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestRecordSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedRecord(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkRecordSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*Record, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedRecord(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestPromiseRequestSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedPromiseRequest(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkPromiseRequestSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*PromiseRequest, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedPromiseRequest(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestPromiseResponseSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedPromiseResponse(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkPromiseResponseSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*PromiseResponse, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedPromiseResponse(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestWriteRequestSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedWriteRequest(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkWriteRequestSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*WriteRequest, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedWriteRequest(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestWriteResponseSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedWriteResponse(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkWriteResponseSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*WriteResponse, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedWriteResponse(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestLearnedMessageSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedLearnedMessage(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkLearnedMessageSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*LearnedMessage, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedLearnedMessage(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestRecoverRequestSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedRecoverRequest(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkRecoverRequestSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*RecoverRequest, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedRecoverRequest(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestRecoverResponseSize(t *testing11.T) {
	popr := math_rand11.New(math_rand11.NewSource(time11.Now().UnixNano()))
	p := NewPopulatedRecoverResponse(popr, true)
	size2 := github_com_gogo_protobuf_proto6.Size(p)
	data, err := github_com_gogo_protobuf_proto6.Marshal(p)
	if err != nil {
		panic(err)
	}
	size := p.Size()
	if len(data) != size {
		t.Fatalf("size %v != marshalled size %v", size, len(data))
	}
	if size2 != size {
		t.Fatalf("size %v != before marshal proto.Size %v", size, size2)
	}
	size3 := github_com_gogo_protobuf_proto6.Size(p)
	if size3 != size {
		t.Fatalf("size %v != after marshal proto.Size %v", size, size3)
	}
}

func BenchmarkRecoverResponseSize(b *testing11.B) {
	popr := math_rand11.New(math_rand11.NewSource(616))
	total := 0
	pops := make([]*RecoverResponse, 1000)
	for i := 0; i < 1000; i++ {
		pops[i] = NewPopulatedRecoverResponse(popr, false)
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		total += pops[i%1000].Size()
	}
	b.SetBytes(int64(total / b.N))
}

func TestPromiseGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedPromise(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestActionGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedAction(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestAction_NopGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedAction_Nop(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestAction_AppendGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedAction_Append(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestAction_TruncateGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedAction_Truncate(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestMetadataGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedMetadata(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestRecordGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedRecord(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestPromiseRequestGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedPromiseRequest(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestPromiseResponseGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedPromiseResponse(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestWriteRequestGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedWriteRequest(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestWriteResponseGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedWriteResponse(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestLearnedMessageGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedLearnedMessage(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestRecoverRequestGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedRecoverRequest(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestRecoverResponseGoString(t *testing12.T) {
	popr := math_rand12.New(math_rand12.NewSource(time12.Now().UnixNano()))
	p := NewPopulatedRecoverResponse(popr, false)
	s1 := p.GoString()
	s2 := fmt3.Sprintf("%#v", p)
	if s1 != s2 {
		t.Fatalf("GoString want %v got %v", s1, s2)
	}
	_, err := go_parser1.ParseExpr(s1)
	if err != nil {
		panic(err)
	}
}
func TestPromiseVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedPromise(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Promise{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestActionVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedAction(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestAction_NopVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedAction_Nop(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action_Nop{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestAction_AppendVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedAction_Append(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action_Append{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestAction_TruncateVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedAction_Truncate(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Action_Truncate{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestMetadataVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedMetadata(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Metadata{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestRecordVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedRecord(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &Record{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestPromiseRequestVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedPromiseRequest(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &PromiseRequest{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestPromiseResponseVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedPromiseResponse(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &PromiseResponse{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestWriteRequestVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedWriteRequest(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &WriteRequest{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestWriteResponseVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedWriteResponse(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &WriteResponse{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestLearnedMessageVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedLearnedMessage(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &LearnedMessage{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestRecoverRequestVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedRecoverRequest(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &RecoverRequest{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}
func TestRecoverResponseVerboseEqual(t *testing13.T) {
	popr := math_rand13.New(math_rand13.NewSource(time13.Now().UnixNano()))
	p := NewPopulatedRecoverResponse(popr, false)
	data, err := github_com_gogo_protobuf_proto7.Marshal(p)
	if err != nil {
		panic(err)
	}
	msg := &RecoverResponse{}
	if err := github_com_gogo_protobuf_proto7.Unmarshal(data, msg); err != nil {
		panic(err)
	}
	if err := p.VerboseEqual(msg); err != nil {
		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
	}
}

//These tests are generated by github.com/gogo/protobuf/plugin/testgen
