1// Code generated by protoc-gen-gogo. DO NOT EDIT.
2// source: combos/both/theproto3.proto
3
4package theproto3
5
6import (
7	fmt "fmt"
8	_ "github.com/gogo/protobuf/gogoproto"
9	github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
10	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
11	proto "github.com/gogo/protobuf/proto"
12	_ "github.com/gogo/protobuf/test/combos/both"
13	go_parser "go/parser"
14	math "math"
15	math_rand "math/rand"
16	testing "testing"
17	time "time"
18)
19
20// Reference imports to suppress errors if they are not otherwise used.
21var _ = proto.Marshal
22var _ = fmt.Errorf
23var _ = math.Inf
24
25func TestMessageProto(t *testing.T) {
26	seed := time.Now().UnixNano()
27	popr := math_rand.New(math_rand.NewSource(seed))
28	p := NewPopulatedMessage(popr, false)
29	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
30	if err != nil {
31		t.Fatalf("seed = %d, err = %v", seed, err)
32	}
33	msg := &Message{}
34	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
35		t.Fatalf("seed = %d, err = %v", seed, err)
36	}
37	littlefuzz := make([]byte, len(dAtA))
38	copy(littlefuzz, dAtA)
39	for i := range dAtA {
40		dAtA[i] = byte(popr.Intn(256))
41	}
42	if err := p.VerboseEqual(msg); err != nil {
43		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
44	}
45	if !p.Equal(msg) {
46		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
47	}
48	if len(littlefuzz) > 0 {
49		fuzzamount := 100
50		for i := 0; i < fuzzamount; i++ {
51			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
52			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
53		}
54		// shouldn't panic
55		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
56	}
57}
58
59func TestMessageMarshalTo(t *testing.T) {
60	seed := time.Now().UnixNano()
61	popr := math_rand.New(math_rand.NewSource(seed))
62	p := NewPopulatedMessage(popr, false)
63	size := p.Size()
64	dAtA := make([]byte, size)
65	for i := range dAtA {
66		dAtA[i] = byte(popr.Intn(256))
67	}
68	_, err := p.MarshalTo(dAtA)
69	if err != nil {
70		t.Fatalf("seed = %d, err = %v", seed, err)
71	}
72	msg := &Message{}
73	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
74		t.Fatalf("seed = %d, err = %v", seed, err)
75	}
76	for i := range dAtA {
77		dAtA[i] = byte(popr.Intn(256))
78	}
79	if err := p.VerboseEqual(msg); err != nil {
80		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
81	}
82	if !p.Equal(msg) {
83		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
84	}
85}
86
87func BenchmarkMessageProtoMarshal(b *testing.B) {
88	popr := math_rand.New(math_rand.NewSource(616))
89	total := 0
90	pops := make([]*Message, 10000)
91	for i := 0; i < 10000; i++ {
92		pops[i] = NewPopulatedMessage(popr, false)
93	}
94	b.ResetTimer()
95	for i := 0; i < b.N; i++ {
96		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
97		if err != nil {
98			panic(err)
99		}
100		total += len(dAtA)
101	}
102	b.SetBytes(int64(total / b.N))
103}
104
105func BenchmarkMessageProtoUnmarshal(b *testing.B) {
106	popr := math_rand.New(math_rand.NewSource(616))
107	total := 0
108	datas := make([][]byte, 10000)
109	for i := 0; i < 10000; i++ {
110		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessage(popr, false))
111		if err != nil {
112			panic(err)
113		}
114		datas[i] = dAtA
115	}
116	msg := &Message{}
117	b.ResetTimer()
118	for i := 0; i < b.N; i++ {
119		total += len(datas[i%10000])
120		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
121			panic(err)
122		}
123	}
124	b.SetBytes(int64(total / b.N))
125}
126
127func TestNestedProto(t *testing.T) {
128	seed := time.Now().UnixNano()
129	popr := math_rand.New(math_rand.NewSource(seed))
130	p := NewPopulatedNested(popr, false)
131	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
132	if err != nil {
133		t.Fatalf("seed = %d, err = %v", seed, err)
134	}
135	msg := &Nested{}
136	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
137		t.Fatalf("seed = %d, err = %v", seed, err)
138	}
139	littlefuzz := make([]byte, len(dAtA))
140	copy(littlefuzz, dAtA)
141	for i := range dAtA {
142		dAtA[i] = byte(popr.Intn(256))
143	}
144	if err := p.VerboseEqual(msg); err != nil {
145		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
146	}
147	if !p.Equal(msg) {
148		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
149	}
150	if len(littlefuzz) > 0 {
151		fuzzamount := 100
152		for i := 0; i < fuzzamount; i++ {
153			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
154			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
155		}
156		// shouldn't panic
157		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
158	}
159}
160
161func TestNestedMarshalTo(t *testing.T) {
162	seed := time.Now().UnixNano()
163	popr := math_rand.New(math_rand.NewSource(seed))
164	p := NewPopulatedNested(popr, false)
165	size := p.Size()
166	dAtA := make([]byte, size)
167	for i := range dAtA {
168		dAtA[i] = byte(popr.Intn(256))
169	}
170	_, err := p.MarshalTo(dAtA)
171	if err != nil {
172		t.Fatalf("seed = %d, err = %v", seed, err)
173	}
174	msg := &Nested{}
175	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
176		t.Fatalf("seed = %d, err = %v", seed, err)
177	}
178	for i := range dAtA {
179		dAtA[i] = byte(popr.Intn(256))
180	}
181	if err := p.VerboseEqual(msg); err != nil {
182		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
183	}
184	if !p.Equal(msg) {
185		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
186	}
187}
188
189func BenchmarkNestedProtoMarshal(b *testing.B) {
190	popr := math_rand.New(math_rand.NewSource(616))
191	total := 0
192	pops := make([]*Nested, 10000)
193	for i := 0; i < 10000; i++ {
194		pops[i] = NewPopulatedNested(popr, false)
195	}
196	b.ResetTimer()
197	for i := 0; i < b.N; i++ {
198		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
199		if err != nil {
200			panic(err)
201		}
202		total += len(dAtA)
203	}
204	b.SetBytes(int64(total / b.N))
205}
206
207func BenchmarkNestedProtoUnmarshal(b *testing.B) {
208	popr := math_rand.New(math_rand.NewSource(616))
209	total := 0
210	datas := make([][]byte, 10000)
211	for i := 0; i < 10000; i++ {
212		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNested(popr, false))
213		if err != nil {
214			panic(err)
215		}
216		datas[i] = dAtA
217	}
218	msg := &Nested{}
219	b.ResetTimer()
220	for i := 0; i < b.N; i++ {
221		total += len(datas[i%10000])
222		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
223			panic(err)
224		}
225	}
226	b.SetBytes(int64(total / b.N))
227}
228
229func TestAllMapsProto(t *testing.T) {
230	seed := time.Now().UnixNano()
231	popr := math_rand.New(math_rand.NewSource(seed))
232	p := NewPopulatedAllMaps(popr, false)
233	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
234	if err != nil {
235		t.Fatalf("seed = %d, err = %v", seed, err)
236	}
237	msg := &AllMaps{}
238	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
239		t.Fatalf("seed = %d, err = %v", seed, err)
240	}
241	littlefuzz := make([]byte, len(dAtA))
242	copy(littlefuzz, dAtA)
243	for i := range dAtA {
244		dAtA[i] = byte(popr.Intn(256))
245	}
246	if err := p.VerboseEqual(msg); err != nil {
247		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
248	}
249	if !p.Equal(msg) {
250		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
251	}
252	if len(littlefuzz) > 0 {
253		fuzzamount := 100
254		for i := 0; i < fuzzamount; i++ {
255			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
256			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
257		}
258		// shouldn't panic
259		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
260	}
261}
262
263func TestAllMapsMarshalTo(t *testing.T) {
264	seed := time.Now().UnixNano()
265	popr := math_rand.New(math_rand.NewSource(seed))
266	p := NewPopulatedAllMaps(popr, false)
267	size := p.Size()
268	dAtA := make([]byte, size)
269	for i := range dAtA {
270		dAtA[i] = byte(popr.Intn(256))
271	}
272	_, err := p.MarshalTo(dAtA)
273	if err != nil {
274		t.Fatalf("seed = %d, err = %v", seed, err)
275	}
276	msg := &AllMaps{}
277	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
278		t.Fatalf("seed = %d, err = %v", seed, err)
279	}
280	for i := range dAtA {
281		dAtA[i] = byte(popr.Intn(256))
282	}
283	if err := p.VerboseEqual(msg); err != nil {
284		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
285	}
286	if !p.Equal(msg) {
287		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
288	}
289}
290
291func BenchmarkAllMapsProtoMarshal(b *testing.B) {
292	popr := math_rand.New(math_rand.NewSource(616))
293	total := 0
294	pops := make([]*AllMaps, 10000)
295	for i := 0; i < 10000; i++ {
296		pops[i] = NewPopulatedAllMaps(popr, false)
297	}
298	b.ResetTimer()
299	for i := 0; i < b.N; i++ {
300		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
301		if err != nil {
302			panic(err)
303		}
304		total += len(dAtA)
305	}
306	b.SetBytes(int64(total / b.N))
307}
308
309func BenchmarkAllMapsProtoUnmarshal(b *testing.B) {
310	popr := math_rand.New(math_rand.NewSource(616))
311	total := 0
312	datas := make([][]byte, 10000)
313	for i := 0; i < 10000; i++ {
314		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false))
315		if err != nil {
316			panic(err)
317		}
318		datas[i] = dAtA
319	}
320	msg := &AllMaps{}
321	b.ResetTimer()
322	for i := 0; i < b.N; i++ {
323		total += len(datas[i%10000])
324		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
325			panic(err)
326		}
327	}
328	b.SetBytes(int64(total / b.N))
329}
330
331func TestAllMapsOrderedProto(t *testing.T) {
332	seed := time.Now().UnixNano()
333	popr := math_rand.New(math_rand.NewSource(seed))
334	p := NewPopulatedAllMapsOrdered(popr, false)
335	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
336	if err != nil {
337		t.Fatalf("seed = %d, err = %v", seed, err)
338	}
339	msg := &AllMapsOrdered{}
340	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
341		t.Fatalf("seed = %d, err = %v", seed, err)
342	}
343	littlefuzz := make([]byte, len(dAtA))
344	copy(littlefuzz, dAtA)
345	for i := range dAtA {
346		dAtA[i] = byte(popr.Intn(256))
347	}
348	if err := p.VerboseEqual(msg); err != nil {
349		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
350	}
351	if !p.Equal(msg) {
352		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
353	}
354	if len(littlefuzz) > 0 {
355		fuzzamount := 100
356		for i := 0; i < fuzzamount; i++ {
357			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
358			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
359		}
360		// shouldn't panic
361		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
362	}
363}
364
365func TestAllMapsOrderedMarshalTo(t *testing.T) {
366	seed := time.Now().UnixNano()
367	popr := math_rand.New(math_rand.NewSource(seed))
368	p := NewPopulatedAllMapsOrdered(popr, false)
369	size := p.Size()
370	dAtA := make([]byte, size)
371	for i := range dAtA {
372		dAtA[i] = byte(popr.Intn(256))
373	}
374	_, err := p.MarshalTo(dAtA)
375	if err != nil {
376		t.Fatalf("seed = %d, err = %v", seed, err)
377	}
378	msg := &AllMapsOrdered{}
379	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
380		t.Fatalf("seed = %d, err = %v", seed, err)
381	}
382	for i := range dAtA {
383		dAtA[i] = byte(popr.Intn(256))
384	}
385	if err := p.VerboseEqual(msg); err != nil {
386		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
387	}
388	if !p.Equal(msg) {
389		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
390	}
391}
392
393func BenchmarkAllMapsOrderedProtoMarshal(b *testing.B) {
394	popr := math_rand.New(math_rand.NewSource(616))
395	total := 0
396	pops := make([]*AllMapsOrdered, 10000)
397	for i := 0; i < 10000; i++ {
398		pops[i] = NewPopulatedAllMapsOrdered(popr, false)
399	}
400	b.ResetTimer()
401	for i := 0; i < b.N; i++ {
402		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
403		if err != nil {
404			panic(err)
405		}
406		total += len(dAtA)
407	}
408	b.SetBytes(int64(total / b.N))
409}
410
411func BenchmarkAllMapsOrderedProtoUnmarshal(b *testing.B) {
412	popr := math_rand.New(math_rand.NewSource(616))
413	total := 0
414	datas := make([][]byte, 10000)
415	for i := 0; i < 10000; i++ {
416		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMapsOrdered(popr, false))
417		if err != nil {
418			panic(err)
419		}
420		datas[i] = dAtA
421	}
422	msg := &AllMapsOrdered{}
423	b.ResetTimer()
424	for i := 0; i < b.N; i++ {
425		total += len(datas[i%10000])
426		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
427			panic(err)
428		}
429	}
430	b.SetBytes(int64(total / b.N))
431}
432
433func TestMessageWithMapProto(t *testing.T) {
434	seed := time.Now().UnixNano()
435	popr := math_rand.New(math_rand.NewSource(seed))
436	p := NewPopulatedMessageWithMap(popr, false)
437	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
438	if err != nil {
439		t.Fatalf("seed = %d, err = %v", seed, err)
440	}
441	msg := &MessageWithMap{}
442	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
443		t.Fatalf("seed = %d, err = %v", seed, err)
444	}
445	littlefuzz := make([]byte, len(dAtA))
446	copy(littlefuzz, dAtA)
447	for i := range dAtA {
448		dAtA[i] = byte(popr.Intn(256))
449	}
450	if err := p.VerboseEqual(msg); err != nil {
451		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
452	}
453	if !p.Equal(msg) {
454		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
455	}
456	if len(littlefuzz) > 0 {
457		fuzzamount := 100
458		for i := 0; i < fuzzamount; i++ {
459			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
460			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
461		}
462		// shouldn't panic
463		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
464	}
465}
466
467func TestMessageWithMapMarshalTo(t *testing.T) {
468	seed := time.Now().UnixNano()
469	popr := math_rand.New(math_rand.NewSource(seed))
470	p := NewPopulatedMessageWithMap(popr, false)
471	size := p.Size()
472	dAtA := make([]byte, size)
473	for i := range dAtA {
474		dAtA[i] = byte(popr.Intn(256))
475	}
476	_, err := p.MarshalTo(dAtA)
477	if err != nil {
478		t.Fatalf("seed = %d, err = %v", seed, err)
479	}
480	msg := &MessageWithMap{}
481	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
482		t.Fatalf("seed = %d, err = %v", seed, err)
483	}
484	for i := range dAtA {
485		dAtA[i] = byte(popr.Intn(256))
486	}
487	if err := p.VerboseEqual(msg); err != nil {
488		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
489	}
490	if !p.Equal(msg) {
491		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
492	}
493}
494
495func BenchmarkMessageWithMapProtoMarshal(b *testing.B) {
496	popr := math_rand.New(math_rand.NewSource(616))
497	total := 0
498	pops := make([]*MessageWithMap, 10000)
499	for i := 0; i < 10000; i++ {
500		pops[i] = NewPopulatedMessageWithMap(popr, false)
501	}
502	b.ResetTimer()
503	for i := 0; i < b.N; i++ {
504		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
505		if err != nil {
506			panic(err)
507		}
508		total += len(dAtA)
509	}
510	b.SetBytes(int64(total / b.N))
511}
512
513func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) {
514	popr := math_rand.New(math_rand.NewSource(616))
515	total := 0
516	datas := make([][]byte, 10000)
517	for i := 0; i < 10000; i++ {
518		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessageWithMap(popr, false))
519		if err != nil {
520			panic(err)
521		}
522		datas[i] = dAtA
523	}
524	msg := &MessageWithMap{}
525	b.ResetTimer()
526	for i := 0; i < b.N; i++ {
527		total += len(datas[i%10000])
528		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
529			panic(err)
530		}
531	}
532	b.SetBytes(int64(total / b.N))
533}
534
535func TestFloatingPointProto(t *testing.T) {
536	seed := time.Now().UnixNano()
537	popr := math_rand.New(math_rand.NewSource(seed))
538	p := NewPopulatedFloatingPoint(popr, false)
539	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
540	if err != nil {
541		t.Fatalf("seed = %d, err = %v", seed, err)
542	}
543	msg := &FloatingPoint{}
544	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
545		t.Fatalf("seed = %d, err = %v", seed, err)
546	}
547	littlefuzz := make([]byte, len(dAtA))
548	copy(littlefuzz, dAtA)
549	for i := range dAtA {
550		dAtA[i] = byte(popr.Intn(256))
551	}
552	if err := p.VerboseEqual(msg); err != nil {
553		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
554	}
555	if !p.Equal(msg) {
556		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
557	}
558	if len(littlefuzz) > 0 {
559		fuzzamount := 100
560		for i := 0; i < fuzzamount; i++ {
561			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
562			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
563		}
564		// shouldn't panic
565		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
566	}
567}
568
569func TestFloatingPointMarshalTo(t *testing.T) {
570	seed := time.Now().UnixNano()
571	popr := math_rand.New(math_rand.NewSource(seed))
572	p := NewPopulatedFloatingPoint(popr, false)
573	size := p.Size()
574	dAtA := make([]byte, size)
575	for i := range dAtA {
576		dAtA[i] = byte(popr.Intn(256))
577	}
578	_, err := p.MarshalTo(dAtA)
579	if err != nil {
580		t.Fatalf("seed = %d, err = %v", seed, err)
581	}
582	msg := &FloatingPoint{}
583	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
584		t.Fatalf("seed = %d, err = %v", seed, err)
585	}
586	for i := range dAtA {
587		dAtA[i] = byte(popr.Intn(256))
588	}
589	if err := p.VerboseEqual(msg); err != nil {
590		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
591	}
592	if !p.Equal(msg) {
593		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
594	}
595}
596
597func BenchmarkFloatingPointProtoMarshal(b *testing.B) {
598	popr := math_rand.New(math_rand.NewSource(616))
599	total := 0
600	pops := make([]*FloatingPoint, 10000)
601	for i := 0; i < 10000; i++ {
602		pops[i] = NewPopulatedFloatingPoint(popr, false)
603	}
604	b.ResetTimer()
605	for i := 0; i < b.N; i++ {
606		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
607		if err != nil {
608			panic(err)
609		}
610		total += len(dAtA)
611	}
612	b.SetBytes(int64(total / b.N))
613}
614
615func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) {
616	popr := math_rand.New(math_rand.NewSource(616))
617	total := 0
618	datas := make([][]byte, 10000)
619	for i := 0; i < 10000; i++ {
620		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false))
621		if err != nil {
622			panic(err)
623		}
624		datas[i] = dAtA
625	}
626	msg := &FloatingPoint{}
627	b.ResetTimer()
628	for i := 0; i < b.N; i++ {
629		total += len(datas[i%10000])
630		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
631			panic(err)
632		}
633	}
634	b.SetBytes(int64(total / b.N))
635}
636
637func TestUint128PairProto(t *testing.T) {
638	seed := time.Now().UnixNano()
639	popr := math_rand.New(math_rand.NewSource(seed))
640	p := NewPopulatedUint128Pair(popr, false)
641	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
642	if err != nil {
643		t.Fatalf("seed = %d, err = %v", seed, err)
644	}
645	msg := &Uint128Pair{}
646	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
647		t.Fatalf("seed = %d, err = %v", seed, err)
648	}
649	littlefuzz := make([]byte, len(dAtA))
650	copy(littlefuzz, dAtA)
651	for i := range dAtA {
652		dAtA[i] = byte(popr.Intn(256))
653	}
654	if err := p.VerboseEqual(msg); err != nil {
655		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
656	}
657	if !p.Equal(msg) {
658		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
659	}
660	if len(littlefuzz) > 0 {
661		fuzzamount := 100
662		for i := 0; i < fuzzamount; i++ {
663			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
664			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
665		}
666		// shouldn't panic
667		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
668	}
669}
670
671func TestUint128PairMarshalTo(t *testing.T) {
672	seed := time.Now().UnixNano()
673	popr := math_rand.New(math_rand.NewSource(seed))
674	p := NewPopulatedUint128Pair(popr, false)
675	size := p.Size()
676	dAtA := make([]byte, size)
677	for i := range dAtA {
678		dAtA[i] = byte(popr.Intn(256))
679	}
680	_, err := p.MarshalTo(dAtA)
681	if err != nil {
682		t.Fatalf("seed = %d, err = %v", seed, err)
683	}
684	msg := &Uint128Pair{}
685	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
686		t.Fatalf("seed = %d, err = %v", seed, err)
687	}
688	for i := range dAtA {
689		dAtA[i] = byte(popr.Intn(256))
690	}
691	if err := p.VerboseEqual(msg); err != nil {
692		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
693	}
694	if !p.Equal(msg) {
695		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
696	}
697}
698
699func BenchmarkUint128PairProtoMarshal(b *testing.B) {
700	popr := math_rand.New(math_rand.NewSource(616))
701	total := 0
702	pops := make([]*Uint128Pair, 10000)
703	for i := 0; i < 10000; i++ {
704		pops[i] = NewPopulatedUint128Pair(popr, false)
705	}
706	b.ResetTimer()
707	for i := 0; i < b.N; i++ {
708		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
709		if err != nil {
710			panic(err)
711		}
712		total += len(dAtA)
713	}
714	b.SetBytes(int64(total / b.N))
715}
716
717func BenchmarkUint128PairProtoUnmarshal(b *testing.B) {
718	popr := math_rand.New(math_rand.NewSource(616))
719	total := 0
720	datas := make([][]byte, 10000)
721	for i := 0; i < 10000; i++ {
722		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUint128Pair(popr, false))
723		if err != nil {
724			panic(err)
725		}
726		datas[i] = dAtA
727	}
728	msg := &Uint128Pair{}
729	b.ResetTimer()
730	for i := 0; i < b.N; i++ {
731		total += len(datas[i%10000])
732		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
733			panic(err)
734		}
735	}
736	b.SetBytes(int64(total / b.N))
737}
738
739func TestContainsNestedMapProto(t *testing.T) {
740	seed := time.Now().UnixNano()
741	popr := math_rand.New(math_rand.NewSource(seed))
742	p := NewPopulatedContainsNestedMap(popr, false)
743	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
744	if err != nil {
745		t.Fatalf("seed = %d, err = %v", seed, err)
746	}
747	msg := &ContainsNestedMap{}
748	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
749		t.Fatalf("seed = %d, err = %v", seed, err)
750	}
751	littlefuzz := make([]byte, len(dAtA))
752	copy(littlefuzz, dAtA)
753	for i := range dAtA {
754		dAtA[i] = byte(popr.Intn(256))
755	}
756	if err := p.VerboseEqual(msg); err != nil {
757		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
758	}
759	if !p.Equal(msg) {
760		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
761	}
762	if len(littlefuzz) > 0 {
763		fuzzamount := 100
764		for i := 0; i < fuzzamount; i++ {
765			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
766			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
767		}
768		// shouldn't panic
769		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
770	}
771}
772
773func TestContainsNestedMapMarshalTo(t *testing.T) {
774	seed := time.Now().UnixNano()
775	popr := math_rand.New(math_rand.NewSource(seed))
776	p := NewPopulatedContainsNestedMap(popr, false)
777	size := p.Size()
778	dAtA := make([]byte, size)
779	for i := range dAtA {
780		dAtA[i] = byte(popr.Intn(256))
781	}
782	_, err := p.MarshalTo(dAtA)
783	if err != nil {
784		t.Fatalf("seed = %d, err = %v", seed, err)
785	}
786	msg := &ContainsNestedMap{}
787	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
788		t.Fatalf("seed = %d, err = %v", seed, err)
789	}
790	for i := range dAtA {
791		dAtA[i] = byte(popr.Intn(256))
792	}
793	if err := p.VerboseEqual(msg); err != nil {
794		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
795	}
796	if !p.Equal(msg) {
797		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
798	}
799}
800
801func BenchmarkContainsNestedMapProtoMarshal(b *testing.B) {
802	popr := math_rand.New(math_rand.NewSource(616))
803	total := 0
804	pops := make([]*ContainsNestedMap, 10000)
805	for i := 0; i < 10000; i++ {
806		pops[i] = NewPopulatedContainsNestedMap(popr, false)
807	}
808	b.ResetTimer()
809	for i := 0; i < b.N; i++ {
810		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
811		if err != nil {
812			panic(err)
813		}
814		total += len(dAtA)
815	}
816	b.SetBytes(int64(total / b.N))
817}
818
819func BenchmarkContainsNestedMapProtoUnmarshal(b *testing.B) {
820	popr := math_rand.New(math_rand.NewSource(616))
821	total := 0
822	datas := make([][]byte, 10000)
823	for i := 0; i < 10000; i++ {
824		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedContainsNestedMap(popr, false))
825		if err != nil {
826			panic(err)
827		}
828		datas[i] = dAtA
829	}
830	msg := &ContainsNestedMap{}
831	b.ResetTimer()
832	for i := 0; i < b.N; i++ {
833		total += len(datas[i%10000])
834		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
835			panic(err)
836		}
837	}
838	b.SetBytes(int64(total / b.N))
839}
840
841func TestContainsNestedMap_NestedMapProto(t *testing.T) {
842	seed := time.Now().UnixNano()
843	popr := math_rand.New(math_rand.NewSource(seed))
844	p := NewPopulatedContainsNestedMap_NestedMap(popr, false)
845	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
846	if err != nil {
847		t.Fatalf("seed = %d, err = %v", seed, err)
848	}
849	msg := &ContainsNestedMap_NestedMap{}
850	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
851		t.Fatalf("seed = %d, err = %v", seed, err)
852	}
853	littlefuzz := make([]byte, len(dAtA))
854	copy(littlefuzz, dAtA)
855	for i := range dAtA {
856		dAtA[i] = byte(popr.Intn(256))
857	}
858	if err := p.VerboseEqual(msg); err != nil {
859		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
860	}
861	if !p.Equal(msg) {
862		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
863	}
864	if len(littlefuzz) > 0 {
865		fuzzamount := 100
866		for i := 0; i < fuzzamount; i++ {
867			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
868			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
869		}
870		// shouldn't panic
871		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
872	}
873}
874
875func TestContainsNestedMap_NestedMapMarshalTo(t *testing.T) {
876	seed := time.Now().UnixNano()
877	popr := math_rand.New(math_rand.NewSource(seed))
878	p := NewPopulatedContainsNestedMap_NestedMap(popr, false)
879	size := p.Size()
880	dAtA := make([]byte, size)
881	for i := range dAtA {
882		dAtA[i] = byte(popr.Intn(256))
883	}
884	_, err := p.MarshalTo(dAtA)
885	if err != nil {
886		t.Fatalf("seed = %d, err = %v", seed, err)
887	}
888	msg := &ContainsNestedMap_NestedMap{}
889	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
890		t.Fatalf("seed = %d, err = %v", seed, err)
891	}
892	for i := range dAtA {
893		dAtA[i] = byte(popr.Intn(256))
894	}
895	if err := p.VerboseEqual(msg); err != nil {
896		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
897	}
898	if !p.Equal(msg) {
899		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
900	}
901}
902
903func BenchmarkContainsNestedMap_NestedMapProtoMarshal(b *testing.B) {
904	popr := math_rand.New(math_rand.NewSource(616))
905	total := 0
906	pops := make([]*ContainsNestedMap_NestedMap, 10000)
907	for i := 0; i < 10000; i++ {
908		pops[i] = NewPopulatedContainsNestedMap_NestedMap(popr, false)
909	}
910	b.ResetTimer()
911	for i := 0; i < b.N; i++ {
912		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
913		if err != nil {
914			panic(err)
915		}
916		total += len(dAtA)
917	}
918	b.SetBytes(int64(total / b.N))
919}
920
921func BenchmarkContainsNestedMap_NestedMapProtoUnmarshal(b *testing.B) {
922	popr := math_rand.New(math_rand.NewSource(616))
923	total := 0
924	datas := make([][]byte, 10000)
925	for i := 0; i < 10000; i++ {
926		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedContainsNestedMap_NestedMap(popr, false))
927		if err != nil {
928			panic(err)
929		}
930		datas[i] = dAtA
931	}
932	msg := &ContainsNestedMap_NestedMap{}
933	b.ResetTimer()
934	for i := 0; i < b.N; i++ {
935		total += len(datas[i%10000])
936		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
937			panic(err)
938		}
939	}
940	b.SetBytes(int64(total / b.N))
941}
942
943func TestNotPackedProto(t *testing.T) {
944	seed := time.Now().UnixNano()
945	popr := math_rand.New(math_rand.NewSource(seed))
946	p := NewPopulatedNotPacked(popr, false)
947	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
948	if err != nil {
949		t.Fatalf("seed = %d, err = %v", seed, err)
950	}
951	msg := &NotPacked{}
952	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
953		t.Fatalf("seed = %d, err = %v", seed, err)
954	}
955	littlefuzz := make([]byte, len(dAtA))
956	copy(littlefuzz, dAtA)
957	for i := range dAtA {
958		dAtA[i] = byte(popr.Intn(256))
959	}
960	if err := p.VerboseEqual(msg); err != nil {
961		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
962	}
963	if !p.Equal(msg) {
964		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
965	}
966	if len(littlefuzz) > 0 {
967		fuzzamount := 100
968		for i := 0; i < fuzzamount; i++ {
969			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
970			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
971		}
972		// shouldn't panic
973		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
974	}
975}
976
977func TestNotPackedMarshalTo(t *testing.T) {
978	seed := time.Now().UnixNano()
979	popr := math_rand.New(math_rand.NewSource(seed))
980	p := NewPopulatedNotPacked(popr, false)
981	size := p.Size()
982	dAtA := make([]byte, size)
983	for i := range dAtA {
984		dAtA[i] = byte(popr.Intn(256))
985	}
986	_, err := p.MarshalTo(dAtA)
987	if err != nil {
988		t.Fatalf("seed = %d, err = %v", seed, err)
989	}
990	msg := &NotPacked{}
991	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
992		t.Fatalf("seed = %d, err = %v", seed, err)
993	}
994	for i := range dAtA {
995		dAtA[i] = byte(popr.Intn(256))
996	}
997	if err := p.VerboseEqual(msg); err != nil {
998		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
999	}
1000	if !p.Equal(msg) {
1001		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1002	}
1003}
1004
1005func BenchmarkNotPackedProtoMarshal(b *testing.B) {
1006	popr := math_rand.New(math_rand.NewSource(616))
1007	total := 0
1008	pops := make([]*NotPacked, 10000)
1009	for i := 0; i < 10000; i++ {
1010		pops[i] = NewPopulatedNotPacked(popr, false)
1011	}
1012	b.ResetTimer()
1013	for i := 0; i < b.N; i++ {
1014		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1015		if err != nil {
1016			panic(err)
1017		}
1018		total += len(dAtA)
1019	}
1020	b.SetBytes(int64(total / b.N))
1021}
1022
1023func BenchmarkNotPackedProtoUnmarshal(b *testing.B) {
1024	popr := math_rand.New(math_rand.NewSource(616))
1025	total := 0
1026	datas := make([][]byte, 10000)
1027	for i := 0; i < 10000; i++ {
1028		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNotPacked(popr, false))
1029		if err != nil {
1030			panic(err)
1031		}
1032		datas[i] = dAtA
1033	}
1034	msg := &NotPacked{}
1035	b.ResetTimer()
1036	for i := 0; i < b.N; i++ {
1037		total += len(datas[i%10000])
1038		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1039			panic(err)
1040		}
1041	}
1042	b.SetBytes(int64(total / b.N))
1043}
1044
1045func TestMessageJSON(t *testing.T) {
1046	seed := time.Now().UnixNano()
1047	popr := math_rand.New(math_rand.NewSource(seed))
1048	p := NewPopulatedMessage(popr, true)
1049	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
1050	jsondata, err := marshaler.MarshalToString(p)
1051	if err != nil {
1052		t.Fatalf("seed = %d, err = %v", seed, err)
1053	}
1054	msg := &Message{}
1055	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
1056	if err != nil {
1057		t.Fatalf("seed = %d, err = %v", seed, err)
1058	}
1059	if err := p.VerboseEqual(msg); err != nil {
1060		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1061	}
1062	if !p.Equal(msg) {
1063		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
1064	}
1065}
1066func TestNestedJSON(t *testing.T) {
1067	seed := time.Now().UnixNano()
1068	popr := math_rand.New(math_rand.NewSource(seed))
1069	p := NewPopulatedNested(popr, true)
1070	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
1071	jsondata, err := marshaler.MarshalToString(p)
1072	if err != nil {
1073		t.Fatalf("seed = %d, err = %v", seed, err)
1074	}
1075	msg := &Nested{}
1076	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
1077	if err != nil {
1078		t.Fatalf("seed = %d, err = %v", seed, err)
1079	}
1080	if err := p.VerboseEqual(msg); err != nil {
1081		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1082	}
1083	if !p.Equal(msg) {
1084		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
1085	}
1086}
1087func TestAllMapsJSON(t *testing.T) {
1088	seed := time.Now().UnixNano()
1089	popr := math_rand.New(math_rand.NewSource(seed))
1090	p := NewPopulatedAllMaps(popr, true)
1091	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
1092	jsondata, err := marshaler.MarshalToString(p)
1093	if err != nil {
1094		t.Fatalf("seed = %d, err = %v", seed, err)
1095	}
1096	msg := &AllMaps{}
1097	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
1098	if err != nil {
1099		t.Fatalf("seed = %d, err = %v", seed, err)
1100	}
1101	if err := p.VerboseEqual(msg); err != nil {
1102		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1103	}
1104	if !p.Equal(msg) {
1105		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
1106	}
1107}
1108func TestAllMapsOrderedJSON(t *testing.T) {
1109	seed := time.Now().UnixNano()
1110	popr := math_rand.New(math_rand.NewSource(seed))
1111	p := NewPopulatedAllMapsOrdered(popr, true)
1112	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
1113	jsondata, err := marshaler.MarshalToString(p)
1114	if err != nil {
1115		t.Fatalf("seed = %d, err = %v", seed, err)
1116	}
1117	msg := &AllMapsOrdered{}
1118	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
1119	if err != nil {
1120		t.Fatalf("seed = %d, err = %v", seed, err)
1121	}
1122	if err := p.VerboseEqual(msg); err != nil {
1123		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1124	}
1125	if !p.Equal(msg) {
1126		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
1127	}
1128}
1129func TestMessageWithMapJSON(t *testing.T) {
1130	seed := time.Now().UnixNano()
1131	popr := math_rand.New(math_rand.NewSource(seed))
1132	p := NewPopulatedMessageWithMap(popr, true)
1133	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
1134	jsondata, err := marshaler.MarshalToString(p)
1135	if err != nil {
1136		t.Fatalf("seed = %d, err = %v", seed, err)
1137	}
1138	msg := &MessageWithMap{}
1139	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
1140	if err != nil {
1141		t.Fatalf("seed = %d, err = %v", seed, err)
1142	}
1143	if err := p.VerboseEqual(msg); err != nil {
1144		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1145	}
1146	if !p.Equal(msg) {
1147		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
1148	}
1149}
1150func TestFloatingPointJSON(t *testing.T) {
1151	seed := time.Now().UnixNano()
1152	popr := math_rand.New(math_rand.NewSource(seed))
1153	p := NewPopulatedFloatingPoint(popr, true)
1154	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
1155	jsondata, err := marshaler.MarshalToString(p)
1156	if err != nil {
1157		t.Fatalf("seed = %d, err = %v", seed, err)
1158	}
1159	msg := &FloatingPoint{}
1160	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
1161	if err != nil {
1162		t.Fatalf("seed = %d, err = %v", seed, err)
1163	}
1164	if err := p.VerboseEqual(msg); err != nil {
1165		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1166	}
1167	if !p.Equal(msg) {
1168		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
1169	}
1170}
1171func TestUint128PairJSON(t *testing.T) {
1172	seed := time.Now().UnixNano()
1173	popr := math_rand.New(math_rand.NewSource(seed))
1174	p := NewPopulatedUint128Pair(popr, true)
1175	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
1176	jsondata, err := marshaler.MarshalToString(p)
1177	if err != nil {
1178		t.Fatalf("seed = %d, err = %v", seed, err)
1179	}
1180	msg := &Uint128Pair{}
1181	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
1182	if err != nil {
1183		t.Fatalf("seed = %d, err = %v", seed, err)
1184	}
1185	if err := p.VerboseEqual(msg); err != nil {
1186		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1187	}
1188	if !p.Equal(msg) {
1189		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
1190	}
1191}
1192func TestContainsNestedMapJSON(t *testing.T) {
1193	seed := time.Now().UnixNano()
1194	popr := math_rand.New(math_rand.NewSource(seed))
1195	p := NewPopulatedContainsNestedMap(popr, true)
1196	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
1197	jsondata, err := marshaler.MarshalToString(p)
1198	if err != nil {
1199		t.Fatalf("seed = %d, err = %v", seed, err)
1200	}
1201	msg := &ContainsNestedMap{}
1202	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
1203	if err != nil {
1204		t.Fatalf("seed = %d, err = %v", seed, err)
1205	}
1206	if err := p.VerboseEqual(msg); err != nil {
1207		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1208	}
1209	if !p.Equal(msg) {
1210		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
1211	}
1212}
1213func TestContainsNestedMap_NestedMapJSON(t *testing.T) {
1214	seed := time.Now().UnixNano()
1215	popr := math_rand.New(math_rand.NewSource(seed))
1216	p := NewPopulatedContainsNestedMap_NestedMap(popr, true)
1217	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
1218	jsondata, err := marshaler.MarshalToString(p)
1219	if err != nil {
1220		t.Fatalf("seed = %d, err = %v", seed, err)
1221	}
1222	msg := &ContainsNestedMap_NestedMap{}
1223	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
1224	if err != nil {
1225		t.Fatalf("seed = %d, err = %v", seed, err)
1226	}
1227	if err := p.VerboseEqual(msg); err != nil {
1228		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1229	}
1230	if !p.Equal(msg) {
1231		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
1232	}
1233}
1234func TestNotPackedJSON(t *testing.T) {
1235	seed := time.Now().UnixNano()
1236	popr := math_rand.New(math_rand.NewSource(seed))
1237	p := NewPopulatedNotPacked(popr, true)
1238	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
1239	jsondata, err := marshaler.MarshalToString(p)
1240	if err != nil {
1241		t.Fatalf("seed = %d, err = %v", seed, err)
1242	}
1243	msg := &NotPacked{}
1244	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
1245	if err != nil {
1246		t.Fatalf("seed = %d, err = %v", seed, err)
1247	}
1248	if err := p.VerboseEqual(msg); err != nil {
1249		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1250	}
1251	if !p.Equal(msg) {
1252		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
1253	}
1254}
1255func TestMessageProtoText(t *testing.T) {
1256	seed := time.Now().UnixNano()
1257	popr := math_rand.New(math_rand.NewSource(seed))
1258	p := NewPopulatedMessage(popr, true)
1259	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1260	msg := &Message{}
1261	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1262		t.Fatalf("seed = %d, err = %v", seed, err)
1263	}
1264	if err := p.VerboseEqual(msg); err != nil {
1265		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1266	}
1267	if !p.Equal(msg) {
1268		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1269	}
1270}
1271
1272func TestMessageProtoCompactText(t *testing.T) {
1273	seed := time.Now().UnixNano()
1274	popr := math_rand.New(math_rand.NewSource(seed))
1275	p := NewPopulatedMessage(popr, true)
1276	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1277	msg := &Message{}
1278	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1279		t.Fatalf("seed = %d, err = %v", seed, err)
1280	}
1281	if err := p.VerboseEqual(msg); err != nil {
1282		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1283	}
1284	if !p.Equal(msg) {
1285		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1286	}
1287}
1288
1289func TestNestedProtoText(t *testing.T) {
1290	seed := time.Now().UnixNano()
1291	popr := math_rand.New(math_rand.NewSource(seed))
1292	p := NewPopulatedNested(popr, true)
1293	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1294	msg := &Nested{}
1295	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1296		t.Fatalf("seed = %d, err = %v", seed, err)
1297	}
1298	if err := p.VerboseEqual(msg); err != nil {
1299		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1300	}
1301	if !p.Equal(msg) {
1302		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1303	}
1304}
1305
1306func TestNestedProtoCompactText(t *testing.T) {
1307	seed := time.Now().UnixNano()
1308	popr := math_rand.New(math_rand.NewSource(seed))
1309	p := NewPopulatedNested(popr, true)
1310	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1311	msg := &Nested{}
1312	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1313		t.Fatalf("seed = %d, err = %v", seed, err)
1314	}
1315	if err := p.VerboseEqual(msg); err != nil {
1316		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1317	}
1318	if !p.Equal(msg) {
1319		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1320	}
1321}
1322
1323func TestAllMapsProtoText(t *testing.T) {
1324	seed := time.Now().UnixNano()
1325	popr := math_rand.New(math_rand.NewSource(seed))
1326	p := NewPopulatedAllMaps(popr, true)
1327	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1328	msg := &AllMaps{}
1329	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1330		t.Fatalf("seed = %d, err = %v", seed, err)
1331	}
1332	if err := p.VerboseEqual(msg); err != nil {
1333		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1334	}
1335	if !p.Equal(msg) {
1336		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1337	}
1338}
1339
1340func TestAllMapsProtoCompactText(t *testing.T) {
1341	seed := time.Now().UnixNano()
1342	popr := math_rand.New(math_rand.NewSource(seed))
1343	p := NewPopulatedAllMaps(popr, true)
1344	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1345	msg := &AllMaps{}
1346	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1347		t.Fatalf("seed = %d, err = %v", seed, err)
1348	}
1349	if err := p.VerboseEqual(msg); err != nil {
1350		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1351	}
1352	if !p.Equal(msg) {
1353		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1354	}
1355}
1356
1357func TestAllMapsOrderedProtoText(t *testing.T) {
1358	seed := time.Now().UnixNano()
1359	popr := math_rand.New(math_rand.NewSource(seed))
1360	p := NewPopulatedAllMapsOrdered(popr, true)
1361	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1362	msg := &AllMapsOrdered{}
1363	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1364		t.Fatalf("seed = %d, err = %v", seed, err)
1365	}
1366	if err := p.VerboseEqual(msg); err != nil {
1367		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1368	}
1369	if !p.Equal(msg) {
1370		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1371	}
1372}
1373
1374func TestAllMapsOrderedProtoCompactText(t *testing.T) {
1375	seed := time.Now().UnixNano()
1376	popr := math_rand.New(math_rand.NewSource(seed))
1377	p := NewPopulatedAllMapsOrdered(popr, true)
1378	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1379	msg := &AllMapsOrdered{}
1380	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1381		t.Fatalf("seed = %d, err = %v", seed, err)
1382	}
1383	if err := p.VerboseEqual(msg); err != nil {
1384		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1385	}
1386	if !p.Equal(msg) {
1387		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1388	}
1389}
1390
1391func TestMessageWithMapProtoText(t *testing.T) {
1392	seed := time.Now().UnixNano()
1393	popr := math_rand.New(math_rand.NewSource(seed))
1394	p := NewPopulatedMessageWithMap(popr, true)
1395	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1396	msg := &MessageWithMap{}
1397	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1398		t.Fatalf("seed = %d, err = %v", seed, err)
1399	}
1400	if err := p.VerboseEqual(msg); err != nil {
1401		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1402	}
1403	if !p.Equal(msg) {
1404		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1405	}
1406}
1407
1408func TestMessageWithMapProtoCompactText(t *testing.T) {
1409	seed := time.Now().UnixNano()
1410	popr := math_rand.New(math_rand.NewSource(seed))
1411	p := NewPopulatedMessageWithMap(popr, true)
1412	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1413	msg := &MessageWithMap{}
1414	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1415		t.Fatalf("seed = %d, err = %v", seed, err)
1416	}
1417	if err := p.VerboseEqual(msg); err != nil {
1418		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1419	}
1420	if !p.Equal(msg) {
1421		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1422	}
1423}
1424
1425func TestFloatingPointProtoText(t *testing.T) {
1426	seed := time.Now().UnixNano()
1427	popr := math_rand.New(math_rand.NewSource(seed))
1428	p := NewPopulatedFloatingPoint(popr, true)
1429	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1430	msg := &FloatingPoint{}
1431	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1432		t.Fatalf("seed = %d, err = %v", seed, err)
1433	}
1434	if err := p.VerboseEqual(msg); err != nil {
1435		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1436	}
1437	if !p.Equal(msg) {
1438		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1439	}
1440}
1441
1442func TestFloatingPointProtoCompactText(t *testing.T) {
1443	seed := time.Now().UnixNano()
1444	popr := math_rand.New(math_rand.NewSource(seed))
1445	p := NewPopulatedFloatingPoint(popr, true)
1446	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1447	msg := &FloatingPoint{}
1448	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1449		t.Fatalf("seed = %d, err = %v", seed, err)
1450	}
1451	if err := p.VerboseEqual(msg); err != nil {
1452		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1453	}
1454	if !p.Equal(msg) {
1455		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1456	}
1457}
1458
1459func TestUint128PairProtoText(t *testing.T) {
1460	seed := time.Now().UnixNano()
1461	popr := math_rand.New(math_rand.NewSource(seed))
1462	p := NewPopulatedUint128Pair(popr, true)
1463	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1464	msg := &Uint128Pair{}
1465	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1466		t.Fatalf("seed = %d, err = %v", seed, err)
1467	}
1468	if err := p.VerboseEqual(msg); err != nil {
1469		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1470	}
1471	if !p.Equal(msg) {
1472		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1473	}
1474}
1475
1476func TestUint128PairProtoCompactText(t *testing.T) {
1477	seed := time.Now().UnixNano()
1478	popr := math_rand.New(math_rand.NewSource(seed))
1479	p := NewPopulatedUint128Pair(popr, true)
1480	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1481	msg := &Uint128Pair{}
1482	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1483		t.Fatalf("seed = %d, err = %v", seed, err)
1484	}
1485	if err := p.VerboseEqual(msg); err != nil {
1486		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1487	}
1488	if !p.Equal(msg) {
1489		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1490	}
1491}
1492
1493func TestContainsNestedMapProtoText(t *testing.T) {
1494	seed := time.Now().UnixNano()
1495	popr := math_rand.New(math_rand.NewSource(seed))
1496	p := NewPopulatedContainsNestedMap(popr, true)
1497	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1498	msg := &ContainsNestedMap{}
1499	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1500		t.Fatalf("seed = %d, err = %v", seed, err)
1501	}
1502	if err := p.VerboseEqual(msg); err != nil {
1503		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1504	}
1505	if !p.Equal(msg) {
1506		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1507	}
1508}
1509
1510func TestContainsNestedMapProtoCompactText(t *testing.T) {
1511	seed := time.Now().UnixNano()
1512	popr := math_rand.New(math_rand.NewSource(seed))
1513	p := NewPopulatedContainsNestedMap(popr, true)
1514	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1515	msg := &ContainsNestedMap{}
1516	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1517		t.Fatalf("seed = %d, err = %v", seed, err)
1518	}
1519	if err := p.VerboseEqual(msg); err != nil {
1520		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1521	}
1522	if !p.Equal(msg) {
1523		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1524	}
1525}
1526
1527func TestContainsNestedMap_NestedMapProtoText(t *testing.T) {
1528	seed := time.Now().UnixNano()
1529	popr := math_rand.New(math_rand.NewSource(seed))
1530	p := NewPopulatedContainsNestedMap_NestedMap(popr, true)
1531	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1532	msg := &ContainsNestedMap_NestedMap{}
1533	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1534		t.Fatalf("seed = %d, err = %v", seed, err)
1535	}
1536	if err := p.VerboseEqual(msg); err != nil {
1537		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1538	}
1539	if !p.Equal(msg) {
1540		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1541	}
1542}
1543
1544func TestContainsNestedMap_NestedMapProtoCompactText(t *testing.T) {
1545	seed := time.Now().UnixNano()
1546	popr := math_rand.New(math_rand.NewSource(seed))
1547	p := NewPopulatedContainsNestedMap_NestedMap(popr, true)
1548	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1549	msg := &ContainsNestedMap_NestedMap{}
1550	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1551		t.Fatalf("seed = %d, err = %v", seed, err)
1552	}
1553	if err := p.VerboseEqual(msg); err != nil {
1554		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1555	}
1556	if !p.Equal(msg) {
1557		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1558	}
1559}
1560
1561func TestNotPackedProtoText(t *testing.T) {
1562	seed := time.Now().UnixNano()
1563	popr := math_rand.New(math_rand.NewSource(seed))
1564	p := NewPopulatedNotPacked(popr, true)
1565	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1566	msg := &NotPacked{}
1567	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1568		t.Fatalf("seed = %d, err = %v", seed, err)
1569	}
1570	if err := p.VerboseEqual(msg); err != nil {
1571		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1572	}
1573	if !p.Equal(msg) {
1574		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1575	}
1576}
1577
1578func TestNotPackedProtoCompactText(t *testing.T) {
1579	seed := time.Now().UnixNano()
1580	popr := math_rand.New(math_rand.NewSource(seed))
1581	p := NewPopulatedNotPacked(popr, true)
1582	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1583	msg := &NotPacked{}
1584	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1585		t.Fatalf("seed = %d, err = %v", seed, err)
1586	}
1587	if err := p.VerboseEqual(msg); err != nil {
1588		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1589	}
1590	if !p.Equal(msg) {
1591		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1592	}
1593}
1594
1595func TestTheproto3Description(t *testing.T) {
1596	Theproto3Description()
1597}
1598func TestMessageVerboseEqual(t *testing.T) {
1599	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1600	p := NewPopulatedMessage(popr, false)
1601	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1602	if err != nil {
1603		panic(err)
1604	}
1605	msg := &Message{}
1606	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1607		panic(err)
1608	}
1609	if err := p.VerboseEqual(msg); err != nil {
1610		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1611	}
1612}
1613func TestNestedVerboseEqual(t *testing.T) {
1614	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1615	p := NewPopulatedNested(popr, false)
1616	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1617	if err != nil {
1618		panic(err)
1619	}
1620	msg := &Nested{}
1621	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1622		panic(err)
1623	}
1624	if err := p.VerboseEqual(msg); err != nil {
1625		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1626	}
1627}
1628func TestAllMapsVerboseEqual(t *testing.T) {
1629	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1630	p := NewPopulatedAllMaps(popr, false)
1631	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1632	if err != nil {
1633		panic(err)
1634	}
1635	msg := &AllMaps{}
1636	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1637		panic(err)
1638	}
1639	if err := p.VerboseEqual(msg); err != nil {
1640		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1641	}
1642}
1643func TestAllMapsOrderedVerboseEqual(t *testing.T) {
1644	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1645	p := NewPopulatedAllMapsOrdered(popr, false)
1646	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1647	if err != nil {
1648		panic(err)
1649	}
1650	msg := &AllMapsOrdered{}
1651	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1652		panic(err)
1653	}
1654	if err := p.VerboseEqual(msg); err != nil {
1655		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1656	}
1657}
1658func TestMessageWithMapVerboseEqual(t *testing.T) {
1659	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1660	p := NewPopulatedMessageWithMap(popr, false)
1661	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1662	if err != nil {
1663		panic(err)
1664	}
1665	msg := &MessageWithMap{}
1666	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1667		panic(err)
1668	}
1669	if err := p.VerboseEqual(msg); err != nil {
1670		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1671	}
1672}
1673func TestFloatingPointVerboseEqual(t *testing.T) {
1674	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1675	p := NewPopulatedFloatingPoint(popr, false)
1676	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1677	if err != nil {
1678		panic(err)
1679	}
1680	msg := &FloatingPoint{}
1681	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1682		panic(err)
1683	}
1684	if err := p.VerboseEqual(msg); err != nil {
1685		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1686	}
1687}
1688func TestUint128PairVerboseEqual(t *testing.T) {
1689	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1690	p := NewPopulatedUint128Pair(popr, false)
1691	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1692	if err != nil {
1693		panic(err)
1694	}
1695	msg := &Uint128Pair{}
1696	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1697		panic(err)
1698	}
1699	if err := p.VerboseEqual(msg); err != nil {
1700		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1701	}
1702}
1703func TestContainsNestedMapVerboseEqual(t *testing.T) {
1704	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1705	p := NewPopulatedContainsNestedMap(popr, false)
1706	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1707	if err != nil {
1708		panic(err)
1709	}
1710	msg := &ContainsNestedMap{}
1711	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1712		panic(err)
1713	}
1714	if err := p.VerboseEqual(msg); err != nil {
1715		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1716	}
1717}
1718func TestContainsNestedMap_NestedMapVerboseEqual(t *testing.T) {
1719	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1720	p := NewPopulatedContainsNestedMap_NestedMap(popr, false)
1721	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1722	if err != nil {
1723		panic(err)
1724	}
1725	msg := &ContainsNestedMap_NestedMap{}
1726	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1727		panic(err)
1728	}
1729	if err := p.VerboseEqual(msg); err != nil {
1730		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1731	}
1732}
1733func TestNotPackedVerboseEqual(t *testing.T) {
1734	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1735	p := NewPopulatedNotPacked(popr, false)
1736	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1737	if err != nil {
1738		panic(err)
1739	}
1740	msg := &NotPacked{}
1741	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1742		panic(err)
1743	}
1744	if err := p.VerboseEqual(msg); err != nil {
1745		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1746	}
1747}
1748func TestMessageFace(t *testing.T) {
1749	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1750	p := NewPopulatedMessage(popr, true)
1751	msg := p.TestProto()
1752	if !p.Equal(msg) {
1753		t.Fatalf("%#v !Face Equal %#v", msg, p)
1754	}
1755}
1756func TestNestedFace(t *testing.T) {
1757	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1758	p := NewPopulatedNested(popr, true)
1759	msg := p.TestProto()
1760	if !p.Equal(msg) {
1761		t.Fatalf("%#v !Face Equal %#v", msg, p)
1762	}
1763}
1764func TestAllMapsFace(t *testing.T) {
1765	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1766	p := NewPopulatedAllMaps(popr, true)
1767	msg := p.TestProto()
1768	if !p.Equal(msg) {
1769		t.Fatalf("%#v !Face Equal %#v", msg, p)
1770	}
1771}
1772func TestAllMapsOrderedFace(t *testing.T) {
1773	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1774	p := NewPopulatedAllMapsOrdered(popr, true)
1775	msg := p.TestProto()
1776	if !p.Equal(msg) {
1777		t.Fatalf("%#v !Face Equal %#v", msg, p)
1778	}
1779}
1780func TestMessageWithMapFace(t *testing.T) {
1781	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1782	p := NewPopulatedMessageWithMap(popr, true)
1783	msg := p.TestProto()
1784	if !p.Equal(msg) {
1785		t.Fatalf("%#v !Face Equal %#v", msg, p)
1786	}
1787}
1788func TestFloatingPointFace(t *testing.T) {
1789	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1790	p := NewPopulatedFloatingPoint(popr, true)
1791	msg := p.TestProto()
1792	if !p.Equal(msg) {
1793		t.Fatalf("%#v !Face Equal %#v", msg, p)
1794	}
1795}
1796func TestUint128PairFace(t *testing.T) {
1797	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1798	p := NewPopulatedUint128Pair(popr, true)
1799	msg := p.TestProto()
1800	if !p.Equal(msg) {
1801		t.Fatalf("%#v !Face Equal %#v", msg, p)
1802	}
1803}
1804func TestContainsNestedMapFace(t *testing.T) {
1805	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1806	p := NewPopulatedContainsNestedMap(popr, true)
1807	msg := p.TestProto()
1808	if !p.Equal(msg) {
1809		t.Fatalf("%#v !Face Equal %#v", msg, p)
1810	}
1811}
1812func TestContainsNestedMap_NestedMapFace(t *testing.T) {
1813	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1814	p := NewPopulatedContainsNestedMap_NestedMap(popr, true)
1815	msg := p.TestProto()
1816	if !p.Equal(msg) {
1817		t.Fatalf("%#v !Face Equal %#v", msg, p)
1818	}
1819}
1820func TestNotPackedFace(t *testing.T) {
1821	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1822	p := NewPopulatedNotPacked(popr, true)
1823	msg := p.TestProto()
1824	if !p.Equal(msg) {
1825		t.Fatalf("%#v !Face Equal %#v", msg, p)
1826	}
1827}
1828func TestMessageGoString(t *testing.T) {
1829	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1830	p := NewPopulatedMessage(popr, false)
1831	s1 := p.GoString()
1832	s2 := fmt.Sprintf("%#v", p)
1833	if s1 != s2 {
1834		t.Fatalf("GoString want %v got %v", s1, s2)
1835	}
1836	_, err := go_parser.ParseExpr(s1)
1837	if err != nil {
1838		t.Fatal(err)
1839	}
1840}
1841func TestNestedGoString(t *testing.T) {
1842	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1843	p := NewPopulatedNested(popr, false)
1844	s1 := p.GoString()
1845	s2 := fmt.Sprintf("%#v", p)
1846	if s1 != s2 {
1847		t.Fatalf("GoString want %v got %v", s1, s2)
1848	}
1849	_, err := go_parser.ParseExpr(s1)
1850	if err != nil {
1851		t.Fatal(err)
1852	}
1853}
1854func TestAllMapsGoString(t *testing.T) {
1855	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1856	p := NewPopulatedAllMaps(popr, false)
1857	s1 := p.GoString()
1858	s2 := fmt.Sprintf("%#v", p)
1859	if s1 != s2 {
1860		t.Fatalf("GoString want %v got %v", s1, s2)
1861	}
1862	_, err := go_parser.ParseExpr(s1)
1863	if err != nil {
1864		t.Fatal(err)
1865	}
1866}
1867func TestAllMapsOrderedGoString(t *testing.T) {
1868	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1869	p := NewPopulatedAllMapsOrdered(popr, false)
1870	s1 := p.GoString()
1871	s2 := fmt.Sprintf("%#v", p)
1872	if s1 != s2 {
1873		t.Fatalf("GoString want %v got %v", s1, s2)
1874	}
1875	_, err := go_parser.ParseExpr(s1)
1876	if err != nil {
1877		t.Fatal(err)
1878	}
1879}
1880func TestMessageWithMapGoString(t *testing.T) {
1881	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1882	p := NewPopulatedMessageWithMap(popr, false)
1883	s1 := p.GoString()
1884	s2 := fmt.Sprintf("%#v", p)
1885	if s1 != s2 {
1886		t.Fatalf("GoString want %v got %v", s1, s2)
1887	}
1888	_, err := go_parser.ParseExpr(s1)
1889	if err != nil {
1890		t.Fatal(err)
1891	}
1892}
1893func TestFloatingPointGoString(t *testing.T) {
1894	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1895	p := NewPopulatedFloatingPoint(popr, false)
1896	s1 := p.GoString()
1897	s2 := fmt.Sprintf("%#v", p)
1898	if s1 != s2 {
1899		t.Fatalf("GoString want %v got %v", s1, s2)
1900	}
1901	_, err := go_parser.ParseExpr(s1)
1902	if err != nil {
1903		t.Fatal(err)
1904	}
1905}
1906func TestUint128PairGoString(t *testing.T) {
1907	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1908	p := NewPopulatedUint128Pair(popr, false)
1909	s1 := p.GoString()
1910	s2 := fmt.Sprintf("%#v", p)
1911	if s1 != s2 {
1912		t.Fatalf("GoString want %v got %v", s1, s2)
1913	}
1914	_, err := go_parser.ParseExpr(s1)
1915	if err != nil {
1916		t.Fatal(err)
1917	}
1918}
1919func TestContainsNestedMapGoString(t *testing.T) {
1920	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1921	p := NewPopulatedContainsNestedMap(popr, false)
1922	s1 := p.GoString()
1923	s2 := fmt.Sprintf("%#v", p)
1924	if s1 != s2 {
1925		t.Fatalf("GoString want %v got %v", s1, s2)
1926	}
1927	_, err := go_parser.ParseExpr(s1)
1928	if err != nil {
1929		t.Fatal(err)
1930	}
1931}
1932func TestContainsNestedMap_NestedMapGoString(t *testing.T) {
1933	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1934	p := NewPopulatedContainsNestedMap_NestedMap(popr, false)
1935	s1 := p.GoString()
1936	s2 := fmt.Sprintf("%#v", p)
1937	if s1 != s2 {
1938		t.Fatalf("GoString want %v got %v", s1, s2)
1939	}
1940	_, err := go_parser.ParseExpr(s1)
1941	if err != nil {
1942		t.Fatal(err)
1943	}
1944}
1945func TestNotPackedGoString(t *testing.T) {
1946	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1947	p := NewPopulatedNotPacked(popr, false)
1948	s1 := p.GoString()
1949	s2 := fmt.Sprintf("%#v", p)
1950	if s1 != s2 {
1951		t.Fatalf("GoString want %v got %v", s1, s2)
1952	}
1953	_, err := go_parser.ParseExpr(s1)
1954	if err != nil {
1955		t.Fatal(err)
1956	}
1957}
1958func TestMessageSize(t *testing.T) {
1959	seed := time.Now().UnixNano()
1960	popr := math_rand.New(math_rand.NewSource(seed))
1961	p := NewPopulatedMessage(popr, true)
1962	size2 := github_com_gogo_protobuf_proto.Size(p)
1963	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1964	if err != nil {
1965		t.Fatalf("seed = %d, err = %v", seed, err)
1966	}
1967	size := p.Size()
1968	if len(dAtA) != size {
1969		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1970	}
1971	if size2 != size {
1972		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1973	}
1974	size3 := github_com_gogo_protobuf_proto.Size(p)
1975	if size3 != size {
1976		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1977	}
1978}
1979
1980func BenchmarkMessageSize(b *testing.B) {
1981	popr := math_rand.New(math_rand.NewSource(616))
1982	total := 0
1983	pops := make([]*Message, 1000)
1984	for i := 0; i < 1000; i++ {
1985		pops[i] = NewPopulatedMessage(popr, false)
1986	}
1987	b.ResetTimer()
1988	for i := 0; i < b.N; i++ {
1989		total += pops[i%1000].Size()
1990	}
1991	b.SetBytes(int64(total / b.N))
1992}
1993
1994func TestNestedSize(t *testing.T) {
1995	seed := time.Now().UnixNano()
1996	popr := math_rand.New(math_rand.NewSource(seed))
1997	p := NewPopulatedNested(popr, true)
1998	size2 := github_com_gogo_protobuf_proto.Size(p)
1999	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2000	if err != nil {
2001		t.Fatalf("seed = %d, err = %v", seed, err)
2002	}
2003	size := p.Size()
2004	if len(dAtA) != size {
2005		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
2006	}
2007	if size2 != size {
2008		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
2009	}
2010	size3 := github_com_gogo_protobuf_proto.Size(p)
2011	if size3 != size {
2012		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
2013	}
2014}
2015
2016func BenchmarkNestedSize(b *testing.B) {
2017	popr := math_rand.New(math_rand.NewSource(616))
2018	total := 0
2019	pops := make([]*Nested, 1000)
2020	for i := 0; i < 1000; i++ {
2021		pops[i] = NewPopulatedNested(popr, false)
2022	}
2023	b.ResetTimer()
2024	for i := 0; i < b.N; i++ {
2025		total += pops[i%1000].Size()
2026	}
2027	b.SetBytes(int64(total / b.N))
2028}
2029
2030func TestAllMapsSize(t *testing.T) {
2031	seed := time.Now().UnixNano()
2032	popr := math_rand.New(math_rand.NewSource(seed))
2033	p := NewPopulatedAllMaps(popr, true)
2034	size2 := github_com_gogo_protobuf_proto.Size(p)
2035	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2036	if err != nil {
2037		t.Fatalf("seed = %d, err = %v", seed, err)
2038	}
2039	size := p.Size()
2040	if len(dAtA) != size {
2041		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
2042	}
2043	if size2 != size {
2044		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
2045	}
2046	size3 := github_com_gogo_protobuf_proto.Size(p)
2047	if size3 != size {
2048		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
2049	}
2050}
2051
2052func BenchmarkAllMapsSize(b *testing.B) {
2053	popr := math_rand.New(math_rand.NewSource(616))
2054	total := 0
2055	pops := make([]*AllMaps, 1000)
2056	for i := 0; i < 1000; i++ {
2057		pops[i] = NewPopulatedAllMaps(popr, false)
2058	}
2059	b.ResetTimer()
2060	for i := 0; i < b.N; i++ {
2061		total += pops[i%1000].Size()
2062	}
2063	b.SetBytes(int64(total / b.N))
2064}
2065
2066func TestAllMapsOrderedSize(t *testing.T) {
2067	seed := time.Now().UnixNano()
2068	popr := math_rand.New(math_rand.NewSource(seed))
2069	p := NewPopulatedAllMapsOrdered(popr, true)
2070	size2 := github_com_gogo_protobuf_proto.Size(p)
2071	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2072	if err != nil {
2073		t.Fatalf("seed = %d, err = %v", seed, err)
2074	}
2075	size := p.Size()
2076	if len(dAtA) != size {
2077		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
2078	}
2079	if size2 != size {
2080		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
2081	}
2082	size3 := github_com_gogo_protobuf_proto.Size(p)
2083	if size3 != size {
2084		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
2085	}
2086}
2087
2088func BenchmarkAllMapsOrderedSize(b *testing.B) {
2089	popr := math_rand.New(math_rand.NewSource(616))
2090	total := 0
2091	pops := make([]*AllMapsOrdered, 1000)
2092	for i := 0; i < 1000; i++ {
2093		pops[i] = NewPopulatedAllMapsOrdered(popr, false)
2094	}
2095	b.ResetTimer()
2096	for i := 0; i < b.N; i++ {
2097		total += pops[i%1000].Size()
2098	}
2099	b.SetBytes(int64(total / b.N))
2100}
2101
2102func TestMessageWithMapSize(t *testing.T) {
2103	seed := time.Now().UnixNano()
2104	popr := math_rand.New(math_rand.NewSource(seed))
2105	p := NewPopulatedMessageWithMap(popr, true)
2106	size2 := github_com_gogo_protobuf_proto.Size(p)
2107	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2108	if err != nil {
2109		t.Fatalf("seed = %d, err = %v", seed, err)
2110	}
2111	size := p.Size()
2112	if len(dAtA) != size {
2113		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
2114	}
2115	if size2 != size {
2116		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
2117	}
2118	size3 := github_com_gogo_protobuf_proto.Size(p)
2119	if size3 != size {
2120		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
2121	}
2122}
2123
2124func BenchmarkMessageWithMapSize(b *testing.B) {
2125	popr := math_rand.New(math_rand.NewSource(616))
2126	total := 0
2127	pops := make([]*MessageWithMap, 1000)
2128	for i := 0; i < 1000; i++ {
2129		pops[i] = NewPopulatedMessageWithMap(popr, false)
2130	}
2131	b.ResetTimer()
2132	for i := 0; i < b.N; i++ {
2133		total += pops[i%1000].Size()
2134	}
2135	b.SetBytes(int64(total / b.N))
2136}
2137
2138func TestFloatingPointSize(t *testing.T) {
2139	seed := time.Now().UnixNano()
2140	popr := math_rand.New(math_rand.NewSource(seed))
2141	p := NewPopulatedFloatingPoint(popr, true)
2142	size2 := github_com_gogo_protobuf_proto.Size(p)
2143	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2144	if err != nil {
2145		t.Fatalf("seed = %d, err = %v", seed, err)
2146	}
2147	size := p.Size()
2148	if len(dAtA) != size {
2149		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
2150	}
2151	if size2 != size {
2152		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
2153	}
2154	size3 := github_com_gogo_protobuf_proto.Size(p)
2155	if size3 != size {
2156		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
2157	}
2158}
2159
2160func BenchmarkFloatingPointSize(b *testing.B) {
2161	popr := math_rand.New(math_rand.NewSource(616))
2162	total := 0
2163	pops := make([]*FloatingPoint, 1000)
2164	for i := 0; i < 1000; i++ {
2165		pops[i] = NewPopulatedFloatingPoint(popr, false)
2166	}
2167	b.ResetTimer()
2168	for i := 0; i < b.N; i++ {
2169		total += pops[i%1000].Size()
2170	}
2171	b.SetBytes(int64(total / b.N))
2172}
2173
2174func TestUint128PairSize(t *testing.T) {
2175	seed := time.Now().UnixNano()
2176	popr := math_rand.New(math_rand.NewSource(seed))
2177	p := NewPopulatedUint128Pair(popr, true)
2178	size2 := github_com_gogo_protobuf_proto.Size(p)
2179	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2180	if err != nil {
2181		t.Fatalf("seed = %d, err = %v", seed, err)
2182	}
2183	size := p.Size()
2184	if len(dAtA) != size {
2185		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
2186	}
2187	if size2 != size {
2188		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
2189	}
2190	size3 := github_com_gogo_protobuf_proto.Size(p)
2191	if size3 != size {
2192		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
2193	}
2194}
2195
2196func BenchmarkUint128PairSize(b *testing.B) {
2197	popr := math_rand.New(math_rand.NewSource(616))
2198	total := 0
2199	pops := make([]*Uint128Pair, 1000)
2200	for i := 0; i < 1000; i++ {
2201		pops[i] = NewPopulatedUint128Pair(popr, false)
2202	}
2203	b.ResetTimer()
2204	for i := 0; i < b.N; i++ {
2205		total += pops[i%1000].Size()
2206	}
2207	b.SetBytes(int64(total / b.N))
2208}
2209
2210func TestContainsNestedMapSize(t *testing.T) {
2211	seed := time.Now().UnixNano()
2212	popr := math_rand.New(math_rand.NewSource(seed))
2213	p := NewPopulatedContainsNestedMap(popr, true)
2214	size2 := github_com_gogo_protobuf_proto.Size(p)
2215	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2216	if err != nil {
2217		t.Fatalf("seed = %d, err = %v", seed, err)
2218	}
2219	size := p.Size()
2220	if len(dAtA) != size {
2221		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
2222	}
2223	if size2 != size {
2224		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
2225	}
2226	size3 := github_com_gogo_protobuf_proto.Size(p)
2227	if size3 != size {
2228		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
2229	}
2230}
2231
2232func BenchmarkContainsNestedMapSize(b *testing.B) {
2233	popr := math_rand.New(math_rand.NewSource(616))
2234	total := 0
2235	pops := make([]*ContainsNestedMap, 1000)
2236	for i := 0; i < 1000; i++ {
2237		pops[i] = NewPopulatedContainsNestedMap(popr, false)
2238	}
2239	b.ResetTimer()
2240	for i := 0; i < b.N; i++ {
2241		total += pops[i%1000].Size()
2242	}
2243	b.SetBytes(int64(total / b.N))
2244}
2245
2246func TestContainsNestedMap_NestedMapSize(t *testing.T) {
2247	seed := time.Now().UnixNano()
2248	popr := math_rand.New(math_rand.NewSource(seed))
2249	p := NewPopulatedContainsNestedMap_NestedMap(popr, true)
2250	size2 := github_com_gogo_protobuf_proto.Size(p)
2251	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2252	if err != nil {
2253		t.Fatalf("seed = %d, err = %v", seed, err)
2254	}
2255	size := p.Size()
2256	if len(dAtA) != size {
2257		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
2258	}
2259	if size2 != size {
2260		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
2261	}
2262	size3 := github_com_gogo_protobuf_proto.Size(p)
2263	if size3 != size {
2264		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
2265	}
2266}
2267
2268func BenchmarkContainsNestedMap_NestedMapSize(b *testing.B) {
2269	popr := math_rand.New(math_rand.NewSource(616))
2270	total := 0
2271	pops := make([]*ContainsNestedMap_NestedMap, 1000)
2272	for i := 0; i < 1000; i++ {
2273		pops[i] = NewPopulatedContainsNestedMap_NestedMap(popr, false)
2274	}
2275	b.ResetTimer()
2276	for i := 0; i < b.N; i++ {
2277		total += pops[i%1000].Size()
2278	}
2279	b.SetBytes(int64(total / b.N))
2280}
2281
2282func TestNotPackedSize(t *testing.T) {
2283	seed := time.Now().UnixNano()
2284	popr := math_rand.New(math_rand.NewSource(seed))
2285	p := NewPopulatedNotPacked(popr, true)
2286	size2 := github_com_gogo_protobuf_proto.Size(p)
2287	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2288	if err != nil {
2289		t.Fatalf("seed = %d, err = %v", seed, err)
2290	}
2291	size := p.Size()
2292	if len(dAtA) != size {
2293		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
2294	}
2295	if size2 != size {
2296		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
2297	}
2298	size3 := github_com_gogo_protobuf_proto.Size(p)
2299	if size3 != size {
2300		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
2301	}
2302}
2303
2304func BenchmarkNotPackedSize(b *testing.B) {
2305	popr := math_rand.New(math_rand.NewSource(616))
2306	total := 0
2307	pops := make([]*NotPacked, 1000)
2308	for i := 0; i < 1000; i++ {
2309		pops[i] = NewPopulatedNotPacked(popr, false)
2310	}
2311	b.ResetTimer()
2312	for i := 0; i < b.N; i++ {
2313		total += pops[i%1000].Size()
2314	}
2315	b.SetBytes(int64(total / b.N))
2316}
2317
2318func TestMessageStringer(t *testing.T) {
2319	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
2320	p := NewPopulatedMessage(popr, false)
2321	s1 := p.String()
2322	s2 := fmt.Sprintf("%v", p)
2323	if s1 != s2 {
2324		t.Fatalf("String want %v got %v", s1, s2)
2325	}
2326}
2327func TestNestedStringer(t *testing.T) {
2328	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
2329	p := NewPopulatedNested(popr, false)
2330	s1 := p.String()
2331	s2 := fmt.Sprintf("%v", p)
2332	if s1 != s2 {
2333		t.Fatalf("String want %v got %v", s1, s2)
2334	}
2335}
2336func TestAllMapsStringer(t *testing.T) {
2337	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
2338	p := NewPopulatedAllMaps(popr, false)
2339	s1 := p.String()
2340	s2 := fmt.Sprintf("%v", p)
2341	if s1 != s2 {
2342		t.Fatalf("String want %v got %v", s1, s2)
2343	}
2344}
2345func TestAllMapsOrderedStringer(t *testing.T) {
2346	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
2347	p := NewPopulatedAllMapsOrdered(popr, false)
2348	s1 := p.String()
2349	s2 := fmt.Sprintf("%v", p)
2350	if s1 != s2 {
2351		t.Fatalf("String want %v got %v", s1, s2)
2352	}
2353}
2354func TestMessageWithMapStringer(t *testing.T) {
2355	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
2356	p := NewPopulatedMessageWithMap(popr, false)
2357	s1 := p.String()
2358	s2 := fmt.Sprintf("%v", p)
2359	if s1 != s2 {
2360		t.Fatalf("String want %v got %v", s1, s2)
2361	}
2362}
2363func TestFloatingPointStringer(t *testing.T) {
2364	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
2365	p := NewPopulatedFloatingPoint(popr, false)
2366	s1 := p.String()
2367	s2 := fmt.Sprintf("%v", p)
2368	if s1 != s2 {
2369		t.Fatalf("String want %v got %v", s1, s2)
2370	}
2371}
2372func TestUint128PairStringer(t *testing.T) {
2373	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
2374	p := NewPopulatedUint128Pair(popr, false)
2375	s1 := p.String()
2376	s2 := fmt.Sprintf("%v", p)
2377	if s1 != s2 {
2378		t.Fatalf("String want %v got %v", s1, s2)
2379	}
2380}
2381func TestContainsNestedMapStringer(t *testing.T) {
2382	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
2383	p := NewPopulatedContainsNestedMap(popr, false)
2384	s1 := p.String()
2385	s2 := fmt.Sprintf("%v", p)
2386	if s1 != s2 {
2387		t.Fatalf("String want %v got %v", s1, s2)
2388	}
2389}
2390func TestContainsNestedMap_NestedMapStringer(t *testing.T) {
2391	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
2392	p := NewPopulatedContainsNestedMap_NestedMap(popr, false)
2393	s1 := p.String()
2394	s2 := fmt.Sprintf("%v", p)
2395	if s1 != s2 {
2396		t.Fatalf("String want %v got %v", s1, s2)
2397	}
2398}
2399func TestNotPackedStringer(t *testing.T) {
2400	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
2401	p := NewPopulatedNotPacked(popr, false)
2402	s1 := p.String()
2403	s2 := fmt.Sprintf("%v", p)
2404	if s1 != s2 {
2405		t.Fatalf("String want %v got %v", s1, s2)
2406	}
2407}
2408
2409//These tests are generated by github.com/gogo/protobuf/plugin/testgen
2410