1
2
3
4 package test
5
6 import (
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 go_parser "go/parser"
13 math "math"
14 math_rand "math/rand"
15 testing "testing"
16 time "time"
17 )
18
19
20 var _ = proto.Marshal
21 var _ = fmt.Errorf
22 var _ = math.Inf
23
24 func TestNidOptNativeProto(t *testing.T) {
25 seed := time.Now().UnixNano()
26 popr := math_rand.New(math_rand.NewSource(seed))
27 p := NewPopulatedNidOptNative(popr, false)
28 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
29 if err != nil {
30 t.Fatalf("seed = %d, err = %v", seed, err)
31 }
32 msg := &NidOptNative{}
33 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
34 t.Fatalf("seed = %d, err = %v", seed, err)
35 }
36 littlefuzz := make([]byte, len(dAtA))
37 copy(littlefuzz, dAtA)
38 for i := range dAtA {
39 dAtA[i] = byte(popr.Intn(256))
40 }
41 if err := p.VerboseEqual(msg); err != nil {
42 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
43 }
44 if !p.Equal(msg) {
45 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
46 }
47 if len(littlefuzz) > 0 {
48 fuzzamount := 100
49 for i := 0; i < fuzzamount; i++ {
50 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
51 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
52 }
53
54 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
55 }
56 }
57
58 func BenchmarkNidOptNativeProtoMarshal(b *testing.B) {
59 popr := math_rand.New(math_rand.NewSource(616))
60 total := 0
61 pops := make([]*NidOptNative, 10000)
62 for i := 0; i < 10000; i++ {
63 pops[i] = NewPopulatedNidOptNative(popr, false)
64 }
65 b.ResetTimer()
66 for i := 0; i < b.N; i++ {
67 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
68 if err != nil {
69 panic(err)
70 }
71 total += len(dAtA)
72 }
73 b.SetBytes(int64(total / b.N))
74 }
75
76 func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) {
77 popr := math_rand.New(math_rand.NewSource(616))
78 total := 0
79 datas := make([][]byte, 10000)
80 for i := 0; i < 10000; i++ {
81 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNative(popr, false))
82 if err != nil {
83 panic(err)
84 }
85 datas[i] = dAtA
86 }
87 msg := &NidOptNative{}
88 b.ResetTimer()
89 for i := 0; i < b.N; i++ {
90 total += len(datas[i%10000])
91 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
92 panic(err)
93 }
94 }
95 b.SetBytes(int64(total / b.N))
96 }
97
98 func TestNinOptNativeProto(t *testing.T) {
99 seed := time.Now().UnixNano()
100 popr := math_rand.New(math_rand.NewSource(seed))
101 p := NewPopulatedNinOptNative(popr, false)
102 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
103 if err != nil {
104 t.Fatalf("seed = %d, err = %v", seed, err)
105 }
106 msg := &NinOptNative{}
107 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
108 t.Fatalf("seed = %d, err = %v", seed, err)
109 }
110 littlefuzz := make([]byte, len(dAtA))
111 copy(littlefuzz, dAtA)
112 for i := range dAtA {
113 dAtA[i] = byte(popr.Intn(256))
114 }
115 if err := p.VerboseEqual(msg); err != nil {
116 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
117 }
118 if !p.Equal(msg) {
119 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
120 }
121 if len(littlefuzz) > 0 {
122 fuzzamount := 100
123 for i := 0; i < fuzzamount; i++ {
124 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
125 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
126 }
127
128 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
129 }
130 }
131
132 func BenchmarkNinOptNativeProtoMarshal(b *testing.B) {
133 popr := math_rand.New(math_rand.NewSource(616))
134 total := 0
135 pops := make([]*NinOptNative, 10000)
136 for i := 0; i < 10000; i++ {
137 pops[i] = NewPopulatedNinOptNative(popr, false)
138 }
139 b.ResetTimer()
140 for i := 0; i < b.N; i++ {
141 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
142 if err != nil {
143 panic(err)
144 }
145 total += len(dAtA)
146 }
147 b.SetBytes(int64(total / b.N))
148 }
149
150 func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) {
151 popr := math_rand.New(math_rand.NewSource(616))
152 total := 0
153 datas := make([][]byte, 10000)
154 for i := 0; i < 10000; i++ {
155 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNative(popr, false))
156 if err != nil {
157 panic(err)
158 }
159 datas[i] = dAtA
160 }
161 msg := &NinOptNative{}
162 b.ResetTimer()
163 for i := 0; i < b.N; i++ {
164 total += len(datas[i%10000])
165 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
166 panic(err)
167 }
168 }
169 b.SetBytes(int64(total / b.N))
170 }
171
172 func TestNidRepNativeProto(t *testing.T) {
173 seed := time.Now().UnixNano()
174 popr := math_rand.New(math_rand.NewSource(seed))
175 p := NewPopulatedNidRepNative(popr, false)
176 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
177 if err != nil {
178 t.Fatalf("seed = %d, err = %v", seed, err)
179 }
180 msg := &NidRepNative{}
181 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
182 t.Fatalf("seed = %d, err = %v", seed, err)
183 }
184 littlefuzz := make([]byte, len(dAtA))
185 copy(littlefuzz, dAtA)
186 for i := range dAtA {
187 dAtA[i] = byte(popr.Intn(256))
188 }
189 if err := p.VerboseEqual(msg); err != nil {
190 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
191 }
192 if !p.Equal(msg) {
193 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
194 }
195 if len(littlefuzz) > 0 {
196 fuzzamount := 100
197 for i := 0; i < fuzzamount; i++ {
198 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
199 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
200 }
201
202 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
203 }
204 }
205
206 func BenchmarkNidRepNativeProtoMarshal(b *testing.B) {
207 popr := math_rand.New(math_rand.NewSource(616))
208 total := 0
209 pops := make([]*NidRepNative, 10000)
210 for i := 0; i < 10000; i++ {
211 pops[i] = NewPopulatedNidRepNative(popr, false)
212 }
213 b.ResetTimer()
214 for i := 0; i < b.N; i++ {
215 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
216 if err != nil {
217 panic(err)
218 }
219 total += len(dAtA)
220 }
221 b.SetBytes(int64(total / b.N))
222 }
223
224 func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) {
225 popr := math_rand.New(math_rand.NewSource(616))
226 total := 0
227 datas := make([][]byte, 10000)
228 for i := 0; i < 10000; i++ {
229 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNative(popr, false))
230 if err != nil {
231 panic(err)
232 }
233 datas[i] = dAtA
234 }
235 msg := &NidRepNative{}
236 b.ResetTimer()
237 for i := 0; i < b.N; i++ {
238 total += len(datas[i%10000])
239 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
240 panic(err)
241 }
242 }
243 b.SetBytes(int64(total / b.N))
244 }
245
246 func TestNinRepNativeProto(t *testing.T) {
247 seed := time.Now().UnixNano()
248 popr := math_rand.New(math_rand.NewSource(seed))
249 p := NewPopulatedNinRepNative(popr, false)
250 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
251 if err != nil {
252 t.Fatalf("seed = %d, err = %v", seed, err)
253 }
254 msg := &NinRepNative{}
255 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
256 t.Fatalf("seed = %d, err = %v", seed, err)
257 }
258 littlefuzz := make([]byte, len(dAtA))
259 copy(littlefuzz, dAtA)
260 for i := range dAtA {
261 dAtA[i] = byte(popr.Intn(256))
262 }
263 if err := p.VerboseEqual(msg); err != nil {
264 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
265 }
266 if !p.Equal(msg) {
267 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
268 }
269 if len(littlefuzz) > 0 {
270 fuzzamount := 100
271 for i := 0; i < fuzzamount; i++ {
272 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
273 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
274 }
275
276 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
277 }
278 }
279
280 func BenchmarkNinRepNativeProtoMarshal(b *testing.B) {
281 popr := math_rand.New(math_rand.NewSource(616))
282 total := 0
283 pops := make([]*NinRepNative, 10000)
284 for i := 0; i < 10000; i++ {
285 pops[i] = NewPopulatedNinRepNative(popr, false)
286 }
287 b.ResetTimer()
288 for i := 0; i < b.N; i++ {
289 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
290 if err != nil {
291 panic(err)
292 }
293 total += len(dAtA)
294 }
295 b.SetBytes(int64(total / b.N))
296 }
297
298 func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) {
299 popr := math_rand.New(math_rand.NewSource(616))
300 total := 0
301 datas := make([][]byte, 10000)
302 for i := 0; i < 10000; i++ {
303 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNative(popr, false))
304 if err != nil {
305 panic(err)
306 }
307 datas[i] = dAtA
308 }
309 msg := &NinRepNative{}
310 b.ResetTimer()
311 for i := 0; i < b.N; i++ {
312 total += len(datas[i%10000])
313 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
314 panic(err)
315 }
316 }
317 b.SetBytes(int64(total / b.N))
318 }
319
320 func TestNidRepPackedNativeProto(t *testing.T) {
321 seed := time.Now().UnixNano()
322 popr := math_rand.New(math_rand.NewSource(seed))
323 p := NewPopulatedNidRepPackedNative(popr, false)
324 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
325 if err != nil {
326 t.Fatalf("seed = %d, err = %v", seed, err)
327 }
328 msg := &NidRepPackedNative{}
329 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
330 t.Fatalf("seed = %d, err = %v", seed, err)
331 }
332 littlefuzz := make([]byte, len(dAtA))
333 copy(littlefuzz, dAtA)
334 for i := range dAtA {
335 dAtA[i] = byte(popr.Intn(256))
336 }
337 if err := p.VerboseEqual(msg); err != nil {
338 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
339 }
340 if !p.Equal(msg) {
341 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
342 }
343 if len(littlefuzz) > 0 {
344 fuzzamount := 100
345 for i := 0; i < fuzzamount; i++ {
346 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
347 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
348 }
349
350 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
351 }
352 }
353
354 func BenchmarkNidRepPackedNativeProtoMarshal(b *testing.B) {
355 popr := math_rand.New(math_rand.NewSource(616))
356 total := 0
357 pops := make([]*NidRepPackedNative, 10000)
358 for i := 0; i < 10000; i++ {
359 pops[i] = NewPopulatedNidRepPackedNative(popr, false)
360 }
361 b.ResetTimer()
362 for i := 0; i < b.N; i++ {
363 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
364 if err != nil {
365 panic(err)
366 }
367 total += len(dAtA)
368 }
369 b.SetBytes(int64(total / b.N))
370 }
371
372 func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) {
373 popr := math_rand.New(math_rand.NewSource(616))
374 total := 0
375 datas := make([][]byte, 10000)
376 for i := 0; i < 10000; i++ {
377 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepPackedNative(popr, false))
378 if err != nil {
379 panic(err)
380 }
381 datas[i] = dAtA
382 }
383 msg := &NidRepPackedNative{}
384 b.ResetTimer()
385 for i := 0; i < b.N; i++ {
386 total += len(datas[i%10000])
387 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
388 panic(err)
389 }
390 }
391 b.SetBytes(int64(total / b.N))
392 }
393
394 func TestNinRepPackedNativeProto(t *testing.T) {
395 seed := time.Now().UnixNano()
396 popr := math_rand.New(math_rand.NewSource(seed))
397 p := NewPopulatedNinRepPackedNative(popr, false)
398 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
399 if err != nil {
400 t.Fatalf("seed = %d, err = %v", seed, err)
401 }
402 msg := &NinRepPackedNative{}
403 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
404 t.Fatalf("seed = %d, err = %v", seed, err)
405 }
406 littlefuzz := make([]byte, len(dAtA))
407 copy(littlefuzz, dAtA)
408 for i := range dAtA {
409 dAtA[i] = byte(popr.Intn(256))
410 }
411 if err := p.VerboseEqual(msg); err != nil {
412 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
413 }
414 if !p.Equal(msg) {
415 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
416 }
417 if len(littlefuzz) > 0 {
418 fuzzamount := 100
419 for i := 0; i < fuzzamount; i++ {
420 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
421 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
422 }
423
424 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
425 }
426 }
427
428 func BenchmarkNinRepPackedNativeProtoMarshal(b *testing.B) {
429 popr := math_rand.New(math_rand.NewSource(616))
430 total := 0
431 pops := make([]*NinRepPackedNative, 10000)
432 for i := 0; i < 10000; i++ {
433 pops[i] = NewPopulatedNinRepPackedNative(popr, false)
434 }
435 b.ResetTimer()
436 for i := 0; i < b.N; i++ {
437 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
438 if err != nil {
439 panic(err)
440 }
441 total += len(dAtA)
442 }
443 b.SetBytes(int64(total / b.N))
444 }
445
446 func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) {
447 popr := math_rand.New(math_rand.NewSource(616))
448 total := 0
449 datas := make([][]byte, 10000)
450 for i := 0; i < 10000; i++ {
451 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepPackedNative(popr, false))
452 if err != nil {
453 panic(err)
454 }
455 datas[i] = dAtA
456 }
457 msg := &NinRepPackedNative{}
458 b.ResetTimer()
459 for i := 0; i < b.N; i++ {
460 total += len(datas[i%10000])
461 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
462 panic(err)
463 }
464 }
465 b.SetBytes(int64(total / b.N))
466 }
467
468 func TestNidOptStructProto(t *testing.T) {
469 seed := time.Now().UnixNano()
470 popr := math_rand.New(math_rand.NewSource(seed))
471 p := NewPopulatedNidOptStruct(popr, false)
472 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
473 if err != nil {
474 t.Fatalf("seed = %d, err = %v", seed, err)
475 }
476 msg := &NidOptStruct{}
477 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
478 t.Fatalf("seed = %d, err = %v", seed, err)
479 }
480 littlefuzz := make([]byte, len(dAtA))
481 copy(littlefuzz, dAtA)
482 for i := range dAtA {
483 dAtA[i] = byte(popr.Intn(256))
484 }
485 if err := p.VerboseEqual(msg); err != nil {
486 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
487 }
488 if !p.Equal(msg) {
489 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
490 }
491 if len(littlefuzz) > 0 {
492 fuzzamount := 100
493 for i := 0; i < fuzzamount; i++ {
494 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
495 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
496 }
497
498 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
499 }
500 }
501
502 func BenchmarkNidOptStructProtoMarshal(b *testing.B) {
503 popr := math_rand.New(math_rand.NewSource(616))
504 total := 0
505 pops := make([]*NidOptStruct, 10000)
506 for i := 0; i < 10000; i++ {
507 pops[i] = NewPopulatedNidOptStruct(popr, false)
508 }
509 b.ResetTimer()
510 for i := 0; i < b.N; i++ {
511 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
512 if err != nil {
513 panic(err)
514 }
515 total += len(dAtA)
516 }
517 b.SetBytes(int64(total / b.N))
518 }
519
520 func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) {
521 popr := math_rand.New(math_rand.NewSource(616))
522 total := 0
523 datas := make([][]byte, 10000)
524 for i := 0; i < 10000; i++ {
525 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptStruct(popr, false))
526 if err != nil {
527 panic(err)
528 }
529 datas[i] = dAtA
530 }
531 msg := &NidOptStruct{}
532 b.ResetTimer()
533 for i := 0; i < b.N; i++ {
534 total += len(datas[i%10000])
535 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
536 panic(err)
537 }
538 }
539 b.SetBytes(int64(total / b.N))
540 }
541
542 func TestNinOptStructProto(t *testing.T) {
543 seed := time.Now().UnixNano()
544 popr := math_rand.New(math_rand.NewSource(seed))
545 p := NewPopulatedNinOptStruct(popr, false)
546 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
547 if err != nil {
548 t.Fatalf("seed = %d, err = %v", seed, err)
549 }
550 msg := &NinOptStruct{}
551 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
552 t.Fatalf("seed = %d, err = %v", seed, err)
553 }
554 littlefuzz := make([]byte, len(dAtA))
555 copy(littlefuzz, dAtA)
556 for i := range dAtA {
557 dAtA[i] = byte(popr.Intn(256))
558 }
559 if err := p.VerboseEqual(msg); err != nil {
560 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
561 }
562 if !p.Equal(msg) {
563 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
564 }
565 if len(littlefuzz) > 0 {
566 fuzzamount := 100
567 for i := 0; i < fuzzamount; i++ {
568 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
569 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
570 }
571
572 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
573 }
574 }
575
576 func BenchmarkNinOptStructProtoMarshal(b *testing.B) {
577 popr := math_rand.New(math_rand.NewSource(616))
578 total := 0
579 pops := make([]*NinOptStruct, 10000)
580 for i := 0; i < 10000; i++ {
581 pops[i] = NewPopulatedNinOptStruct(popr, false)
582 }
583 b.ResetTimer()
584 for i := 0; i < b.N; i++ {
585 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
586 if err != nil {
587 panic(err)
588 }
589 total += len(dAtA)
590 }
591 b.SetBytes(int64(total / b.N))
592 }
593
594 func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) {
595 popr := math_rand.New(math_rand.NewSource(616))
596 total := 0
597 datas := make([][]byte, 10000)
598 for i := 0; i < 10000; i++ {
599 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStruct(popr, false))
600 if err != nil {
601 panic(err)
602 }
603 datas[i] = dAtA
604 }
605 msg := &NinOptStruct{}
606 b.ResetTimer()
607 for i := 0; i < b.N; i++ {
608 total += len(datas[i%10000])
609 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
610 panic(err)
611 }
612 }
613 b.SetBytes(int64(total / b.N))
614 }
615
616 func TestNidRepStructProto(t *testing.T) {
617 seed := time.Now().UnixNano()
618 popr := math_rand.New(math_rand.NewSource(seed))
619 p := NewPopulatedNidRepStruct(popr, false)
620 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
621 if err != nil {
622 t.Fatalf("seed = %d, err = %v", seed, err)
623 }
624 msg := &NidRepStruct{}
625 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
626 t.Fatalf("seed = %d, err = %v", seed, err)
627 }
628 littlefuzz := make([]byte, len(dAtA))
629 copy(littlefuzz, dAtA)
630 for i := range dAtA {
631 dAtA[i] = byte(popr.Intn(256))
632 }
633 if err := p.VerboseEqual(msg); err != nil {
634 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
635 }
636 if !p.Equal(msg) {
637 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
638 }
639 if len(littlefuzz) > 0 {
640 fuzzamount := 100
641 for i := 0; i < fuzzamount; i++ {
642 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
643 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
644 }
645
646 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
647 }
648 }
649
650 func BenchmarkNidRepStructProtoMarshal(b *testing.B) {
651 popr := math_rand.New(math_rand.NewSource(616))
652 total := 0
653 pops := make([]*NidRepStruct, 10000)
654 for i := 0; i < 10000; i++ {
655 pops[i] = NewPopulatedNidRepStruct(popr, false)
656 }
657 b.ResetTimer()
658 for i := 0; i < b.N; i++ {
659 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
660 if err != nil {
661 panic(err)
662 }
663 total += len(dAtA)
664 }
665 b.SetBytes(int64(total / b.N))
666 }
667
668 func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) {
669 popr := math_rand.New(math_rand.NewSource(616))
670 total := 0
671 datas := make([][]byte, 10000)
672 for i := 0; i < 10000; i++ {
673 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepStruct(popr, false))
674 if err != nil {
675 panic(err)
676 }
677 datas[i] = dAtA
678 }
679 msg := &NidRepStruct{}
680 b.ResetTimer()
681 for i := 0; i < b.N; i++ {
682 total += len(datas[i%10000])
683 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
684 panic(err)
685 }
686 }
687 b.SetBytes(int64(total / b.N))
688 }
689
690 func TestNinRepStructProto(t *testing.T) {
691 seed := time.Now().UnixNano()
692 popr := math_rand.New(math_rand.NewSource(seed))
693 p := NewPopulatedNinRepStruct(popr, false)
694 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
695 if err != nil {
696 t.Fatalf("seed = %d, err = %v", seed, err)
697 }
698 msg := &NinRepStruct{}
699 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
700 t.Fatalf("seed = %d, err = %v", seed, err)
701 }
702 littlefuzz := make([]byte, len(dAtA))
703 copy(littlefuzz, dAtA)
704 for i := range dAtA {
705 dAtA[i] = byte(popr.Intn(256))
706 }
707 if err := p.VerboseEqual(msg); err != nil {
708 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
709 }
710 if !p.Equal(msg) {
711 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
712 }
713 if len(littlefuzz) > 0 {
714 fuzzamount := 100
715 for i := 0; i < fuzzamount; i++ {
716 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
717 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
718 }
719
720 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
721 }
722 }
723
724 func BenchmarkNinRepStructProtoMarshal(b *testing.B) {
725 popr := math_rand.New(math_rand.NewSource(616))
726 total := 0
727 pops := make([]*NinRepStruct, 10000)
728 for i := 0; i < 10000; i++ {
729 pops[i] = NewPopulatedNinRepStruct(popr, false)
730 }
731 b.ResetTimer()
732 for i := 0; i < b.N; i++ {
733 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
734 if err != nil {
735 panic(err)
736 }
737 total += len(dAtA)
738 }
739 b.SetBytes(int64(total / b.N))
740 }
741
742 func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) {
743 popr := math_rand.New(math_rand.NewSource(616))
744 total := 0
745 datas := make([][]byte, 10000)
746 for i := 0; i < 10000; i++ {
747 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepStruct(popr, false))
748 if err != nil {
749 panic(err)
750 }
751 datas[i] = dAtA
752 }
753 msg := &NinRepStruct{}
754 b.ResetTimer()
755 for i := 0; i < b.N; i++ {
756 total += len(datas[i%10000])
757 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
758 panic(err)
759 }
760 }
761 b.SetBytes(int64(total / b.N))
762 }
763
764 func TestNidEmbeddedStructProto(t *testing.T) {
765 seed := time.Now().UnixNano()
766 popr := math_rand.New(math_rand.NewSource(seed))
767 p := NewPopulatedNidEmbeddedStruct(popr, false)
768 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
769 if err != nil {
770 t.Fatalf("seed = %d, err = %v", seed, err)
771 }
772 msg := &NidEmbeddedStruct{}
773 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
774 t.Fatalf("seed = %d, err = %v", seed, err)
775 }
776 littlefuzz := make([]byte, len(dAtA))
777 copy(littlefuzz, dAtA)
778 for i := range dAtA {
779 dAtA[i] = byte(popr.Intn(256))
780 }
781 if err := p.VerboseEqual(msg); err != nil {
782 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
783 }
784 if !p.Equal(msg) {
785 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
786 }
787 if len(littlefuzz) > 0 {
788 fuzzamount := 100
789 for i := 0; i < fuzzamount; i++ {
790 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
791 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
792 }
793
794 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
795 }
796 }
797
798 func BenchmarkNidEmbeddedStructProtoMarshal(b *testing.B) {
799 popr := math_rand.New(math_rand.NewSource(616))
800 total := 0
801 pops := make([]*NidEmbeddedStruct, 10000)
802 for i := 0; i < 10000; i++ {
803 pops[i] = NewPopulatedNidEmbeddedStruct(popr, false)
804 }
805 b.ResetTimer()
806 for i := 0; i < b.N; i++ {
807 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
808 if err != nil {
809 panic(err)
810 }
811 total += len(dAtA)
812 }
813 b.SetBytes(int64(total / b.N))
814 }
815
816 func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) {
817 popr := math_rand.New(math_rand.NewSource(616))
818 total := 0
819 datas := make([][]byte, 10000)
820 for i := 0; i < 10000; i++ {
821 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidEmbeddedStruct(popr, false))
822 if err != nil {
823 panic(err)
824 }
825 datas[i] = dAtA
826 }
827 msg := &NidEmbeddedStruct{}
828 b.ResetTimer()
829 for i := 0; i < b.N; i++ {
830 total += len(datas[i%10000])
831 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
832 panic(err)
833 }
834 }
835 b.SetBytes(int64(total / b.N))
836 }
837
838 func TestNinEmbeddedStructProto(t *testing.T) {
839 seed := time.Now().UnixNano()
840 popr := math_rand.New(math_rand.NewSource(seed))
841 p := NewPopulatedNinEmbeddedStruct(popr, false)
842 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
843 if err != nil {
844 t.Fatalf("seed = %d, err = %v", seed, err)
845 }
846 msg := &NinEmbeddedStruct{}
847 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
848 t.Fatalf("seed = %d, err = %v", seed, err)
849 }
850 littlefuzz := make([]byte, len(dAtA))
851 copy(littlefuzz, dAtA)
852 for i := range dAtA {
853 dAtA[i] = byte(popr.Intn(256))
854 }
855 if err := p.VerboseEqual(msg); err != nil {
856 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
857 }
858 if !p.Equal(msg) {
859 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
860 }
861 if len(littlefuzz) > 0 {
862 fuzzamount := 100
863 for i := 0; i < fuzzamount; i++ {
864 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
865 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
866 }
867
868 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
869 }
870 }
871
872 func BenchmarkNinEmbeddedStructProtoMarshal(b *testing.B) {
873 popr := math_rand.New(math_rand.NewSource(616))
874 total := 0
875 pops := make([]*NinEmbeddedStruct, 10000)
876 for i := 0; i < 10000; i++ {
877 pops[i] = NewPopulatedNinEmbeddedStruct(popr, false)
878 }
879 b.ResetTimer()
880 for i := 0; i < b.N; i++ {
881 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
882 if err != nil {
883 panic(err)
884 }
885 total += len(dAtA)
886 }
887 b.SetBytes(int64(total / b.N))
888 }
889
890 func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) {
891 popr := math_rand.New(math_rand.NewSource(616))
892 total := 0
893 datas := make([][]byte, 10000)
894 for i := 0; i < 10000; i++ {
895 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStruct(popr, false))
896 if err != nil {
897 panic(err)
898 }
899 datas[i] = dAtA
900 }
901 msg := &NinEmbeddedStruct{}
902 b.ResetTimer()
903 for i := 0; i < b.N; i++ {
904 total += len(datas[i%10000])
905 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
906 panic(err)
907 }
908 }
909 b.SetBytes(int64(total / b.N))
910 }
911
912 func TestNidNestedStructProto(t *testing.T) {
913 seed := time.Now().UnixNano()
914 popr := math_rand.New(math_rand.NewSource(seed))
915 p := NewPopulatedNidNestedStruct(popr, false)
916 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
917 if err != nil {
918 t.Fatalf("seed = %d, err = %v", seed, err)
919 }
920 msg := &NidNestedStruct{}
921 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
922 t.Fatalf("seed = %d, err = %v", seed, err)
923 }
924 littlefuzz := make([]byte, len(dAtA))
925 copy(littlefuzz, dAtA)
926 for i := range dAtA {
927 dAtA[i] = byte(popr.Intn(256))
928 }
929 if err := p.VerboseEqual(msg); err != nil {
930 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
931 }
932 if !p.Equal(msg) {
933 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
934 }
935 if len(littlefuzz) > 0 {
936 fuzzamount := 100
937 for i := 0; i < fuzzamount; i++ {
938 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
939 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
940 }
941
942 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
943 }
944 }
945
946 func BenchmarkNidNestedStructProtoMarshal(b *testing.B) {
947 popr := math_rand.New(math_rand.NewSource(616))
948 total := 0
949 pops := make([]*NidNestedStruct, 10000)
950 for i := 0; i < 10000; i++ {
951 pops[i] = NewPopulatedNidNestedStruct(popr, false)
952 }
953 b.ResetTimer()
954 for i := 0; i < b.N; i++ {
955 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
956 if err != nil {
957 panic(err)
958 }
959 total += len(dAtA)
960 }
961 b.SetBytes(int64(total / b.N))
962 }
963
964 func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) {
965 popr := math_rand.New(math_rand.NewSource(616))
966 total := 0
967 datas := make([][]byte, 10000)
968 for i := 0; i < 10000; i++ {
969 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidNestedStruct(popr, false))
970 if err != nil {
971 panic(err)
972 }
973 datas[i] = dAtA
974 }
975 msg := &NidNestedStruct{}
976 b.ResetTimer()
977 for i := 0; i < b.N; i++ {
978 total += len(datas[i%10000])
979 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
980 panic(err)
981 }
982 }
983 b.SetBytes(int64(total / b.N))
984 }
985
986 func TestNinNestedStructProto(t *testing.T) {
987 seed := time.Now().UnixNano()
988 popr := math_rand.New(math_rand.NewSource(seed))
989 p := NewPopulatedNinNestedStruct(popr, false)
990 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
991 if err != nil {
992 t.Fatalf("seed = %d, err = %v", seed, err)
993 }
994 msg := &NinNestedStruct{}
995 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
996 t.Fatalf("seed = %d, err = %v", seed, err)
997 }
998 littlefuzz := make([]byte, len(dAtA))
999 copy(littlefuzz, dAtA)
1000 for i := range dAtA {
1001 dAtA[i] = byte(popr.Intn(256))
1002 }
1003 if err := p.VerboseEqual(msg); err != nil {
1004 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1005 }
1006 if !p.Equal(msg) {
1007 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1008 }
1009 if len(littlefuzz) > 0 {
1010 fuzzamount := 100
1011 for i := 0; i < fuzzamount; i++ {
1012 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1013 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1014 }
1015
1016 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1017 }
1018 }
1019
1020 func BenchmarkNinNestedStructProtoMarshal(b *testing.B) {
1021 popr := math_rand.New(math_rand.NewSource(616))
1022 total := 0
1023 pops := make([]*NinNestedStruct, 10000)
1024 for i := 0; i < 10000; i++ {
1025 pops[i] = NewPopulatedNinNestedStruct(popr, false)
1026 }
1027 b.ResetTimer()
1028 for i := 0; i < b.N; i++ {
1029 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1030 if err != nil {
1031 panic(err)
1032 }
1033 total += len(dAtA)
1034 }
1035 b.SetBytes(int64(total / b.N))
1036 }
1037
1038 func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) {
1039 popr := math_rand.New(math_rand.NewSource(616))
1040 total := 0
1041 datas := make([][]byte, 10000)
1042 for i := 0; i < 10000; i++ {
1043 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStruct(popr, false))
1044 if err != nil {
1045 panic(err)
1046 }
1047 datas[i] = dAtA
1048 }
1049 msg := &NinNestedStruct{}
1050 b.ResetTimer()
1051 for i := 0; i < b.N; i++ {
1052 total += len(datas[i%10000])
1053 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1054 panic(err)
1055 }
1056 }
1057 b.SetBytes(int64(total / b.N))
1058 }
1059
1060 func TestNidOptCustomProto(t *testing.T) {
1061 seed := time.Now().UnixNano()
1062 popr := math_rand.New(math_rand.NewSource(seed))
1063 p := NewPopulatedNidOptCustom(popr, false)
1064 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1065 if err != nil {
1066 t.Fatalf("seed = %d, err = %v", seed, err)
1067 }
1068 msg := &NidOptCustom{}
1069 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1070 t.Fatalf("seed = %d, err = %v", seed, err)
1071 }
1072 littlefuzz := make([]byte, len(dAtA))
1073 copy(littlefuzz, dAtA)
1074 for i := range dAtA {
1075 dAtA[i] = byte(popr.Intn(256))
1076 }
1077 if err := p.VerboseEqual(msg); err != nil {
1078 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1079 }
1080 if !p.Equal(msg) {
1081 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1082 }
1083 if len(littlefuzz) > 0 {
1084 fuzzamount := 100
1085 for i := 0; i < fuzzamount; i++ {
1086 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1087 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1088 }
1089
1090 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1091 }
1092 }
1093
1094 func BenchmarkNidOptCustomProtoMarshal(b *testing.B) {
1095 popr := math_rand.New(math_rand.NewSource(616))
1096 total := 0
1097 pops := make([]*NidOptCustom, 10000)
1098 for i := 0; i < 10000; i++ {
1099 pops[i] = NewPopulatedNidOptCustom(popr, false)
1100 }
1101 b.ResetTimer()
1102 for i := 0; i < b.N; i++ {
1103 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1104 if err != nil {
1105 panic(err)
1106 }
1107 total += len(dAtA)
1108 }
1109 b.SetBytes(int64(total / b.N))
1110 }
1111
1112 func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) {
1113 popr := math_rand.New(math_rand.NewSource(616))
1114 total := 0
1115 datas := make([][]byte, 10000)
1116 for i := 0; i < 10000; i++ {
1117 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptCustom(popr, false))
1118 if err != nil {
1119 panic(err)
1120 }
1121 datas[i] = dAtA
1122 }
1123 msg := &NidOptCustom{}
1124 b.ResetTimer()
1125 for i := 0; i < b.N; i++ {
1126 total += len(datas[i%10000])
1127 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1128 panic(err)
1129 }
1130 }
1131 b.SetBytes(int64(total / b.N))
1132 }
1133
1134 func TestCustomDashProto(t *testing.T) {
1135 seed := time.Now().UnixNano()
1136 popr := math_rand.New(math_rand.NewSource(seed))
1137 p := NewPopulatedCustomDash(popr, false)
1138 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1139 if err != nil {
1140 t.Fatalf("seed = %d, err = %v", seed, err)
1141 }
1142 msg := &CustomDash{}
1143 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1144 t.Fatalf("seed = %d, err = %v", seed, err)
1145 }
1146 littlefuzz := make([]byte, len(dAtA))
1147 copy(littlefuzz, dAtA)
1148 for i := range dAtA {
1149 dAtA[i] = byte(popr.Intn(256))
1150 }
1151 if err := p.VerboseEqual(msg); err != nil {
1152 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1153 }
1154 if !p.Equal(msg) {
1155 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1156 }
1157 if len(littlefuzz) > 0 {
1158 fuzzamount := 100
1159 for i := 0; i < fuzzamount; i++ {
1160 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1161 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1162 }
1163
1164 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1165 }
1166 }
1167
1168 func BenchmarkCustomDashProtoMarshal(b *testing.B) {
1169 popr := math_rand.New(math_rand.NewSource(616))
1170 total := 0
1171 pops := make([]*CustomDash, 10000)
1172 for i := 0; i < 10000; i++ {
1173 pops[i] = NewPopulatedCustomDash(popr, false)
1174 }
1175 b.ResetTimer()
1176 for i := 0; i < b.N; i++ {
1177 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1178 if err != nil {
1179 panic(err)
1180 }
1181 total += len(dAtA)
1182 }
1183 b.SetBytes(int64(total / b.N))
1184 }
1185
1186 func BenchmarkCustomDashProtoUnmarshal(b *testing.B) {
1187 popr := math_rand.New(math_rand.NewSource(616))
1188 total := 0
1189 datas := make([][]byte, 10000)
1190 for i := 0; i < 10000; i++ {
1191 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomDash(popr, false))
1192 if err != nil {
1193 panic(err)
1194 }
1195 datas[i] = dAtA
1196 }
1197 msg := &CustomDash{}
1198 b.ResetTimer()
1199 for i := 0; i < b.N; i++ {
1200 total += len(datas[i%10000])
1201 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1202 panic(err)
1203 }
1204 }
1205 b.SetBytes(int64(total / b.N))
1206 }
1207
1208 func TestNinOptCustomProto(t *testing.T) {
1209 seed := time.Now().UnixNano()
1210 popr := math_rand.New(math_rand.NewSource(seed))
1211 p := NewPopulatedNinOptCustom(popr, false)
1212 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1213 if err != nil {
1214 t.Fatalf("seed = %d, err = %v", seed, err)
1215 }
1216 msg := &NinOptCustom{}
1217 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1218 t.Fatalf("seed = %d, err = %v", seed, err)
1219 }
1220 littlefuzz := make([]byte, len(dAtA))
1221 copy(littlefuzz, dAtA)
1222 for i := range dAtA {
1223 dAtA[i] = byte(popr.Intn(256))
1224 }
1225 if err := p.VerboseEqual(msg); err != nil {
1226 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1227 }
1228 if !p.Equal(msg) {
1229 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1230 }
1231 if len(littlefuzz) > 0 {
1232 fuzzamount := 100
1233 for i := 0; i < fuzzamount; i++ {
1234 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1235 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1236 }
1237
1238 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1239 }
1240 }
1241
1242 func BenchmarkNinOptCustomProtoMarshal(b *testing.B) {
1243 popr := math_rand.New(math_rand.NewSource(616))
1244 total := 0
1245 pops := make([]*NinOptCustom, 10000)
1246 for i := 0; i < 10000; i++ {
1247 pops[i] = NewPopulatedNinOptCustom(popr, false)
1248 }
1249 b.ResetTimer()
1250 for i := 0; i < b.N; i++ {
1251 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1252 if err != nil {
1253 panic(err)
1254 }
1255 total += len(dAtA)
1256 }
1257 b.SetBytes(int64(total / b.N))
1258 }
1259
1260 func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) {
1261 popr := math_rand.New(math_rand.NewSource(616))
1262 total := 0
1263 datas := make([][]byte, 10000)
1264 for i := 0; i < 10000; i++ {
1265 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptCustom(popr, false))
1266 if err != nil {
1267 panic(err)
1268 }
1269 datas[i] = dAtA
1270 }
1271 msg := &NinOptCustom{}
1272 b.ResetTimer()
1273 for i := 0; i < b.N; i++ {
1274 total += len(datas[i%10000])
1275 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1276 panic(err)
1277 }
1278 }
1279 b.SetBytes(int64(total / b.N))
1280 }
1281
1282 func TestNidRepCustomProto(t *testing.T) {
1283 seed := time.Now().UnixNano()
1284 popr := math_rand.New(math_rand.NewSource(seed))
1285 p := NewPopulatedNidRepCustom(popr, false)
1286 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1287 if err != nil {
1288 t.Fatalf("seed = %d, err = %v", seed, err)
1289 }
1290 msg := &NidRepCustom{}
1291 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1292 t.Fatalf("seed = %d, err = %v", seed, err)
1293 }
1294 littlefuzz := make([]byte, len(dAtA))
1295 copy(littlefuzz, dAtA)
1296 for i := range dAtA {
1297 dAtA[i] = byte(popr.Intn(256))
1298 }
1299 if err := p.VerboseEqual(msg); err != nil {
1300 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1301 }
1302 if !p.Equal(msg) {
1303 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1304 }
1305 if len(littlefuzz) > 0 {
1306 fuzzamount := 100
1307 for i := 0; i < fuzzamount; i++ {
1308 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1309 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1310 }
1311
1312 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1313 }
1314 }
1315
1316 func BenchmarkNidRepCustomProtoMarshal(b *testing.B) {
1317 popr := math_rand.New(math_rand.NewSource(616))
1318 total := 0
1319 pops := make([]*NidRepCustom, 10000)
1320 for i := 0; i < 10000; i++ {
1321 pops[i] = NewPopulatedNidRepCustom(popr, false)
1322 }
1323 b.ResetTimer()
1324 for i := 0; i < b.N; i++ {
1325 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1326 if err != nil {
1327 panic(err)
1328 }
1329 total += len(dAtA)
1330 }
1331 b.SetBytes(int64(total / b.N))
1332 }
1333
1334 func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) {
1335 popr := math_rand.New(math_rand.NewSource(616))
1336 total := 0
1337 datas := make([][]byte, 10000)
1338 for i := 0; i < 10000; i++ {
1339 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepCustom(popr, false))
1340 if err != nil {
1341 panic(err)
1342 }
1343 datas[i] = dAtA
1344 }
1345 msg := &NidRepCustom{}
1346 b.ResetTimer()
1347 for i := 0; i < b.N; i++ {
1348 total += len(datas[i%10000])
1349 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1350 panic(err)
1351 }
1352 }
1353 b.SetBytes(int64(total / b.N))
1354 }
1355
1356 func TestNinRepCustomProto(t *testing.T) {
1357 seed := time.Now().UnixNano()
1358 popr := math_rand.New(math_rand.NewSource(seed))
1359 p := NewPopulatedNinRepCustom(popr, false)
1360 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1361 if err != nil {
1362 t.Fatalf("seed = %d, err = %v", seed, err)
1363 }
1364 msg := &NinRepCustom{}
1365 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1366 t.Fatalf("seed = %d, err = %v", seed, err)
1367 }
1368 littlefuzz := make([]byte, len(dAtA))
1369 copy(littlefuzz, dAtA)
1370 for i := range dAtA {
1371 dAtA[i] = byte(popr.Intn(256))
1372 }
1373 if err := p.VerboseEqual(msg); err != nil {
1374 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1375 }
1376 if !p.Equal(msg) {
1377 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1378 }
1379 if len(littlefuzz) > 0 {
1380 fuzzamount := 100
1381 for i := 0; i < fuzzamount; i++ {
1382 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1383 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1384 }
1385
1386 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1387 }
1388 }
1389
1390 func BenchmarkNinRepCustomProtoMarshal(b *testing.B) {
1391 popr := math_rand.New(math_rand.NewSource(616))
1392 total := 0
1393 pops := make([]*NinRepCustom, 10000)
1394 for i := 0; i < 10000; i++ {
1395 pops[i] = NewPopulatedNinRepCustom(popr, false)
1396 }
1397 b.ResetTimer()
1398 for i := 0; i < b.N; i++ {
1399 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1400 if err != nil {
1401 panic(err)
1402 }
1403 total += len(dAtA)
1404 }
1405 b.SetBytes(int64(total / b.N))
1406 }
1407
1408 func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) {
1409 popr := math_rand.New(math_rand.NewSource(616))
1410 total := 0
1411 datas := make([][]byte, 10000)
1412 for i := 0; i < 10000; i++ {
1413 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepCustom(popr, false))
1414 if err != nil {
1415 panic(err)
1416 }
1417 datas[i] = dAtA
1418 }
1419 msg := &NinRepCustom{}
1420 b.ResetTimer()
1421 for i := 0; i < b.N; i++ {
1422 total += len(datas[i%10000])
1423 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1424 panic(err)
1425 }
1426 }
1427 b.SetBytes(int64(total / b.N))
1428 }
1429
1430 func TestNinOptNativeUnionProto(t *testing.T) {
1431 seed := time.Now().UnixNano()
1432 popr := math_rand.New(math_rand.NewSource(seed))
1433 p := NewPopulatedNinOptNativeUnion(popr, false)
1434 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1435 if err != nil {
1436 t.Fatalf("seed = %d, err = %v", seed, err)
1437 }
1438 msg := &NinOptNativeUnion{}
1439 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1440 t.Fatalf("seed = %d, err = %v", seed, err)
1441 }
1442 littlefuzz := make([]byte, len(dAtA))
1443 copy(littlefuzz, dAtA)
1444 for i := range dAtA {
1445 dAtA[i] = byte(popr.Intn(256))
1446 }
1447 if err := p.VerboseEqual(msg); err != nil {
1448 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1449 }
1450 if !p.Equal(msg) {
1451 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1452 }
1453 if len(littlefuzz) > 0 {
1454 fuzzamount := 100
1455 for i := 0; i < fuzzamount; i++ {
1456 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1457 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1458 }
1459
1460 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1461 }
1462 }
1463
1464 func BenchmarkNinOptNativeUnionProtoMarshal(b *testing.B) {
1465 popr := math_rand.New(math_rand.NewSource(616))
1466 total := 0
1467 pops := make([]*NinOptNativeUnion, 10000)
1468 for i := 0; i < 10000; i++ {
1469 pops[i] = NewPopulatedNinOptNativeUnion(popr, false)
1470 }
1471 b.ResetTimer()
1472 for i := 0; i < b.N; i++ {
1473 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1474 if err != nil {
1475 panic(err)
1476 }
1477 total += len(dAtA)
1478 }
1479 b.SetBytes(int64(total / b.N))
1480 }
1481
1482 func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) {
1483 popr := math_rand.New(math_rand.NewSource(616))
1484 total := 0
1485 datas := make([][]byte, 10000)
1486 for i := 0; i < 10000; i++ {
1487 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeUnion(popr, false))
1488 if err != nil {
1489 panic(err)
1490 }
1491 datas[i] = dAtA
1492 }
1493 msg := &NinOptNativeUnion{}
1494 b.ResetTimer()
1495 for i := 0; i < b.N; i++ {
1496 total += len(datas[i%10000])
1497 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1498 panic(err)
1499 }
1500 }
1501 b.SetBytes(int64(total / b.N))
1502 }
1503
1504 func TestNinOptStructUnionProto(t *testing.T) {
1505 seed := time.Now().UnixNano()
1506 popr := math_rand.New(math_rand.NewSource(seed))
1507 p := NewPopulatedNinOptStructUnion(popr, false)
1508 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1509 if err != nil {
1510 t.Fatalf("seed = %d, err = %v", seed, err)
1511 }
1512 msg := &NinOptStructUnion{}
1513 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1514 t.Fatalf("seed = %d, err = %v", seed, err)
1515 }
1516 littlefuzz := make([]byte, len(dAtA))
1517 copy(littlefuzz, dAtA)
1518 for i := range dAtA {
1519 dAtA[i] = byte(popr.Intn(256))
1520 }
1521 if err := p.VerboseEqual(msg); err != nil {
1522 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1523 }
1524 if !p.Equal(msg) {
1525 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1526 }
1527 if len(littlefuzz) > 0 {
1528 fuzzamount := 100
1529 for i := 0; i < fuzzamount; i++ {
1530 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1531 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1532 }
1533
1534 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1535 }
1536 }
1537
1538 func BenchmarkNinOptStructUnionProtoMarshal(b *testing.B) {
1539 popr := math_rand.New(math_rand.NewSource(616))
1540 total := 0
1541 pops := make([]*NinOptStructUnion, 10000)
1542 for i := 0; i < 10000; i++ {
1543 pops[i] = NewPopulatedNinOptStructUnion(popr, false)
1544 }
1545 b.ResetTimer()
1546 for i := 0; i < b.N; i++ {
1547 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1548 if err != nil {
1549 panic(err)
1550 }
1551 total += len(dAtA)
1552 }
1553 b.SetBytes(int64(total / b.N))
1554 }
1555
1556 func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) {
1557 popr := math_rand.New(math_rand.NewSource(616))
1558 total := 0
1559 datas := make([][]byte, 10000)
1560 for i := 0; i < 10000; i++ {
1561 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStructUnion(popr, false))
1562 if err != nil {
1563 panic(err)
1564 }
1565 datas[i] = dAtA
1566 }
1567 msg := &NinOptStructUnion{}
1568 b.ResetTimer()
1569 for i := 0; i < b.N; i++ {
1570 total += len(datas[i%10000])
1571 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1572 panic(err)
1573 }
1574 }
1575 b.SetBytes(int64(total / b.N))
1576 }
1577
1578 func TestNinEmbeddedStructUnionProto(t *testing.T) {
1579 seed := time.Now().UnixNano()
1580 popr := math_rand.New(math_rand.NewSource(seed))
1581 p := NewPopulatedNinEmbeddedStructUnion(popr, false)
1582 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1583 if err != nil {
1584 t.Fatalf("seed = %d, err = %v", seed, err)
1585 }
1586 msg := &NinEmbeddedStructUnion{}
1587 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1588 t.Fatalf("seed = %d, err = %v", seed, err)
1589 }
1590 littlefuzz := make([]byte, len(dAtA))
1591 copy(littlefuzz, dAtA)
1592 for i := range dAtA {
1593 dAtA[i] = byte(popr.Intn(256))
1594 }
1595 if err := p.VerboseEqual(msg); err != nil {
1596 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1597 }
1598 if !p.Equal(msg) {
1599 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1600 }
1601 if len(littlefuzz) > 0 {
1602 fuzzamount := 100
1603 for i := 0; i < fuzzamount; i++ {
1604 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1605 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1606 }
1607
1608 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1609 }
1610 }
1611
1612 func BenchmarkNinEmbeddedStructUnionProtoMarshal(b *testing.B) {
1613 popr := math_rand.New(math_rand.NewSource(616))
1614 total := 0
1615 pops := make([]*NinEmbeddedStructUnion, 10000)
1616 for i := 0; i < 10000; i++ {
1617 pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false)
1618 }
1619 b.ResetTimer()
1620 for i := 0; i < b.N; i++ {
1621 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1622 if err != nil {
1623 panic(err)
1624 }
1625 total += len(dAtA)
1626 }
1627 b.SetBytes(int64(total / b.N))
1628 }
1629
1630 func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) {
1631 popr := math_rand.New(math_rand.NewSource(616))
1632 total := 0
1633 datas := make([][]byte, 10000)
1634 for i := 0; i < 10000; i++ {
1635 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStructUnion(popr, false))
1636 if err != nil {
1637 panic(err)
1638 }
1639 datas[i] = dAtA
1640 }
1641 msg := &NinEmbeddedStructUnion{}
1642 b.ResetTimer()
1643 for i := 0; i < b.N; i++ {
1644 total += len(datas[i%10000])
1645 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1646 panic(err)
1647 }
1648 }
1649 b.SetBytes(int64(total / b.N))
1650 }
1651
1652 func TestNinNestedStructUnionProto(t *testing.T) {
1653 seed := time.Now().UnixNano()
1654 popr := math_rand.New(math_rand.NewSource(seed))
1655 p := NewPopulatedNinNestedStructUnion(popr, false)
1656 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1657 if err != nil {
1658 t.Fatalf("seed = %d, err = %v", seed, err)
1659 }
1660 msg := &NinNestedStructUnion{}
1661 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1662 t.Fatalf("seed = %d, err = %v", seed, err)
1663 }
1664 littlefuzz := make([]byte, len(dAtA))
1665 copy(littlefuzz, dAtA)
1666 for i := range dAtA {
1667 dAtA[i] = byte(popr.Intn(256))
1668 }
1669 if err := p.VerboseEqual(msg); err != nil {
1670 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1671 }
1672 if !p.Equal(msg) {
1673 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1674 }
1675 if len(littlefuzz) > 0 {
1676 fuzzamount := 100
1677 for i := 0; i < fuzzamount; i++ {
1678 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1679 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1680 }
1681
1682 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1683 }
1684 }
1685
1686 func BenchmarkNinNestedStructUnionProtoMarshal(b *testing.B) {
1687 popr := math_rand.New(math_rand.NewSource(616))
1688 total := 0
1689 pops := make([]*NinNestedStructUnion, 10000)
1690 for i := 0; i < 10000; i++ {
1691 pops[i] = NewPopulatedNinNestedStructUnion(popr, false)
1692 }
1693 b.ResetTimer()
1694 for i := 0; i < b.N; i++ {
1695 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1696 if err != nil {
1697 panic(err)
1698 }
1699 total += len(dAtA)
1700 }
1701 b.SetBytes(int64(total / b.N))
1702 }
1703
1704 func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) {
1705 popr := math_rand.New(math_rand.NewSource(616))
1706 total := 0
1707 datas := make([][]byte, 10000)
1708 for i := 0; i < 10000; i++ {
1709 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStructUnion(popr, false))
1710 if err != nil {
1711 panic(err)
1712 }
1713 datas[i] = dAtA
1714 }
1715 msg := &NinNestedStructUnion{}
1716 b.ResetTimer()
1717 for i := 0; i < b.N; i++ {
1718 total += len(datas[i%10000])
1719 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1720 panic(err)
1721 }
1722 }
1723 b.SetBytes(int64(total / b.N))
1724 }
1725
1726 func TestTreeProto(t *testing.T) {
1727 seed := time.Now().UnixNano()
1728 popr := math_rand.New(math_rand.NewSource(seed))
1729 p := NewPopulatedTree(popr, false)
1730 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1731 if err != nil {
1732 t.Fatalf("seed = %d, err = %v", seed, err)
1733 }
1734 msg := &Tree{}
1735 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1736 t.Fatalf("seed = %d, err = %v", seed, err)
1737 }
1738 littlefuzz := make([]byte, len(dAtA))
1739 copy(littlefuzz, dAtA)
1740 for i := range dAtA {
1741 dAtA[i] = byte(popr.Intn(256))
1742 }
1743 if err := p.VerboseEqual(msg); err != nil {
1744 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1745 }
1746 if !p.Equal(msg) {
1747 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1748 }
1749 if len(littlefuzz) > 0 {
1750 fuzzamount := 100
1751 for i := 0; i < fuzzamount; i++ {
1752 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1753 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1754 }
1755
1756 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1757 }
1758 }
1759
1760 func BenchmarkTreeProtoMarshal(b *testing.B) {
1761 popr := math_rand.New(math_rand.NewSource(616))
1762 total := 0
1763 pops := make([]*Tree, 10000)
1764 for i := 0; i < 10000; i++ {
1765 pops[i] = NewPopulatedTree(popr, false)
1766 }
1767 b.ResetTimer()
1768 for i := 0; i < b.N; i++ {
1769 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1770 if err != nil {
1771 panic(err)
1772 }
1773 total += len(dAtA)
1774 }
1775 b.SetBytes(int64(total / b.N))
1776 }
1777
1778 func BenchmarkTreeProtoUnmarshal(b *testing.B) {
1779 popr := math_rand.New(math_rand.NewSource(616))
1780 total := 0
1781 datas := make([][]byte, 10000)
1782 for i := 0; i < 10000; i++ {
1783 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTree(popr, false))
1784 if err != nil {
1785 panic(err)
1786 }
1787 datas[i] = dAtA
1788 }
1789 msg := &Tree{}
1790 b.ResetTimer()
1791 for i := 0; i < b.N; i++ {
1792 total += len(datas[i%10000])
1793 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1794 panic(err)
1795 }
1796 }
1797 b.SetBytes(int64(total / b.N))
1798 }
1799
1800 func TestOrBranchProto(t *testing.T) {
1801 seed := time.Now().UnixNano()
1802 popr := math_rand.New(math_rand.NewSource(seed))
1803 p := NewPopulatedOrBranch(popr, false)
1804 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1805 if err != nil {
1806 t.Fatalf("seed = %d, err = %v", seed, err)
1807 }
1808 msg := &OrBranch{}
1809 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1810 t.Fatalf("seed = %d, err = %v", seed, err)
1811 }
1812 littlefuzz := make([]byte, len(dAtA))
1813 copy(littlefuzz, dAtA)
1814 for i := range dAtA {
1815 dAtA[i] = byte(popr.Intn(256))
1816 }
1817 if err := p.VerboseEqual(msg); err != nil {
1818 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1819 }
1820 if !p.Equal(msg) {
1821 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1822 }
1823 if len(littlefuzz) > 0 {
1824 fuzzamount := 100
1825 for i := 0; i < fuzzamount; i++ {
1826 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1827 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1828 }
1829
1830 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1831 }
1832 }
1833
1834 func BenchmarkOrBranchProtoMarshal(b *testing.B) {
1835 popr := math_rand.New(math_rand.NewSource(616))
1836 total := 0
1837 pops := make([]*OrBranch, 10000)
1838 for i := 0; i < 10000; i++ {
1839 pops[i] = NewPopulatedOrBranch(popr, false)
1840 }
1841 b.ResetTimer()
1842 for i := 0; i < b.N; i++ {
1843 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1844 if err != nil {
1845 panic(err)
1846 }
1847 total += len(dAtA)
1848 }
1849 b.SetBytes(int64(total / b.N))
1850 }
1851
1852 func BenchmarkOrBranchProtoUnmarshal(b *testing.B) {
1853 popr := math_rand.New(math_rand.NewSource(616))
1854 total := 0
1855 datas := make([][]byte, 10000)
1856 for i := 0; i < 10000; i++ {
1857 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOrBranch(popr, false))
1858 if err != nil {
1859 panic(err)
1860 }
1861 datas[i] = dAtA
1862 }
1863 msg := &OrBranch{}
1864 b.ResetTimer()
1865 for i := 0; i < b.N; i++ {
1866 total += len(datas[i%10000])
1867 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1868 panic(err)
1869 }
1870 }
1871 b.SetBytes(int64(total / b.N))
1872 }
1873
1874 func TestAndBranchProto(t *testing.T) {
1875 seed := time.Now().UnixNano()
1876 popr := math_rand.New(math_rand.NewSource(seed))
1877 p := NewPopulatedAndBranch(popr, false)
1878 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1879 if err != nil {
1880 t.Fatalf("seed = %d, err = %v", seed, err)
1881 }
1882 msg := &AndBranch{}
1883 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1884 t.Fatalf("seed = %d, err = %v", seed, err)
1885 }
1886 littlefuzz := make([]byte, len(dAtA))
1887 copy(littlefuzz, dAtA)
1888 for i := range dAtA {
1889 dAtA[i] = byte(popr.Intn(256))
1890 }
1891 if err := p.VerboseEqual(msg); err != nil {
1892 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1893 }
1894 if !p.Equal(msg) {
1895 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1896 }
1897 if len(littlefuzz) > 0 {
1898 fuzzamount := 100
1899 for i := 0; i < fuzzamount; i++ {
1900 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1901 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1902 }
1903
1904 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1905 }
1906 }
1907
1908 func BenchmarkAndBranchProtoMarshal(b *testing.B) {
1909 popr := math_rand.New(math_rand.NewSource(616))
1910 total := 0
1911 pops := make([]*AndBranch, 10000)
1912 for i := 0; i < 10000; i++ {
1913 pops[i] = NewPopulatedAndBranch(popr, false)
1914 }
1915 b.ResetTimer()
1916 for i := 0; i < b.N; i++ {
1917 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1918 if err != nil {
1919 panic(err)
1920 }
1921 total += len(dAtA)
1922 }
1923 b.SetBytes(int64(total / b.N))
1924 }
1925
1926 func BenchmarkAndBranchProtoUnmarshal(b *testing.B) {
1927 popr := math_rand.New(math_rand.NewSource(616))
1928 total := 0
1929 datas := make([][]byte, 10000)
1930 for i := 0; i < 10000; i++ {
1931 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndBranch(popr, false))
1932 if err != nil {
1933 panic(err)
1934 }
1935 datas[i] = dAtA
1936 }
1937 msg := &AndBranch{}
1938 b.ResetTimer()
1939 for i := 0; i < b.N; i++ {
1940 total += len(datas[i%10000])
1941 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
1942 panic(err)
1943 }
1944 }
1945 b.SetBytes(int64(total / b.N))
1946 }
1947
1948 func TestLeafProto(t *testing.T) {
1949 seed := time.Now().UnixNano()
1950 popr := math_rand.New(math_rand.NewSource(seed))
1951 p := NewPopulatedLeaf(popr, false)
1952 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1953 if err != nil {
1954 t.Fatalf("seed = %d, err = %v", seed, err)
1955 }
1956 msg := &Leaf{}
1957 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1958 t.Fatalf("seed = %d, err = %v", seed, err)
1959 }
1960 littlefuzz := make([]byte, len(dAtA))
1961 copy(littlefuzz, dAtA)
1962 for i := range dAtA {
1963 dAtA[i] = byte(popr.Intn(256))
1964 }
1965 if err := p.VerboseEqual(msg); err != nil {
1966 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1967 }
1968 if !p.Equal(msg) {
1969 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1970 }
1971 if len(littlefuzz) > 0 {
1972 fuzzamount := 100
1973 for i := 0; i < fuzzamount; i++ {
1974 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
1975 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
1976 }
1977
1978 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
1979 }
1980 }
1981
1982 func BenchmarkLeafProtoMarshal(b *testing.B) {
1983 popr := math_rand.New(math_rand.NewSource(616))
1984 total := 0
1985 pops := make([]*Leaf, 10000)
1986 for i := 0; i < 10000; i++ {
1987 pops[i] = NewPopulatedLeaf(popr, false)
1988 }
1989 b.ResetTimer()
1990 for i := 0; i < b.N; i++ {
1991 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
1992 if err != nil {
1993 panic(err)
1994 }
1995 total += len(dAtA)
1996 }
1997 b.SetBytes(int64(total / b.N))
1998 }
1999
2000 func BenchmarkLeafProtoUnmarshal(b *testing.B) {
2001 popr := math_rand.New(math_rand.NewSource(616))
2002 total := 0
2003 datas := make([][]byte, 10000)
2004 for i := 0; i < 10000; i++ {
2005 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLeaf(popr, false))
2006 if err != nil {
2007 panic(err)
2008 }
2009 datas[i] = dAtA
2010 }
2011 msg := &Leaf{}
2012 b.ResetTimer()
2013 for i := 0; i < b.N; i++ {
2014 total += len(datas[i%10000])
2015 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2016 panic(err)
2017 }
2018 }
2019 b.SetBytes(int64(total / b.N))
2020 }
2021
2022 func TestDeepTreeProto(t *testing.T) {
2023 seed := time.Now().UnixNano()
2024 popr := math_rand.New(math_rand.NewSource(seed))
2025 p := NewPopulatedDeepTree(popr, false)
2026 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2027 if err != nil {
2028 t.Fatalf("seed = %d, err = %v", seed, err)
2029 }
2030 msg := &DeepTree{}
2031 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2032 t.Fatalf("seed = %d, err = %v", seed, err)
2033 }
2034 littlefuzz := make([]byte, len(dAtA))
2035 copy(littlefuzz, dAtA)
2036 for i := range dAtA {
2037 dAtA[i] = byte(popr.Intn(256))
2038 }
2039 if err := p.VerboseEqual(msg); err != nil {
2040 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2041 }
2042 if !p.Equal(msg) {
2043 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2044 }
2045 if len(littlefuzz) > 0 {
2046 fuzzamount := 100
2047 for i := 0; i < fuzzamount; i++ {
2048 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2049 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2050 }
2051
2052 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2053 }
2054 }
2055
2056 func BenchmarkDeepTreeProtoMarshal(b *testing.B) {
2057 popr := math_rand.New(math_rand.NewSource(616))
2058 total := 0
2059 pops := make([]*DeepTree, 10000)
2060 for i := 0; i < 10000; i++ {
2061 pops[i] = NewPopulatedDeepTree(popr, false)
2062 }
2063 b.ResetTimer()
2064 for i := 0; i < b.N; i++ {
2065 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2066 if err != nil {
2067 panic(err)
2068 }
2069 total += len(dAtA)
2070 }
2071 b.SetBytes(int64(total / b.N))
2072 }
2073
2074 func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) {
2075 popr := math_rand.New(math_rand.NewSource(616))
2076 total := 0
2077 datas := make([][]byte, 10000)
2078 for i := 0; i < 10000; i++ {
2079 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepTree(popr, false))
2080 if err != nil {
2081 panic(err)
2082 }
2083 datas[i] = dAtA
2084 }
2085 msg := &DeepTree{}
2086 b.ResetTimer()
2087 for i := 0; i < b.N; i++ {
2088 total += len(datas[i%10000])
2089 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2090 panic(err)
2091 }
2092 }
2093 b.SetBytes(int64(total / b.N))
2094 }
2095
2096 func TestADeepBranchProto(t *testing.T) {
2097 seed := time.Now().UnixNano()
2098 popr := math_rand.New(math_rand.NewSource(seed))
2099 p := NewPopulatedADeepBranch(popr, false)
2100 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2101 if err != nil {
2102 t.Fatalf("seed = %d, err = %v", seed, err)
2103 }
2104 msg := &ADeepBranch{}
2105 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2106 t.Fatalf("seed = %d, err = %v", seed, err)
2107 }
2108 littlefuzz := make([]byte, len(dAtA))
2109 copy(littlefuzz, dAtA)
2110 for i := range dAtA {
2111 dAtA[i] = byte(popr.Intn(256))
2112 }
2113 if err := p.VerboseEqual(msg); err != nil {
2114 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2115 }
2116 if !p.Equal(msg) {
2117 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2118 }
2119 if len(littlefuzz) > 0 {
2120 fuzzamount := 100
2121 for i := 0; i < fuzzamount; i++ {
2122 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2123 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2124 }
2125
2126 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2127 }
2128 }
2129
2130 func BenchmarkADeepBranchProtoMarshal(b *testing.B) {
2131 popr := math_rand.New(math_rand.NewSource(616))
2132 total := 0
2133 pops := make([]*ADeepBranch, 10000)
2134 for i := 0; i < 10000; i++ {
2135 pops[i] = NewPopulatedADeepBranch(popr, false)
2136 }
2137 b.ResetTimer()
2138 for i := 0; i < b.N; i++ {
2139 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2140 if err != nil {
2141 panic(err)
2142 }
2143 total += len(dAtA)
2144 }
2145 b.SetBytes(int64(total / b.N))
2146 }
2147
2148 func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) {
2149 popr := math_rand.New(math_rand.NewSource(616))
2150 total := 0
2151 datas := make([][]byte, 10000)
2152 for i := 0; i < 10000; i++ {
2153 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedADeepBranch(popr, false))
2154 if err != nil {
2155 panic(err)
2156 }
2157 datas[i] = dAtA
2158 }
2159 msg := &ADeepBranch{}
2160 b.ResetTimer()
2161 for i := 0; i < b.N; i++ {
2162 total += len(datas[i%10000])
2163 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2164 panic(err)
2165 }
2166 }
2167 b.SetBytes(int64(total / b.N))
2168 }
2169
2170 func TestAndDeepBranchProto(t *testing.T) {
2171 seed := time.Now().UnixNano()
2172 popr := math_rand.New(math_rand.NewSource(seed))
2173 p := NewPopulatedAndDeepBranch(popr, false)
2174 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2175 if err != nil {
2176 t.Fatalf("seed = %d, err = %v", seed, err)
2177 }
2178 msg := &AndDeepBranch{}
2179 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2180 t.Fatalf("seed = %d, err = %v", seed, err)
2181 }
2182 littlefuzz := make([]byte, len(dAtA))
2183 copy(littlefuzz, dAtA)
2184 for i := range dAtA {
2185 dAtA[i] = byte(popr.Intn(256))
2186 }
2187 if err := p.VerboseEqual(msg); err != nil {
2188 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2189 }
2190 if !p.Equal(msg) {
2191 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2192 }
2193 if len(littlefuzz) > 0 {
2194 fuzzamount := 100
2195 for i := 0; i < fuzzamount; i++ {
2196 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2197 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2198 }
2199
2200 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2201 }
2202 }
2203
2204 func BenchmarkAndDeepBranchProtoMarshal(b *testing.B) {
2205 popr := math_rand.New(math_rand.NewSource(616))
2206 total := 0
2207 pops := make([]*AndDeepBranch, 10000)
2208 for i := 0; i < 10000; i++ {
2209 pops[i] = NewPopulatedAndDeepBranch(popr, false)
2210 }
2211 b.ResetTimer()
2212 for i := 0; i < b.N; i++ {
2213 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2214 if err != nil {
2215 panic(err)
2216 }
2217 total += len(dAtA)
2218 }
2219 b.SetBytes(int64(total / b.N))
2220 }
2221
2222 func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) {
2223 popr := math_rand.New(math_rand.NewSource(616))
2224 total := 0
2225 datas := make([][]byte, 10000)
2226 for i := 0; i < 10000; i++ {
2227 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndDeepBranch(popr, false))
2228 if err != nil {
2229 panic(err)
2230 }
2231 datas[i] = dAtA
2232 }
2233 msg := &AndDeepBranch{}
2234 b.ResetTimer()
2235 for i := 0; i < b.N; i++ {
2236 total += len(datas[i%10000])
2237 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2238 panic(err)
2239 }
2240 }
2241 b.SetBytes(int64(total / b.N))
2242 }
2243
2244 func TestDeepLeafProto(t *testing.T) {
2245 seed := time.Now().UnixNano()
2246 popr := math_rand.New(math_rand.NewSource(seed))
2247 p := NewPopulatedDeepLeaf(popr, false)
2248 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2249 if err != nil {
2250 t.Fatalf("seed = %d, err = %v", seed, err)
2251 }
2252 msg := &DeepLeaf{}
2253 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2254 t.Fatalf("seed = %d, err = %v", seed, err)
2255 }
2256 littlefuzz := make([]byte, len(dAtA))
2257 copy(littlefuzz, dAtA)
2258 for i := range dAtA {
2259 dAtA[i] = byte(popr.Intn(256))
2260 }
2261 if err := p.VerboseEqual(msg); err != nil {
2262 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2263 }
2264 if !p.Equal(msg) {
2265 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2266 }
2267 if len(littlefuzz) > 0 {
2268 fuzzamount := 100
2269 for i := 0; i < fuzzamount; i++ {
2270 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2271 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2272 }
2273
2274 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2275 }
2276 }
2277
2278 func BenchmarkDeepLeafProtoMarshal(b *testing.B) {
2279 popr := math_rand.New(math_rand.NewSource(616))
2280 total := 0
2281 pops := make([]*DeepLeaf, 10000)
2282 for i := 0; i < 10000; i++ {
2283 pops[i] = NewPopulatedDeepLeaf(popr, false)
2284 }
2285 b.ResetTimer()
2286 for i := 0; i < b.N; i++ {
2287 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2288 if err != nil {
2289 panic(err)
2290 }
2291 total += len(dAtA)
2292 }
2293 b.SetBytes(int64(total / b.N))
2294 }
2295
2296 func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) {
2297 popr := math_rand.New(math_rand.NewSource(616))
2298 total := 0
2299 datas := make([][]byte, 10000)
2300 for i := 0; i < 10000; i++ {
2301 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepLeaf(popr, false))
2302 if err != nil {
2303 panic(err)
2304 }
2305 datas[i] = dAtA
2306 }
2307 msg := &DeepLeaf{}
2308 b.ResetTimer()
2309 for i := 0; i < b.N; i++ {
2310 total += len(datas[i%10000])
2311 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2312 panic(err)
2313 }
2314 }
2315 b.SetBytes(int64(total / b.N))
2316 }
2317
2318 func TestNilProto(t *testing.T) {
2319 seed := time.Now().UnixNano()
2320 popr := math_rand.New(math_rand.NewSource(seed))
2321 p := NewPopulatedNil(popr, false)
2322 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2323 if err != nil {
2324 t.Fatalf("seed = %d, err = %v", seed, err)
2325 }
2326 msg := &Nil{}
2327 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2328 t.Fatalf("seed = %d, err = %v", seed, err)
2329 }
2330 littlefuzz := make([]byte, len(dAtA))
2331 copy(littlefuzz, dAtA)
2332 for i := range dAtA {
2333 dAtA[i] = byte(popr.Intn(256))
2334 }
2335 if err := p.VerboseEqual(msg); err != nil {
2336 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2337 }
2338 if !p.Equal(msg) {
2339 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2340 }
2341 if len(littlefuzz) > 0 {
2342 fuzzamount := 100
2343 for i := 0; i < fuzzamount; i++ {
2344 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2345 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2346 }
2347
2348 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2349 }
2350 }
2351
2352 func BenchmarkNilProtoMarshal(b *testing.B) {
2353 popr := math_rand.New(math_rand.NewSource(616))
2354 total := 0
2355 pops := make([]*Nil, 10000)
2356 for i := 0; i < 10000; i++ {
2357 pops[i] = NewPopulatedNil(popr, false)
2358 }
2359 b.ResetTimer()
2360 for i := 0; i < b.N; i++ {
2361 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2362 if err != nil {
2363 panic(err)
2364 }
2365 total += len(dAtA)
2366 }
2367 b.SetBytes(int64(total / b.N))
2368 }
2369
2370 func BenchmarkNilProtoUnmarshal(b *testing.B) {
2371 popr := math_rand.New(math_rand.NewSource(616))
2372 total := 0
2373 datas := make([][]byte, 10000)
2374 for i := 0; i < 10000; i++ {
2375 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNil(popr, false))
2376 if err != nil {
2377 panic(err)
2378 }
2379 datas[i] = dAtA
2380 }
2381 msg := &Nil{}
2382 b.ResetTimer()
2383 for i := 0; i < b.N; i++ {
2384 total += len(datas[i%10000])
2385 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2386 panic(err)
2387 }
2388 }
2389 b.SetBytes(int64(total / b.N))
2390 }
2391
2392 func TestNidOptEnumProto(t *testing.T) {
2393 seed := time.Now().UnixNano()
2394 popr := math_rand.New(math_rand.NewSource(seed))
2395 p := NewPopulatedNidOptEnum(popr, false)
2396 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2397 if err != nil {
2398 t.Fatalf("seed = %d, err = %v", seed, err)
2399 }
2400 msg := &NidOptEnum{}
2401 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2402 t.Fatalf("seed = %d, err = %v", seed, err)
2403 }
2404 littlefuzz := make([]byte, len(dAtA))
2405 copy(littlefuzz, dAtA)
2406 for i := range dAtA {
2407 dAtA[i] = byte(popr.Intn(256))
2408 }
2409 if err := p.VerboseEqual(msg); err != nil {
2410 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2411 }
2412 if !p.Equal(msg) {
2413 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2414 }
2415 if len(littlefuzz) > 0 {
2416 fuzzamount := 100
2417 for i := 0; i < fuzzamount; i++ {
2418 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2419 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2420 }
2421
2422 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2423 }
2424 }
2425
2426 func BenchmarkNidOptEnumProtoMarshal(b *testing.B) {
2427 popr := math_rand.New(math_rand.NewSource(616))
2428 total := 0
2429 pops := make([]*NidOptEnum, 10000)
2430 for i := 0; i < 10000; i++ {
2431 pops[i] = NewPopulatedNidOptEnum(popr, false)
2432 }
2433 b.ResetTimer()
2434 for i := 0; i < b.N; i++ {
2435 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2436 if err != nil {
2437 panic(err)
2438 }
2439 total += len(dAtA)
2440 }
2441 b.SetBytes(int64(total / b.N))
2442 }
2443
2444 func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) {
2445 popr := math_rand.New(math_rand.NewSource(616))
2446 total := 0
2447 datas := make([][]byte, 10000)
2448 for i := 0; i < 10000; i++ {
2449 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptEnum(popr, false))
2450 if err != nil {
2451 panic(err)
2452 }
2453 datas[i] = dAtA
2454 }
2455 msg := &NidOptEnum{}
2456 b.ResetTimer()
2457 for i := 0; i < b.N; i++ {
2458 total += len(datas[i%10000])
2459 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2460 panic(err)
2461 }
2462 }
2463 b.SetBytes(int64(total / b.N))
2464 }
2465
2466 func TestNinOptEnumProto(t *testing.T) {
2467 seed := time.Now().UnixNano()
2468 popr := math_rand.New(math_rand.NewSource(seed))
2469 p := NewPopulatedNinOptEnum(popr, false)
2470 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2471 if err != nil {
2472 t.Fatalf("seed = %d, err = %v", seed, err)
2473 }
2474 msg := &NinOptEnum{}
2475 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2476 t.Fatalf("seed = %d, err = %v", seed, err)
2477 }
2478 littlefuzz := make([]byte, len(dAtA))
2479 copy(littlefuzz, dAtA)
2480 for i := range dAtA {
2481 dAtA[i] = byte(popr.Intn(256))
2482 }
2483 if err := p.VerboseEqual(msg); err != nil {
2484 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2485 }
2486 if !p.Equal(msg) {
2487 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2488 }
2489 if len(littlefuzz) > 0 {
2490 fuzzamount := 100
2491 for i := 0; i < fuzzamount; i++ {
2492 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2493 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2494 }
2495
2496 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2497 }
2498 }
2499
2500 func BenchmarkNinOptEnumProtoMarshal(b *testing.B) {
2501 popr := math_rand.New(math_rand.NewSource(616))
2502 total := 0
2503 pops := make([]*NinOptEnum, 10000)
2504 for i := 0; i < 10000; i++ {
2505 pops[i] = NewPopulatedNinOptEnum(popr, false)
2506 }
2507 b.ResetTimer()
2508 for i := 0; i < b.N; i++ {
2509 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2510 if err != nil {
2511 panic(err)
2512 }
2513 total += len(dAtA)
2514 }
2515 b.SetBytes(int64(total / b.N))
2516 }
2517
2518 func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) {
2519 popr := math_rand.New(math_rand.NewSource(616))
2520 total := 0
2521 datas := make([][]byte, 10000)
2522 for i := 0; i < 10000; i++ {
2523 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnum(popr, false))
2524 if err != nil {
2525 panic(err)
2526 }
2527 datas[i] = dAtA
2528 }
2529 msg := &NinOptEnum{}
2530 b.ResetTimer()
2531 for i := 0; i < b.N; i++ {
2532 total += len(datas[i%10000])
2533 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2534 panic(err)
2535 }
2536 }
2537 b.SetBytes(int64(total / b.N))
2538 }
2539
2540 func TestNidRepEnumProto(t *testing.T) {
2541 seed := time.Now().UnixNano()
2542 popr := math_rand.New(math_rand.NewSource(seed))
2543 p := NewPopulatedNidRepEnum(popr, false)
2544 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2545 if err != nil {
2546 t.Fatalf("seed = %d, err = %v", seed, err)
2547 }
2548 msg := &NidRepEnum{}
2549 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2550 t.Fatalf("seed = %d, err = %v", seed, err)
2551 }
2552 littlefuzz := make([]byte, len(dAtA))
2553 copy(littlefuzz, dAtA)
2554 for i := range dAtA {
2555 dAtA[i] = byte(popr.Intn(256))
2556 }
2557 if err := p.VerboseEqual(msg); err != nil {
2558 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2559 }
2560 if !p.Equal(msg) {
2561 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2562 }
2563 if len(littlefuzz) > 0 {
2564 fuzzamount := 100
2565 for i := 0; i < fuzzamount; i++ {
2566 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2567 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2568 }
2569
2570 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2571 }
2572 }
2573
2574 func BenchmarkNidRepEnumProtoMarshal(b *testing.B) {
2575 popr := math_rand.New(math_rand.NewSource(616))
2576 total := 0
2577 pops := make([]*NidRepEnum, 10000)
2578 for i := 0; i < 10000; i++ {
2579 pops[i] = NewPopulatedNidRepEnum(popr, false)
2580 }
2581 b.ResetTimer()
2582 for i := 0; i < b.N; i++ {
2583 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2584 if err != nil {
2585 panic(err)
2586 }
2587 total += len(dAtA)
2588 }
2589 b.SetBytes(int64(total / b.N))
2590 }
2591
2592 func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) {
2593 popr := math_rand.New(math_rand.NewSource(616))
2594 total := 0
2595 datas := make([][]byte, 10000)
2596 for i := 0; i < 10000; i++ {
2597 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepEnum(popr, false))
2598 if err != nil {
2599 panic(err)
2600 }
2601 datas[i] = dAtA
2602 }
2603 msg := &NidRepEnum{}
2604 b.ResetTimer()
2605 for i := 0; i < b.N; i++ {
2606 total += len(datas[i%10000])
2607 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2608 panic(err)
2609 }
2610 }
2611 b.SetBytes(int64(total / b.N))
2612 }
2613
2614 func TestNinRepEnumProto(t *testing.T) {
2615 seed := time.Now().UnixNano()
2616 popr := math_rand.New(math_rand.NewSource(seed))
2617 p := NewPopulatedNinRepEnum(popr, false)
2618 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2619 if err != nil {
2620 t.Fatalf("seed = %d, err = %v", seed, err)
2621 }
2622 msg := &NinRepEnum{}
2623 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2624 t.Fatalf("seed = %d, err = %v", seed, err)
2625 }
2626 littlefuzz := make([]byte, len(dAtA))
2627 copy(littlefuzz, dAtA)
2628 for i := range dAtA {
2629 dAtA[i] = byte(popr.Intn(256))
2630 }
2631 if err := p.VerboseEqual(msg); err != nil {
2632 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2633 }
2634 if !p.Equal(msg) {
2635 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2636 }
2637 if len(littlefuzz) > 0 {
2638 fuzzamount := 100
2639 for i := 0; i < fuzzamount; i++ {
2640 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2641 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2642 }
2643
2644 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2645 }
2646 }
2647
2648 func BenchmarkNinRepEnumProtoMarshal(b *testing.B) {
2649 popr := math_rand.New(math_rand.NewSource(616))
2650 total := 0
2651 pops := make([]*NinRepEnum, 10000)
2652 for i := 0; i < 10000; i++ {
2653 pops[i] = NewPopulatedNinRepEnum(popr, false)
2654 }
2655 b.ResetTimer()
2656 for i := 0; i < b.N; i++ {
2657 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2658 if err != nil {
2659 panic(err)
2660 }
2661 total += len(dAtA)
2662 }
2663 b.SetBytes(int64(total / b.N))
2664 }
2665
2666 func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) {
2667 popr := math_rand.New(math_rand.NewSource(616))
2668 total := 0
2669 datas := make([][]byte, 10000)
2670 for i := 0; i < 10000; i++ {
2671 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepEnum(popr, false))
2672 if err != nil {
2673 panic(err)
2674 }
2675 datas[i] = dAtA
2676 }
2677 msg := &NinRepEnum{}
2678 b.ResetTimer()
2679 for i := 0; i < b.N; i++ {
2680 total += len(datas[i%10000])
2681 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2682 panic(err)
2683 }
2684 }
2685 b.SetBytes(int64(total / b.N))
2686 }
2687
2688 func TestNinOptEnumDefaultProto(t *testing.T) {
2689 seed := time.Now().UnixNano()
2690 popr := math_rand.New(math_rand.NewSource(seed))
2691 p := NewPopulatedNinOptEnumDefault(popr, false)
2692 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2693 if err != nil {
2694 t.Fatalf("seed = %d, err = %v", seed, err)
2695 }
2696 msg := &NinOptEnumDefault{}
2697 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2698 t.Fatalf("seed = %d, err = %v", seed, err)
2699 }
2700 littlefuzz := make([]byte, len(dAtA))
2701 copy(littlefuzz, dAtA)
2702 for i := range dAtA {
2703 dAtA[i] = byte(popr.Intn(256))
2704 }
2705 if err := p.VerboseEqual(msg); err != nil {
2706 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2707 }
2708 if !p.Equal(msg) {
2709 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2710 }
2711 if len(littlefuzz) > 0 {
2712 fuzzamount := 100
2713 for i := 0; i < fuzzamount; i++ {
2714 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2715 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2716 }
2717
2718 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2719 }
2720 }
2721
2722 func BenchmarkNinOptEnumDefaultProtoMarshal(b *testing.B) {
2723 popr := math_rand.New(math_rand.NewSource(616))
2724 total := 0
2725 pops := make([]*NinOptEnumDefault, 10000)
2726 for i := 0; i < 10000; i++ {
2727 pops[i] = NewPopulatedNinOptEnumDefault(popr, false)
2728 }
2729 b.ResetTimer()
2730 for i := 0; i < b.N; i++ {
2731 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2732 if err != nil {
2733 panic(err)
2734 }
2735 total += len(dAtA)
2736 }
2737 b.SetBytes(int64(total / b.N))
2738 }
2739
2740 func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) {
2741 popr := math_rand.New(math_rand.NewSource(616))
2742 total := 0
2743 datas := make([][]byte, 10000)
2744 for i := 0; i < 10000; i++ {
2745 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnumDefault(popr, false))
2746 if err != nil {
2747 panic(err)
2748 }
2749 datas[i] = dAtA
2750 }
2751 msg := &NinOptEnumDefault{}
2752 b.ResetTimer()
2753 for i := 0; i < b.N; i++ {
2754 total += len(datas[i%10000])
2755 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2756 panic(err)
2757 }
2758 }
2759 b.SetBytes(int64(total / b.N))
2760 }
2761
2762 func TestAnotherNinOptEnumProto(t *testing.T) {
2763 seed := time.Now().UnixNano()
2764 popr := math_rand.New(math_rand.NewSource(seed))
2765 p := NewPopulatedAnotherNinOptEnum(popr, false)
2766 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2767 if err != nil {
2768 t.Fatalf("seed = %d, err = %v", seed, err)
2769 }
2770 msg := &AnotherNinOptEnum{}
2771 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2772 t.Fatalf("seed = %d, err = %v", seed, err)
2773 }
2774 littlefuzz := make([]byte, len(dAtA))
2775 copy(littlefuzz, dAtA)
2776 for i := range dAtA {
2777 dAtA[i] = byte(popr.Intn(256))
2778 }
2779 if err := p.VerboseEqual(msg); err != nil {
2780 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2781 }
2782 if !p.Equal(msg) {
2783 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2784 }
2785 if len(littlefuzz) > 0 {
2786 fuzzamount := 100
2787 for i := 0; i < fuzzamount; i++ {
2788 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2789 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2790 }
2791
2792 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2793 }
2794 }
2795
2796 func BenchmarkAnotherNinOptEnumProtoMarshal(b *testing.B) {
2797 popr := math_rand.New(math_rand.NewSource(616))
2798 total := 0
2799 pops := make([]*AnotherNinOptEnum, 10000)
2800 for i := 0; i < 10000; i++ {
2801 pops[i] = NewPopulatedAnotherNinOptEnum(popr, false)
2802 }
2803 b.ResetTimer()
2804 for i := 0; i < b.N; i++ {
2805 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2806 if err != nil {
2807 panic(err)
2808 }
2809 total += len(dAtA)
2810 }
2811 b.SetBytes(int64(total / b.N))
2812 }
2813
2814 func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) {
2815 popr := math_rand.New(math_rand.NewSource(616))
2816 total := 0
2817 datas := make([][]byte, 10000)
2818 for i := 0; i < 10000; i++ {
2819 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnum(popr, false))
2820 if err != nil {
2821 panic(err)
2822 }
2823 datas[i] = dAtA
2824 }
2825 msg := &AnotherNinOptEnum{}
2826 b.ResetTimer()
2827 for i := 0; i < b.N; i++ {
2828 total += len(datas[i%10000])
2829 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2830 panic(err)
2831 }
2832 }
2833 b.SetBytes(int64(total / b.N))
2834 }
2835
2836 func TestAnotherNinOptEnumDefaultProto(t *testing.T) {
2837 seed := time.Now().UnixNano()
2838 popr := math_rand.New(math_rand.NewSource(seed))
2839 p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
2840 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2841 if err != nil {
2842 t.Fatalf("seed = %d, err = %v", seed, err)
2843 }
2844 msg := &AnotherNinOptEnumDefault{}
2845 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2846 t.Fatalf("seed = %d, err = %v", seed, err)
2847 }
2848 littlefuzz := make([]byte, len(dAtA))
2849 copy(littlefuzz, dAtA)
2850 for i := range dAtA {
2851 dAtA[i] = byte(popr.Intn(256))
2852 }
2853 if err := p.VerboseEqual(msg); err != nil {
2854 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2855 }
2856 if !p.Equal(msg) {
2857 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2858 }
2859 if len(littlefuzz) > 0 {
2860 fuzzamount := 100
2861 for i := 0; i < fuzzamount; i++ {
2862 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2863 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2864 }
2865
2866 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2867 }
2868 }
2869
2870 func BenchmarkAnotherNinOptEnumDefaultProtoMarshal(b *testing.B) {
2871 popr := math_rand.New(math_rand.NewSource(616))
2872 total := 0
2873 pops := make([]*AnotherNinOptEnumDefault, 10000)
2874 for i := 0; i < 10000; i++ {
2875 pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false)
2876 }
2877 b.ResetTimer()
2878 for i := 0; i < b.N; i++ {
2879 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2880 if err != nil {
2881 panic(err)
2882 }
2883 total += len(dAtA)
2884 }
2885 b.SetBytes(int64(total / b.N))
2886 }
2887
2888 func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) {
2889 popr := math_rand.New(math_rand.NewSource(616))
2890 total := 0
2891 datas := make([][]byte, 10000)
2892 for i := 0; i < 10000; i++ {
2893 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnumDefault(popr, false))
2894 if err != nil {
2895 panic(err)
2896 }
2897 datas[i] = dAtA
2898 }
2899 msg := &AnotherNinOptEnumDefault{}
2900 b.ResetTimer()
2901 for i := 0; i < b.N; i++ {
2902 total += len(datas[i%10000])
2903 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2904 panic(err)
2905 }
2906 }
2907 b.SetBytes(int64(total / b.N))
2908 }
2909
2910 func TestTimerProto(t *testing.T) {
2911 seed := time.Now().UnixNano()
2912 popr := math_rand.New(math_rand.NewSource(seed))
2913 p := NewPopulatedTimer(popr, false)
2914 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2915 if err != nil {
2916 t.Fatalf("seed = %d, err = %v", seed, err)
2917 }
2918 msg := &Timer{}
2919 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2920 t.Fatalf("seed = %d, err = %v", seed, err)
2921 }
2922 littlefuzz := make([]byte, len(dAtA))
2923 copy(littlefuzz, dAtA)
2924 for i := range dAtA {
2925 dAtA[i] = byte(popr.Intn(256))
2926 }
2927 if err := p.VerboseEqual(msg); err != nil {
2928 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
2929 }
2930 if !p.Equal(msg) {
2931 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
2932 }
2933 if len(littlefuzz) > 0 {
2934 fuzzamount := 100
2935 for i := 0; i < fuzzamount; i++ {
2936 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
2937 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
2938 }
2939
2940 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
2941 }
2942 }
2943
2944 func BenchmarkTimerProtoMarshal(b *testing.B) {
2945 popr := math_rand.New(math_rand.NewSource(616))
2946 total := 0
2947 pops := make([]*Timer, 10000)
2948 for i := 0; i < 10000; i++ {
2949 pops[i] = NewPopulatedTimer(popr, false)
2950 }
2951 b.ResetTimer()
2952 for i := 0; i < b.N; i++ {
2953 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
2954 if err != nil {
2955 panic(err)
2956 }
2957 total += len(dAtA)
2958 }
2959 b.SetBytes(int64(total / b.N))
2960 }
2961
2962 func BenchmarkTimerProtoUnmarshal(b *testing.B) {
2963 popr := math_rand.New(math_rand.NewSource(616))
2964 total := 0
2965 datas := make([][]byte, 10000)
2966 for i := 0; i < 10000; i++ {
2967 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTimer(popr, false))
2968 if err != nil {
2969 panic(err)
2970 }
2971 datas[i] = dAtA
2972 }
2973 msg := &Timer{}
2974 b.ResetTimer()
2975 for i := 0; i < b.N; i++ {
2976 total += len(datas[i%10000])
2977 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
2978 panic(err)
2979 }
2980 }
2981 b.SetBytes(int64(total / b.N))
2982 }
2983
2984 func TestMyExtendableProto(t *testing.T) {
2985 seed := time.Now().UnixNano()
2986 popr := math_rand.New(math_rand.NewSource(seed))
2987 p := NewPopulatedMyExtendable(popr, false)
2988 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
2989 if err != nil {
2990 t.Fatalf("seed = %d, err = %v", seed, err)
2991 }
2992 msg := &MyExtendable{}
2993 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
2994 t.Fatalf("seed = %d, err = %v", seed, err)
2995 }
2996 littlefuzz := make([]byte, len(dAtA))
2997 copy(littlefuzz, dAtA)
2998 for i := range dAtA {
2999 dAtA[i] = byte(popr.Intn(256))
3000 }
3001 if err := p.VerboseEqual(msg); err != nil {
3002 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3003 }
3004 if !p.Equal(msg) {
3005 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3006 }
3007 if len(littlefuzz) > 0 {
3008 fuzzamount := 100
3009 for i := 0; i < fuzzamount; i++ {
3010 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3011 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3012 }
3013
3014 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3015 }
3016 }
3017
3018 func BenchmarkMyExtendableProtoMarshal(b *testing.B) {
3019 popr := math_rand.New(math_rand.NewSource(616))
3020 total := 0
3021 pops := make([]*MyExtendable, 10000)
3022 for i := 0; i < 10000; i++ {
3023 pops[i] = NewPopulatedMyExtendable(popr, false)
3024 }
3025 b.ResetTimer()
3026 for i := 0; i < b.N; i++ {
3027 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3028 if err != nil {
3029 panic(err)
3030 }
3031 total += len(dAtA)
3032 }
3033 b.SetBytes(int64(total / b.N))
3034 }
3035
3036 func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) {
3037 popr := math_rand.New(math_rand.NewSource(616))
3038 total := 0
3039 datas := make([][]byte, 10000)
3040 for i := 0; i < 10000; i++ {
3041 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMyExtendable(popr, false))
3042 if err != nil {
3043 panic(err)
3044 }
3045 datas[i] = dAtA
3046 }
3047 msg := &MyExtendable{}
3048 b.ResetTimer()
3049 for i := 0; i < b.N; i++ {
3050 total += len(datas[i%10000])
3051 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3052 panic(err)
3053 }
3054 }
3055 b.SetBytes(int64(total / b.N))
3056 }
3057
3058 func TestOtherExtenableProto(t *testing.T) {
3059 seed := time.Now().UnixNano()
3060 popr := math_rand.New(math_rand.NewSource(seed))
3061 p := NewPopulatedOtherExtenable(popr, false)
3062 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3063 if err != nil {
3064 t.Fatalf("seed = %d, err = %v", seed, err)
3065 }
3066 msg := &OtherExtenable{}
3067 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3068 t.Fatalf("seed = %d, err = %v", seed, err)
3069 }
3070 littlefuzz := make([]byte, len(dAtA))
3071 copy(littlefuzz, dAtA)
3072 for i := range dAtA {
3073 dAtA[i] = byte(popr.Intn(256))
3074 }
3075 if err := p.VerboseEqual(msg); err != nil {
3076 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3077 }
3078 if !p.Equal(msg) {
3079 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3080 }
3081 if len(littlefuzz) > 0 {
3082 fuzzamount := 100
3083 for i := 0; i < fuzzamount; i++ {
3084 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3085 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3086 }
3087
3088 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3089 }
3090 }
3091
3092 func BenchmarkOtherExtenableProtoMarshal(b *testing.B) {
3093 popr := math_rand.New(math_rand.NewSource(616))
3094 total := 0
3095 pops := make([]*OtherExtenable, 10000)
3096 for i := 0; i < 10000; i++ {
3097 pops[i] = NewPopulatedOtherExtenable(popr, false)
3098 }
3099 b.ResetTimer()
3100 for i := 0; i < b.N; i++ {
3101 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3102 if err != nil {
3103 panic(err)
3104 }
3105 total += len(dAtA)
3106 }
3107 b.SetBytes(int64(total / b.N))
3108 }
3109
3110 func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) {
3111 popr := math_rand.New(math_rand.NewSource(616))
3112 total := 0
3113 datas := make([][]byte, 10000)
3114 for i := 0; i < 10000; i++ {
3115 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOtherExtenable(popr, false))
3116 if err != nil {
3117 panic(err)
3118 }
3119 datas[i] = dAtA
3120 }
3121 msg := &OtherExtenable{}
3122 b.ResetTimer()
3123 for i := 0; i < b.N; i++ {
3124 total += len(datas[i%10000])
3125 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3126 panic(err)
3127 }
3128 }
3129 b.SetBytes(int64(total / b.N))
3130 }
3131
3132 func TestNestedDefinitionProto(t *testing.T) {
3133 seed := time.Now().UnixNano()
3134 popr := math_rand.New(math_rand.NewSource(seed))
3135 p := NewPopulatedNestedDefinition(popr, false)
3136 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3137 if err != nil {
3138 t.Fatalf("seed = %d, err = %v", seed, err)
3139 }
3140 msg := &NestedDefinition{}
3141 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3142 t.Fatalf("seed = %d, err = %v", seed, err)
3143 }
3144 littlefuzz := make([]byte, len(dAtA))
3145 copy(littlefuzz, dAtA)
3146 for i := range dAtA {
3147 dAtA[i] = byte(popr.Intn(256))
3148 }
3149 if err := p.VerboseEqual(msg); err != nil {
3150 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3151 }
3152 if !p.Equal(msg) {
3153 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3154 }
3155 if len(littlefuzz) > 0 {
3156 fuzzamount := 100
3157 for i := 0; i < fuzzamount; i++ {
3158 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3159 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3160 }
3161
3162 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3163 }
3164 }
3165
3166 func BenchmarkNestedDefinitionProtoMarshal(b *testing.B) {
3167 popr := math_rand.New(math_rand.NewSource(616))
3168 total := 0
3169 pops := make([]*NestedDefinition, 10000)
3170 for i := 0; i < 10000; i++ {
3171 pops[i] = NewPopulatedNestedDefinition(popr, false)
3172 }
3173 b.ResetTimer()
3174 for i := 0; i < b.N; i++ {
3175 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3176 if err != nil {
3177 panic(err)
3178 }
3179 total += len(dAtA)
3180 }
3181 b.SetBytes(int64(total / b.N))
3182 }
3183
3184 func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) {
3185 popr := math_rand.New(math_rand.NewSource(616))
3186 total := 0
3187 datas := make([][]byte, 10000)
3188 for i := 0; i < 10000; i++ {
3189 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition(popr, false))
3190 if err != nil {
3191 panic(err)
3192 }
3193 datas[i] = dAtA
3194 }
3195 msg := &NestedDefinition{}
3196 b.ResetTimer()
3197 for i := 0; i < b.N; i++ {
3198 total += len(datas[i%10000])
3199 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3200 panic(err)
3201 }
3202 }
3203 b.SetBytes(int64(total / b.N))
3204 }
3205
3206 func TestNestedDefinition_NestedMessageProto(t *testing.T) {
3207 seed := time.Now().UnixNano()
3208 popr := math_rand.New(math_rand.NewSource(seed))
3209 p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
3210 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3211 if err != nil {
3212 t.Fatalf("seed = %d, err = %v", seed, err)
3213 }
3214 msg := &NestedDefinition_NestedMessage{}
3215 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3216 t.Fatalf("seed = %d, err = %v", seed, err)
3217 }
3218 littlefuzz := make([]byte, len(dAtA))
3219 copy(littlefuzz, dAtA)
3220 for i := range dAtA {
3221 dAtA[i] = byte(popr.Intn(256))
3222 }
3223 if err := p.VerboseEqual(msg); err != nil {
3224 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3225 }
3226 if !p.Equal(msg) {
3227 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3228 }
3229 if len(littlefuzz) > 0 {
3230 fuzzamount := 100
3231 for i := 0; i < fuzzamount; i++ {
3232 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3233 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3234 }
3235
3236 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3237 }
3238 }
3239
3240 func BenchmarkNestedDefinition_NestedMessageProtoMarshal(b *testing.B) {
3241 popr := math_rand.New(math_rand.NewSource(616))
3242 total := 0
3243 pops := make([]*NestedDefinition_NestedMessage, 10000)
3244 for i := 0; i < 10000; i++ {
3245 pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false)
3246 }
3247 b.ResetTimer()
3248 for i := 0; i < b.N; i++ {
3249 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3250 if err != nil {
3251 panic(err)
3252 }
3253 total += len(dAtA)
3254 }
3255 b.SetBytes(int64(total / b.N))
3256 }
3257
3258 func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) {
3259 popr := math_rand.New(math_rand.NewSource(616))
3260 total := 0
3261 datas := make([][]byte, 10000)
3262 for i := 0; i < 10000; i++ {
3263 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage(popr, false))
3264 if err != nil {
3265 panic(err)
3266 }
3267 datas[i] = dAtA
3268 }
3269 msg := &NestedDefinition_NestedMessage{}
3270 b.ResetTimer()
3271 for i := 0; i < b.N; i++ {
3272 total += len(datas[i%10000])
3273 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3274 panic(err)
3275 }
3276 }
3277 b.SetBytes(int64(total / b.N))
3278 }
3279
3280 func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) {
3281 seed := time.Now().UnixNano()
3282 popr := math_rand.New(math_rand.NewSource(seed))
3283 p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
3284 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3285 if err != nil {
3286 t.Fatalf("seed = %d, err = %v", seed, err)
3287 }
3288 msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
3289 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3290 t.Fatalf("seed = %d, err = %v", seed, err)
3291 }
3292 littlefuzz := make([]byte, len(dAtA))
3293 copy(littlefuzz, dAtA)
3294 for i := range dAtA {
3295 dAtA[i] = byte(popr.Intn(256))
3296 }
3297 if err := p.VerboseEqual(msg); err != nil {
3298 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3299 }
3300 if !p.Equal(msg) {
3301 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3302 }
3303 if len(littlefuzz) > 0 {
3304 fuzzamount := 100
3305 for i := 0; i < fuzzamount; i++ {
3306 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3307 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3308 }
3309
3310 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3311 }
3312 }
3313
3314 func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal(b *testing.B) {
3315 popr := math_rand.New(math_rand.NewSource(616))
3316 total := 0
3317 pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 10000)
3318 for i := 0; i < 10000; i++ {
3319 pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
3320 }
3321 b.ResetTimer()
3322 for i := 0; i < b.N; i++ {
3323 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3324 if err != nil {
3325 panic(err)
3326 }
3327 total += len(dAtA)
3328 }
3329 b.SetBytes(int64(total / b.N))
3330 }
3331
3332 func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *testing.B) {
3333 popr := math_rand.New(math_rand.NewSource(616))
3334 total := 0
3335 datas := make([][]byte, 10000)
3336 for i := 0; i < 10000; i++ {
3337 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false))
3338 if err != nil {
3339 panic(err)
3340 }
3341 datas[i] = dAtA
3342 }
3343 msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
3344 b.ResetTimer()
3345 for i := 0; i < b.N; i++ {
3346 total += len(datas[i%10000])
3347 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3348 panic(err)
3349 }
3350 }
3351 b.SetBytes(int64(total / b.N))
3352 }
3353
3354 func TestNestedScopeProto(t *testing.T) {
3355 seed := time.Now().UnixNano()
3356 popr := math_rand.New(math_rand.NewSource(seed))
3357 p := NewPopulatedNestedScope(popr, false)
3358 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3359 if err != nil {
3360 t.Fatalf("seed = %d, err = %v", seed, err)
3361 }
3362 msg := &NestedScope{}
3363 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3364 t.Fatalf("seed = %d, err = %v", seed, err)
3365 }
3366 littlefuzz := make([]byte, len(dAtA))
3367 copy(littlefuzz, dAtA)
3368 for i := range dAtA {
3369 dAtA[i] = byte(popr.Intn(256))
3370 }
3371 if err := p.VerboseEqual(msg); err != nil {
3372 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3373 }
3374 if !p.Equal(msg) {
3375 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3376 }
3377 if len(littlefuzz) > 0 {
3378 fuzzamount := 100
3379 for i := 0; i < fuzzamount; i++ {
3380 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3381 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3382 }
3383
3384 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3385 }
3386 }
3387
3388 func BenchmarkNestedScopeProtoMarshal(b *testing.B) {
3389 popr := math_rand.New(math_rand.NewSource(616))
3390 total := 0
3391 pops := make([]*NestedScope, 10000)
3392 for i := 0; i < 10000; i++ {
3393 pops[i] = NewPopulatedNestedScope(popr, false)
3394 }
3395 b.ResetTimer()
3396 for i := 0; i < b.N; i++ {
3397 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3398 if err != nil {
3399 panic(err)
3400 }
3401 total += len(dAtA)
3402 }
3403 b.SetBytes(int64(total / b.N))
3404 }
3405
3406 func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) {
3407 popr := math_rand.New(math_rand.NewSource(616))
3408 total := 0
3409 datas := make([][]byte, 10000)
3410 for i := 0; i < 10000; i++ {
3411 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedScope(popr, false))
3412 if err != nil {
3413 panic(err)
3414 }
3415 datas[i] = dAtA
3416 }
3417 msg := &NestedScope{}
3418 b.ResetTimer()
3419 for i := 0; i < b.N; i++ {
3420 total += len(datas[i%10000])
3421 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3422 panic(err)
3423 }
3424 }
3425 b.SetBytes(int64(total / b.N))
3426 }
3427
3428 func TestNinOptNativeDefaultProto(t *testing.T) {
3429 seed := time.Now().UnixNano()
3430 popr := math_rand.New(math_rand.NewSource(seed))
3431 p := NewPopulatedNinOptNativeDefault(popr, false)
3432 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3433 if err != nil {
3434 t.Fatalf("seed = %d, err = %v", seed, err)
3435 }
3436 msg := &NinOptNativeDefault{}
3437 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3438 t.Fatalf("seed = %d, err = %v", seed, err)
3439 }
3440 littlefuzz := make([]byte, len(dAtA))
3441 copy(littlefuzz, dAtA)
3442 for i := range dAtA {
3443 dAtA[i] = byte(popr.Intn(256))
3444 }
3445 if err := p.VerboseEqual(msg); err != nil {
3446 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3447 }
3448 if !p.Equal(msg) {
3449 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3450 }
3451 if len(littlefuzz) > 0 {
3452 fuzzamount := 100
3453 for i := 0; i < fuzzamount; i++ {
3454 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3455 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3456 }
3457
3458 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3459 }
3460 }
3461
3462 func BenchmarkNinOptNativeDefaultProtoMarshal(b *testing.B) {
3463 popr := math_rand.New(math_rand.NewSource(616))
3464 total := 0
3465 pops := make([]*NinOptNativeDefault, 10000)
3466 for i := 0; i < 10000; i++ {
3467 pops[i] = NewPopulatedNinOptNativeDefault(popr, false)
3468 }
3469 b.ResetTimer()
3470 for i := 0; i < b.N; i++ {
3471 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3472 if err != nil {
3473 panic(err)
3474 }
3475 total += len(dAtA)
3476 }
3477 b.SetBytes(int64(total / b.N))
3478 }
3479
3480 func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) {
3481 popr := math_rand.New(math_rand.NewSource(616))
3482 total := 0
3483 datas := make([][]byte, 10000)
3484 for i := 0; i < 10000; i++ {
3485 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeDefault(popr, false))
3486 if err != nil {
3487 panic(err)
3488 }
3489 datas[i] = dAtA
3490 }
3491 msg := &NinOptNativeDefault{}
3492 b.ResetTimer()
3493 for i := 0; i < b.N; i++ {
3494 total += len(datas[i%10000])
3495 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3496 panic(err)
3497 }
3498 }
3499 b.SetBytes(int64(total / b.N))
3500 }
3501
3502 func TestCustomContainerProto(t *testing.T) {
3503 seed := time.Now().UnixNano()
3504 popr := math_rand.New(math_rand.NewSource(seed))
3505 p := NewPopulatedCustomContainer(popr, false)
3506 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3507 if err != nil {
3508 t.Fatalf("seed = %d, err = %v", seed, err)
3509 }
3510 msg := &CustomContainer{}
3511 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3512 t.Fatalf("seed = %d, err = %v", seed, err)
3513 }
3514 littlefuzz := make([]byte, len(dAtA))
3515 copy(littlefuzz, dAtA)
3516 for i := range dAtA {
3517 dAtA[i] = byte(popr.Intn(256))
3518 }
3519 if err := p.VerboseEqual(msg); err != nil {
3520 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3521 }
3522 if !p.Equal(msg) {
3523 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3524 }
3525 if len(littlefuzz) > 0 {
3526 fuzzamount := 100
3527 for i := 0; i < fuzzamount; i++ {
3528 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3529 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3530 }
3531
3532 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3533 }
3534 }
3535
3536 func BenchmarkCustomContainerProtoMarshal(b *testing.B) {
3537 popr := math_rand.New(math_rand.NewSource(616))
3538 total := 0
3539 pops := make([]*CustomContainer, 10000)
3540 for i := 0; i < 10000; i++ {
3541 pops[i] = NewPopulatedCustomContainer(popr, false)
3542 }
3543 b.ResetTimer()
3544 for i := 0; i < b.N; i++ {
3545 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3546 if err != nil {
3547 panic(err)
3548 }
3549 total += len(dAtA)
3550 }
3551 b.SetBytes(int64(total / b.N))
3552 }
3553
3554 func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) {
3555 popr := math_rand.New(math_rand.NewSource(616))
3556 total := 0
3557 datas := make([][]byte, 10000)
3558 for i := 0; i < 10000; i++ {
3559 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomContainer(popr, false))
3560 if err != nil {
3561 panic(err)
3562 }
3563 datas[i] = dAtA
3564 }
3565 msg := &CustomContainer{}
3566 b.ResetTimer()
3567 for i := 0; i < b.N; i++ {
3568 total += len(datas[i%10000])
3569 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3570 panic(err)
3571 }
3572 }
3573 b.SetBytes(int64(total / b.N))
3574 }
3575
3576 func TestCustomNameNidOptNativeProto(t *testing.T) {
3577 seed := time.Now().UnixNano()
3578 popr := math_rand.New(math_rand.NewSource(seed))
3579 p := NewPopulatedCustomNameNidOptNative(popr, false)
3580 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3581 if err != nil {
3582 t.Fatalf("seed = %d, err = %v", seed, err)
3583 }
3584 msg := &CustomNameNidOptNative{}
3585 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3586 t.Fatalf("seed = %d, err = %v", seed, err)
3587 }
3588 littlefuzz := make([]byte, len(dAtA))
3589 copy(littlefuzz, dAtA)
3590 for i := range dAtA {
3591 dAtA[i] = byte(popr.Intn(256))
3592 }
3593 if err := p.VerboseEqual(msg); err != nil {
3594 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3595 }
3596 if !p.Equal(msg) {
3597 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3598 }
3599 if len(littlefuzz) > 0 {
3600 fuzzamount := 100
3601 for i := 0; i < fuzzamount; i++ {
3602 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3603 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3604 }
3605
3606 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3607 }
3608 }
3609
3610 func BenchmarkCustomNameNidOptNativeProtoMarshal(b *testing.B) {
3611 popr := math_rand.New(math_rand.NewSource(616))
3612 total := 0
3613 pops := make([]*CustomNameNidOptNative, 10000)
3614 for i := 0; i < 10000; i++ {
3615 pops[i] = NewPopulatedCustomNameNidOptNative(popr, false)
3616 }
3617 b.ResetTimer()
3618 for i := 0; i < b.N; i++ {
3619 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3620 if err != nil {
3621 panic(err)
3622 }
3623 total += len(dAtA)
3624 }
3625 b.SetBytes(int64(total / b.N))
3626 }
3627
3628 func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) {
3629 popr := math_rand.New(math_rand.NewSource(616))
3630 total := 0
3631 datas := make([][]byte, 10000)
3632 for i := 0; i < 10000; i++ {
3633 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNidOptNative(popr, false))
3634 if err != nil {
3635 panic(err)
3636 }
3637 datas[i] = dAtA
3638 }
3639 msg := &CustomNameNidOptNative{}
3640 b.ResetTimer()
3641 for i := 0; i < b.N; i++ {
3642 total += len(datas[i%10000])
3643 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3644 panic(err)
3645 }
3646 }
3647 b.SetBytes(int64(total / b.N))
3648 }
3649
3650 func TestCustomNameNinOptNativeProto(t *testing.T) {
3651 seed := time.Now().UnixNano()
3652 popr := math_rand.New(math_rand.NewSource(seed))
3653 p := NewPopulatedCustomNameNinOptNative(popr, false)
3654 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3655 if err != nil {
3656 t.Fatalf("seed = %d, err = %v", seed, err)
3657 }
3658 msg := &CustomNameNinOptNative{}
3659 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3660 t.Fatalf("seed = %d, err = %v", seed, err)
3661 }
3662 littlefuzz := make([]byte, len(dAtA))
3663 copy(littlefuzz, dAtA)
3664 for i := range dAtA {
3665 dAtA[i] = byte(popr.Intn(256))
3666 }
3667 if err := p.VerboseEqual(msg); err != nil {
3668 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3669 }
3670 if !p.Equal(msg) {
3671 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3672 }
3673 if len(littlefuzz) > 0 {
3674 fuzzamount := 100
3675 for i := 0; i < fuzzamount; i++ {
3676 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3677 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3678 }
3679
3680 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3681 }
3682 }
3683
3684 func BenchmarkCustomNameNinOptNativeProtoMarshal(b *testing.B) {
3685 popr := math_rand.New(math_rand.NewSource(616))
3686 total := 0
3687 pops := make([]*CustomNameNinOptNative, 10000)
3688 for i := 0; i < 10000; i++ {
3689 pops[i] = NewPopulatedCustomNameNinOptNative(popr, false)
3690 }
3691 b.ResetTimer()
3692 for i := 0; i < b.N; i++ {
3693 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3694 if err != nil {
3695 panic(err)
3696 }
3697 total += len(dAtA)
3698 }
3699 b.SetBytes(int64(total / b.N))
3700 }
3701
3702 func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) {
3703 popr := math_rand.New(math_rand.NewSource(616))
3704 total := 0
3705 datas := make([][]byte, 10000)
3706 for i := 0; i < 10000; i++ {
3707 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinOptNative(popr, false))
3708 if err != nil {
3709 panic(err)
3710 }
3711 datas[i] = dAtA
3712 }
3713 msg := &CustomNameNinOptNative{}
3714 b.ResetTimer()
3715 for i := 0; i < b.N; i++ {
3716 total += len(datas[i%10000])
3717 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3718 panic(err)
3719 }
3720 }
3721 b.SetBytes(int64(total / b.N))
3722 }
3723
3724 func TestCustomNameNinRepNativeProto(t *testing.T) {
3725 seed := time.Now().UnixNano()
3726 popr := math_rand.New(math_rand.NewSource(seed))
3727 p := NewPopulatedCustomNameNinRepNative(popr, false)
3728 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3729 if err != nil {
3730 t.Fatalf("seed = %d, err = %v", seed, err)
3731 }
3732 msg := &CustomNameNinRepNative{}
3733 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3734 t.Fatalf("seed = %d, err = %v", seed, err)
3735 }
3736 littlefuzz := make([]byte, len(dAtA))
3737 copy(littlefuzz, dAtA)
3738 for i := range dAtA {
3739 dAtA[i] = byte(popr.Intn(256))
3740 }
3741 if err := p.VerboseEqual(msg); err != nil {
3742 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3743 }
3744 if !p.Equal(msg) {
3745 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3746 }
3747 if len(littlefuzz) > 0 {
3748 fuzzamount := 100
3749 for i := 0; i < fuzzamount; i++ {
3750 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3751 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3752 }
3753
3754 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3755 }
3756 }
3757
3758 func BenchmarkCustomNameNinRepNativeProtoMarshal(b *testing.B) {
3759 popr := math_rand.New(math_rand.NewSource(616))
3760 total := 0
3761 pops := make([]*CustomNameNinRepNative, 10000)
3762 for i := 0; i < 10000; i++ {
3763 pops[i] = NewPopulatedCustomNameNinRepNative(popr, false)
3764 }
3765 b.ResetTimer()
3766 for i := 0; i < b.N; i++ {
3767 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3768 if err != nil {
3769 panic(err)
3770 }
3771 total += len(dAtA)
3772 }
3773 b.SetBytes(int64(total / b.N))
3774 }
3775
3776 func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) {
3777 popr := math_rand.New(math_rand.NewSource(616))
3778 total := 0
3779 datas := make([][]byte, 10000)
3780 for i := 0; i < 10000; i++ {
3781 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinRepNative(popr, false))
3782 if err != nil {
3783 panic(err)
3784 }
3785 datas[i] = dAtA
3786 }
3787 msg := &CustomNameNinRepNative{}
3788 b.ResetTimer()
3789 for i := 0; i < b.N; i++ {
3790 total += len(datas[i%10000])
3791 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3792 panic(err)
3793 }
3794 }
3795 b.SetBytes(int64(total / b.N))
3796 }
3797
3798 func TestCustomNameNinStructProto(t *testing.T) {
3799 seed := time.Now().UnixNano()
3800 popr := math_rand.New(math_rand.NewSource(seed))
3801 p := NewPopulatedCustomNameNinStruct(popr, false)
3802 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3803 if err != nil {
3804 t.Fatalf("seed = %d, err = %v", seed, err)
3805 }
3806 msg := &CustomNameNinStruct{}
3807 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3808 t.Fatalf("seed = %d, err = %v", seed, err)
3809 }
3810 littlefuzz := make([]byte, len(dAtA))
3811 copy(littlefuzz, dAtA)
3812 for i := range dAtA {
3813 dAtA[i] = byte(popr.Intn(256))
3814 }
3815 if err := p.VerboseEqual(msg); err != nil {
3816 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3817 }
3818 if !p.Equal(msg) {
3819 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3820 }
3821 if len(littlefuzz) > 0 {
3822 fuzzamount := 100
3823 for i := 0; i < fuzzamount; i++ {
3824 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3825 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3826 }
3827
3828 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3829 }
3830 }
3831
3832 func BenchmarkCustomNameNinStructProtoMarshal(b *testing.B) {
3833 popr := math_rand.New(math_rand.NewSource(616))
3834 total := 0
3835 pops := make([]*CustomNameNinStruct, 10000)
3836 for i := 0; i < 10000; i++ {
3837 pops[i] = NewPopulatedCustomNameNinStruct(popr, false)
3838 }
3839 b.ResetTimer()
3840 for i := 0; i < b.N; i++ {
3841 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3842 if err != nil {
3843 panic(err)
3844 }
3845 total += len(dAtA)
3846 }
3847 b.SetBytes(int64(total / b.N))
3848 }
3849
3850 func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) {
3851 popr := math_rand.New(math_rand.NewSource(616))
3852 total := 0
3853 datas := make([][]byte, 10000)
3854 for i := 0; i < 10000; i++ {
3855 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinStruct(popr, false))
3856 if err != nil {
3857 panic(err)
3858 }
3859 datas[i] = dAtA
3860 }
3861 msg := &CustomNameNinStruct{}
3862 b.ResetTimer()
3863 for i := 0; i < b.N; i++ {
3864 total += len(datas[i%10000])
3865 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3866 panic(err)
3867 }
3868 }
3869 b.SetBytes(int64(total / b.N))
3870 }
3871
3872 func TestCustomNameCustomTypeProto(t *testing.T) {
3873 seed := time.Now().UnixNano()
3874 popr := math_rand.New(math_rand.NewSource(seed))
3875 p := NewPopulatedCustomNameCustomType(popr, false)
3876 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3877 if err != nil {
3878 t.Fatalf("seed = %d, err = %v", seed, err)
3879 }
3880 msg := &CustomNameCustomType{}
3881 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3882 t.Fatalf("seed = %d, err = %v", seed, err)
3883 }
3884 littlefuzz := make([]byte, len(dAtA))
3885 copy(littlefuzz, dAtA)
3886 for i := range dAtA {
3887 dAtA[i] = byte(popr.Intn(256))
3888 }
3889 if err := p.VerboseEqual(msg); err != nil {
3890 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3891 }
3892 if !p.Equal(msg) {
3893 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3894 }
3895 if len(littlefuzz) > 0 {
3896 fuzzamount := 100
3897 for i := 0; i < fuzzamount; i++ {
3898 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3899 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3900 }
3901
3902 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3903 }
3904 }
3905
3906 func BenchmarkCustomNameCustomTypeProtoMarshal(b *testing.B) {
3907 popr := math_rand.New(math_rand.NewSource(616))
3908 total := 0
3909 pops := make([]*CustomNameCustomType, 10000)
3910 for i := 0; i < 10000; i++ {
3911 pops[i] = NewPopulatedCustomNameCustomType(popr, false)
3912 }
3913 b.ResetTimer()
3914 for i := 0; i < b.N; i++ {
3915 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3916 if err != nil {
3917 panic(err)
3918 }
3919 total += len(dAtA)
3920 }
3921 b.SetBytes(int64(total / b.N))
3922 }
3923
3924 func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) {
3925 popr := math_rand.New(math_rand.NewSource(616))
3926 total := 0
3927 datas := make([][]byte, 10000)
3928 for i := 0; i < 10000; i++ {
3929 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameCustomType(popr, false))
3930 if err != nil {
3931 panic(err)
3932 }
3933 datas[i] = dAtA
3934 }
3935 msg := &CustomNameCustomType{}
3936 b.ResetTimer()
3937 for i := 0; i < b.N; i++ {
3938 total += len(datas[i%10000])
3939 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
3940 panic(err)
3941 }
3942 }
3943 b.SetBytes(int64(total / b.N))
3944 }
3945
3946 func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) {
3947 seed := time.Now().UnixNano()
3948 popr := math_rand.New(math_rand.NewSource(seed))
3949 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
3950 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
3951 if err != nil {
3952 t.Fatalf("seed = %d, err = %v", seed, err)
3953 }
3954 msg := &CustomNameNinEmbeddedStructUnion{}
3955 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
3956 t.Fatalf("seed = %d, err = %v", seed, err)
3957 }
3958 littlefuzz := make([]byte, len(dAtA))
3959 copy(littlefuzz, dAtA)
3960 for i := range dAtA {
3961 dAtA[i] = byte(popr.Intn(256))
3962 }
3963 if err := p.VerboseEqual(msg); err != nil {
3964 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
3965 }
3966 if !p.Equal(msg) {
3967 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
3968 }
3969 if len(littlefuzz) > 0 {
3970 fuzzamount := 100
3971 for i := 0; i < fuzzamount; i++ {
3972 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
3973 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
3974 }
3975
3976 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
3977 }
3978 }
3979
3980 func BenchmarkCustomNameNinEmbeddedStructUnionProtoMarshal(b *testing.B) {
3981 popr := math_rand.New(math_rand.NewSource(616))
3982 total := 0
3983 pops := make([]*CustomNameNinEmbeddedStructUnion, 10000)
3984 for i := 0; i < 10000; i++ {
3985 pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
3986 }
3987 b.ResetTimer()
3988 for i := 0; i < b.N; i++ {
3989 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
3990 if err != nil {
3991 panic(err)
3992 }
3993 total += len(dAtA)
3994 }
3995 b.SetBytes(int64(total / b.N))
3996 }
3997
3998 func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) {
3999 popr := math_rand.New(math_rand.NewSource(616))
4000 total := 0
4001 datas := make([][]byte, 10000)
4002 for i := 0; i < 10000; i++ {
4003 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false))
4004 if err != nil {
4005 panic(err)
4006 }
4007 datas[i] = dAtA
4008 }
4009 msg := &CustomNameNinEmbeddedStructUnion{}
4010 b.ResetTimer()
4011 for i := 0; i < b.N; i++ {
4012 total += len(datas[i%10000])
4013 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4014 panic(err)
4015 }
4016 }
4017 b.SetBytes(int64(total / b.N))
4018 }
4019
4020 func TestCustomNameEnumProto(t *testing.T) {
4021 seed := time.Now().UnixNano()
4022 popr := math_rand.New(math_rand.NewSource(seed))
4023 p := NewPopulatedCustomNameEnum(popr, false)
4024 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4025 if err != nil {
4026 t.Fatalf("seed = %d, err = %v", seed, err)
4027 }
4028 msg := &CustomNameEnum{}
4029 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4030 t.Fatalf("seed = %d, err = %v", seed, err)
4031 }
4032 littlefuzz := make([]byte, len(dAtA))
4033 copy(littlefuzz, dAtA)
4034 for i := range dAtA {
4035 dAtA[i] = byte(popr.Intn(256))
4036 }
4037 if err := p.VerboseEqual(msg); err != nil {
4038 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4039 }
4040 if !p.Equal(msg) {
4041 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4042 }
4043 if len(littlefuzz) > 0 {
4044 fuzzamount := 100
4045 for i := 0; i < fuzzamount; i++ {
4046 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4047 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4048 }
4049
4050 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4051 }
4052 }
4053
4054 func BenchmarkCustomNameEnumProtoMarshal(b *testing.B) {
4055 popr := math_rand.New(math_rand.NewSource(616))
4056 total := 0
4057 pops := make([]*CustomNameEnum, 10000)
4058 for i := 0; i < 10000; i++ {
4059 pops[i] = NewPopulatedCustomNameEnum(popr, false)
4060 }
4061 b.ResetTimer()
4062 for i := 0; i < b.N; i++ {
4063 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4064 if err != nil {
4065 panic(err)
4066 }
4067 total += len(dAtA)
4068 }
4069 b.SetBytes(int64(total / b.N))
4070 }
4071
4072 func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) {
4073 popr := math_rand.New(math_rand.NewSource(616))
4074 total := 0
4075 datas := make([][]byte, 10000)
4076 for i := 0; i < 10000; i++ {
4077 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameEnum(popr, false))
4078 if err != nil {
4079 panic(err)
4080 }
4081 datas[i] = dAtA
4082 }
4083 msg := &CustomNameEnum{}
4084 b.ResetTimer()
4085 for i := 0; i < b.N; i++ {
4086 total += len(datas[i%10000])
4087 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4088 panic(err)
4089 }
4090 }
4091 b.SetBytes(int64(total / b.N))
4092 }
4093
4094 func TestNoExtensionsMapProto(t *testing.T) {
4095 seed := time.Now().UnixNano()
4096 popr := math_rand.New(math_rand.NewSource(seed))
4097 p := NewPopulatedNoExtensionsMap(popr, false)
4098 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4099 if err != nil {
4100 t.Fatalf("seed = %d, err = %v", seed, err)
4101 }
4102 msg := &NoExtensionsMap{}
4103 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4104 t.Fatalf("seed = %d, err = %v", seed, err)
4105 }
4106 littlefuzz := make([]byte, len(dAtA))
4107 copy(littlefuzz, dAtA)
4108 for i := range dAtA {
4109 dAtA[i] = byte(popr.Intn(256))
4110 }
4111 if err := p.VerboseEqual(msg); err != nil {
4112 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4113 }
4114 if !p.Equal(msg) {
4115 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4116 }
4117 if len(littlefuzz) > 0 {
4118 fuzzamount := 100
4119 for i := 0; i < fuzzamount; i++ {
4120 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4121 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4122 }
4123
4124 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4125 }
4126 }
4127
4128 func BenchmarkNoExtensionsMapProtoMarshal(b *testing.B) {
4129 popr := math_rand.New(math_rand.NewSource(616))
4130 total := 0
4131 pops := make([]*NoExtensionsMap, 10000)
4132 for i := 0; i < 10000; i++ {
4133 pops[i] = NewPopulatedNoExtensionsMap(popr, false)
4134 }
4135 b.ResetTimer()
4136 for i := 0; i < b.N; i++ {
4137 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4138 if err != nil {
4139 panic(err)
4140 }
4141 total += len(dAtA)
4142 }
4143 b.SetBytes(int64(total / b.N))
4144 }
4145
4146 func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) {
4147 popr := math_rand.New(math_rand.NewSource(616))
4148 total := 0
4149 datas := make([][]byte, 10000)
4150 for i := 0; i < 10000; i++ {
4151 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNoExtensionsMap(popr, false))
4152 if err != nil {
4153 panic(err)
4154 }
4155 datas[i] = dAtA
4156 }
4157 msg := &NoExtensionsMap{}
4158 b.ResetTimer()
4159 for i := 0; i < b.N; i++ {
4160 total += len(datas[i%10000])
4161 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4162 panic(err)
4163 }
4164 }
4165 b.SetBytes(int64(total / b.N))
4166 }
4167
4168 func TestUnrecognizedProto(t *testing.T) {
4169 seed := time.Now().UnixNano()
4170 popr := math_rand.New(math_rand.NewSource(seed))
4171 p := NewPopulatedUnrecognized(popr, false)
4172 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4173 if err != nil {
4174 t.Fatalf("seed = %d, err = %v", seed, err)
4175 }
4176 msg := &Unrecognized{}
4177 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4178 t.Fatalf("seed = %d, err = %v", seed, err)
4179 }
4180 littlefuzz := make([]byte, len(dAtA))
4181 copy(littlefuzz, dAtA)
4182 for i := range dAtA {
4183 dAtA[i] = byte(popr.Intn(256))
4184 }
4185 if err := p.VerboseEqual(msg); err != nil {
4186 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4187 }
4188 if !p.Equal(msg) {
4189 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4190 }
4191 if len(littlefuzz) > 0 {
4192 fuzzamount := 100
4193 for i := 0; i < fuzzamount; i++ {
4194 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4195 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4196 }
4197
4198 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4199 }
4200 }
4201
4202 func BenchmarkUnrecognizedProtoMarshal(b *testing.B) {
4203 popr := math_rand.New(math_rand.NewSource(616))
4204 total := 0
4205 pops := make([]*Unrecognized, 10000)
4206 for i := 0; i < 10000; i++ {
4207 pops[i] = NewPopulatedUnrecognized(popr, false)
4208 }
4209 b.ResetTimer()
4210 for i := 0; i < b.N; i++ {
4211 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4212 if err != nil {
4213 panic(err)
4214 }
4215 total += len(dAtA)
4216 }
4217 b.SetBytes(int64(total / b.N))
4218 }
4219
4220 func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) {
4221 popr := math_rand.New(math_rand.NewSource(616))
4222 total := 0
4223 datas := make([][]byte, 10000)
4224 for i := 0; i < 10000; i++ {
4225 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognized(popr, false))
4226 if err != nil {
4227 panic(err)
4228 }
4229 datas[i] = dAtA
4230 }
4231 msg := &Unrecognized{}
4232 b.ResetTimer()
4233 for i := 0; i < b.N; i++ {
4234 total += len(datas[i%10000])
4235 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4236 panic(err)
4237 }
4238 }
4239 b.SetBytes(int64(total / b.N))
4240 }
4241
4242 func TestUnrecognizedWithInnerProto(t *testing.T) {
4243 seed := time.Now().UnixNano()
4244 popr := math_rand.New(math_rand.NewSource(seed))
4245 p := NewPopulatedUnrecognizedWithInner(popr, false)
4246 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4247 if err != nil {
4248 t.Fatalf("seed = %d, err = %v", seed, err)
4249 }
4250 msg := &UnrecognizedWithInner{}
4251 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4252 t.Fatalf("seed = %d, err = %v", seed, err)
4253 }
4254 littlefuzz := make([]byte, len(dAtA))
4255 copy(littlefuzz, dAtA)
4256 for i := range dAtA {
4257 dAtA[i] = byte(popr.Intn(256))
4258 }
4259 if err := p.VerboseEqual(msg); err != nil {
4260 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4261 }
4262 if !p.Equal(msg) {
4263 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4264 }
4265 if len(littlefuzz) > 0 {
4266 fuzzamount := 100
4267 for i := 0; i < fuzzamount; i++ {
4268 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4269 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4270 }
4271
4272 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4273 }
4274 }
4275
4276 func BenchmarkUnrecognizedWithInnerProtoMarshal(b *testing.B) {
4277 popr := math_rand.New(math_rand.NewSource(616))
4278 total := 0
4279 pops := make([]*UnrecognizedWithInner, 10000)
4280 for i := 0; i < 10000; i++ {
4281 pops[i] = NewPopulatedUnrecognizedWithInner(popr, false)
4282 }
4283 b.ResetTimer()
4284 for i := 0; i < b.N; i++ {
4285 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4286 if err != nil {
4287 panic(err)
4288 }
4289 total += len(dAtA)
4290 }
4291 b.SetBytes(int64(total / b.N))
4292 }
4293
4294 func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) {
4295 popr := math_rand.New(math_rand.NewSource(616))
4296 total := 0
4297 datas := make([][]byte, 10000)
4298 for i := 0; i < 10000; i++ {
4299 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner(popr, false))
4300 if err != nil {
4301 panic(err)
4302 }
4303 datas[i] = dAtA
4304 }
4305 msg := &UnrecognizedWithInner{}
4306 b.ResetTimer()
4307 for i := 0; i < b.N; i++ {
4308 total += len(datas[i%10000])
4309 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4310 panic(err)
4311 }
4312 }
4313 b.SetBytes(int64(total / b.N))
4314 }
4315
4316 func TestUnrecognizedWithInner_InnerProto(t *testing.T) {
4317 seed := time.Now().UnixNano()
4318 popr := math_rand.New(math_rand.NewSource(seed))
4319 p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
4320 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4321 if err != nil {
4322 t.Fatalf("seed = %d, err = %v", seed, err)
4323 }
4324 msg := &UnrecognizedWithInner_Inner{}
4325 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4326 t.Fatalf("seed = %d, err = %v", seed, err)
4327 }
4328 littlefuzz := make([]byte, len(dAtA))
4329 copy(littlefuzz, dAtA)
4330 for i := range dAtA {
4331 dAtA[i] = byte(popr.Intn(256))
4332 }
4333 if err := p.VerboseEqual(msg); err != nil {
4334 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4335 }
4336 if !p.Equal(msg) {
4337 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4338 }
4339 if len(littlefuzz) > 0 {
4340 fuzzamount := 100
4341 for i := 0; i < fuzzamount; i++ {
4342 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4343 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4344 }
4345
4346 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4347 }
4348 }
4349
4350 func BenchmarkUnrecognizedWithInner_InnerProtoMarshal(b *testing.B) {
4351 popr := math_rand.New(math_rand.NewSource(616))
4352 total := 0
4353 pops := make([]*UnrecognizedWithInner_Inner, 10000)
4354 for i := 0; i < 10000; i++ {
4355 pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false)
4356 }
4357 b.ResetTimer()
4358 for i := 0; i < b.N; i++ {
4359 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4360 if err != nil {
4361 panic(err)
4362 }
4363 total += len(dAtA)
4364 }
4365 b.SetBytes(int64(total / b.N))
4366 }
4367
4368 func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) {
4369 popr := math_rand.New(math_rand.NewSource(616))
4370 total := 0
4371 datas := make([][]byte, 10000)
4372 for i := 0; i < 10000; i++ {
4373 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner_Inner(popr, false))
4374 if err != nil {
4375 panic(err)
4376 }
4377 datas[i] = dAtA
4378 }
4379 msg := &UnrecognizedWithInner_Inner{}
4380 b.ResetTimer()
4381 for i := 0; i < b.N; i++ {
4382 total += len(datas[i%10000])
4383 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4384 panic(err)
4385 }
4386 }
4387 b.SetBytes(int64(total / b.N))
4388 }
4389
4390 func TestUnrecognizedWithEmbedProto(t *testing.T) {
4391 seed := time.Now().UnixNano()
4392 popr := math_rand.New(math_rand.NewSource(seed))
4393 p := NewPopulatedUnrecognizedWithEmbed(popr, false)
4394 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4395 if err != nil {
4396 t.Fatalf("seed = %d, err = %v", seed, err)
4397 }
4398 msg := &UnrecognizedWithEmbed{}
4399 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4400 t.Fatalf("seed = %d, err = %v", seed, err)
4401 }
4402 littlefuzz := make([]byte, len(dAtA))
4403 copy(littlefuzz, dAtA)
4404 for i := range dAtA {
4405 dAtA[i] = byte(popr.Intn(256))
4406 }
4407 if err := p.VerboseEqual(msg); err != nil {
4408 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4409 }
4410 if !p.Equal(msg) {
4411 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4412 }
4413 if len(littlefuzz) > 0 {
4414 fuzzamount := 100
4415 for i := 0; i < fuzzamount; i++ {
4416 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4417 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4418 }
4419
4420 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4421 }
4422 }
4423
4424 func BenchmarkUnrecognizedWithEmbedProtoMarshal(b *testing.B) {
4425 popr := math_rand.New(math_rand.NewSource(616))
4426 total := 0
4427 pops := make([]*UnrecognizedWithEmbed, 10000)
4428 for i := 0; i < 10000; i++ {
4429 pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false)
4430 }
4431 b.ResetTimer()
4432 for i := 0; i < b.N; i++ {
4433 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4434 if err != nil {
4435 panic(err)
4436 }
4437 total += len(dAtA)
4438 }
4439 b.SetBytes(int64(total / b.N))
4440 }
4441
4442 func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) {
4443 popr := math_rand.New(math_rand.NewSource(616))
4444 total := 0
4445 datas := make([][]byte, 10000)
4446 for i := 0; i < 10000; i++ {
4447 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed(popr, false))
4448 if err != nil {
4449 panic(err)
4450 }
4451 datas[i] = dAtA
4452 }
4453 msg := &UnrecognizedWithEmbed{}
4454 b.ResetTimer()
4455 for i := 0; i < b.N; i++ {
4456 total += len(datas[i%10000])
4457 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4458 panic(err)
4459 }
4460 }
4461 b.SetBytes(int64(total / b.N))
4462 }
4463
4464 func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) {
4465 seed := time.Now().UnixNano()
4466 popr := math_rand.New(math_rand.NewSource(seed))
4467 p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
4468 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4469 if err != nil {
4470 t.Fatalf("seed = %d, err = %v", seed, err)
4471 }
4472 msg := &UnrecognizedWithEmbed_Embedded{}
4473 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4474 t.Fatalf("seed = %d, err = %v", seed, err)
4475 }
4476 littlefuzz := make([]byte, len(dAtA))
4477 copy(littlefuzz, dAtA)
4478 for i := range dAtA {
4479 dAtA[i] = byte(popr.Intn(256))
4480 }
4481 if err := p.VerboseEqual(msg); err != nil {
4482 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4483 }
4484 if !p.Equal(msg) {
4485 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4486 }
4487 if len(littlefuzz) > 0 {
4488 fuzzamount := 100
4489 for i := 0; i < fuzzamount; i++ {
4490 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4491 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4492 }
4493
4494 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4495 }
4496 }
4497
4498 func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoMarshal(b *testing.B) {
4499 popr := math_rand.New(math_rand.NewSource(616))
4500 total := 0
4501 pops := make([]*UnrecognizedWithEmbed_Embedded, 10000)
4502 for i := 0; i < 10000; i++ {
4503 pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
4504 }
4505 b.ResetTimer()
4506 for i := 0; i < b.N; i++ {
4507 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4508 if err != nil {
4509 panic(err)
4510 }
4511 total += len(dAtA)
4512 }
4513 b.SetBytes(int64(total / b.N))
4514 }
4515
4516 func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) {
4517 popr := math_rand.New(math_rand.NewSource(616))
4518 total := 0
4519 datas := make([][]byte, 10000)
4520 for i := 0; i < 10000; i++ {
4521 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false))
4522 if err != nil {
4523 panic(err)
4524 }
4525 datas[i] = dAtA
4526 }
4527 msg := &UnrecognizedWithEmbed_Embedded{}
4528 b.ResetTimer()
4529 for i := 0; i < b.N; i++ {
4530 total += len(datas[i%10000])
4531 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4532 panic(err)
4533 }
4534 }
4535 b.SetBytes(int64(total / b.N))
4536 }
4537
4538 func TestNodeProto(t *testing.T) {
4539 seed := time.Now().UnixNano()
4540 popr := math_rand.New(math_rand.NewSource(seed))
4541 p := NewPopulatedNode(popr, false)
4542 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4543 if err != nil {
4544 t.Fatalf("seed = %d, err = %v", seed, err)
4545 }
4546 msg := &Node{}
4547 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4548 t.Fatalf("seed = %d, err = %v", seed, err)
4549 }
4550 littlefuzz := make([]byte, len(dAtA))
4551 copy(littlefuzz, dAtA)
4552 for i := range dAtA {
4553 dAtA[i] = byte(popr.Intn(256))
4554 }
4555 if err := p.VerboseEqual(msg); err != nil {
4556 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4557 }
4558 if !p.Equal(msg) {
4559 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4560 }
4561 if len(littlefuzz) > 0 {
4562 fuzzamount := 100
4563 for i := 0; i < fuzzamount; i++ {
4564 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4565 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4566 }
4567
4568 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4569 }
4570 }
4571
4572 func BenchmarkNodeProtoMarshal(b *testing.B) {
4573 popr := math_rand.New(math_rand.NewSource(616))
4574 total := 0
4575 pops := make([]*Node, 10000)
4576 for i := 0; i < 10000; i++ {
4577 pops[i] = NewPopulatedNode(popr, false)
4578 }
4579 b.ResetTimer()
4580 for i := 0; i < b.N; i++ {
4581 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4582 if err != nil {
4583 panic(err)
4584 }
4585 total += len(dAtA)
4586 }
4587 b.SetBytes(int64(total / b.N))
4588 }
4589
4590 func BenchmarkNodeProtoUnmarshal(b *testing.B) {
4591 popr := math_rand.New(math_rand.NewSource(616))
4592 total := 0
4593 datas := make([][]byte, 10000)
4594 for i := 0; i < 10000; i++ {
4595 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNode(popr, false))
4596 if err != nil {
4597 panic(err)
4598 }
4599 datas[i] = dAtA
4600 }
4601 msg := &Node{}
4602 b.ResetTimer()
4603 for i := 0; i < b.N; i++ {
4604 total += len(datas[i%10000])
4605 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4606 panic(err)
4607 }
4608 }
4609 b.SetBytes(int64(total / b.N))
4610 }
4611
4612 func TestNonByteCustomTypeProto(t *testing.T) {
4613 seed := time.Now().UnixNano()
4614 popr := math_rand.New(math_rand.NewSource(seed))
4615 p := NewPopulatedNonByteCustomType(popr, false)
4616 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4617 if err != nil {
4618 t.Fatalf("seed = %d, err = %v", seed, err)
4619 }
4620 msg := &NonByteCustomType{}
4621 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4622 t.Fatalf("seed = %d, err = %v", seed, err)
4623 }
4624 littlefuzz := make([]byte, len(dAtA))
4625 copy(littlefuzz, dAtA)
4626 for i := range dAtA {
4627 dAtA[i] = byte(popr.Intn(256))
4628 }
4629 if err := p.VerboseEqual(msg); err != nil {
4630 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4631 }
4632 if !p.Equal(msg) {
4633 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4634 }
4635 if len(littlefuzz) > 0 {
4636 fuzzamount := 100
4637 for i := 0; i < fuzzamount; i++ {
4638 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4639 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4640 }
4641
4642 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4643 }
4644 }
4645
4646 func BenchmarkNonByteCustomTypeProtoMarshal(b *testing.B) {
4647 popr := math_rand.New(math_rand.NewSource(616))
4648 total := 0
4649 pops := make([]*NonByteCustomType, 10000)
4650 for i := 0; i < 10000; i++ {
4651 pops[i] = NewPopulatedNonByteCustomType(popr, false)
4652 }
4653 b.ResetTimer()
4654 for i := 0; i < b.N; i++ {
4655 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4656 if err != nil {
4657 panic(err)
4658 }
4659 total += len(dAtA)
4660 }
4661 b.SetBytes(int64(total / b.N))
4662 }
4663
4664 func BenchmarkNonByteCustomTypeProtoUnmarshal(b *testing.B) {
4665 popr := math_rand.New(math_rand.NewSource(616))
4666 total := 0
4667 datas := make([][]byte, 10000)
4668 for i := 0; i < 10000; i++ {
4669 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNonByteCustomType(popr, false))
4670 if err != nil {
4671 panic(err)
4672 }
4673 datas[i] = dAtA
4674 }
4675 msg := &NonByteCustomType{}
4676 b.ResetTimer()
4677 for i := 0; i < b.N; i++ {
4678 total += len(datas[i%10000])
4679 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4680 panic(err)
4681 }
4682 }
4683 b.SetBytes(int64(total / b.N))
4684 }
4685
4686 func TestNidOptNonByteCustomTypeProto(t *testing.T) {
4687 seed := time.Now().UnixNano()
4688 popr := math_rand.New(math_rand.NewSource(seed))
4689 p := NewPopulatedNidOptNonByteCustomType(popr, false)
4690 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4691 if err != nil {
4692 t.Fatalf("seed = %d, err = %v", seed, err)
4693 }
4694 msg := &NidOptNonByteCustomType{}
4695 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4696 t.Fatalf("seed = %d, err = %v", seed, err)
4697 }
4698 littlefuzz := make([]byte, len(dAtA))
4699 copy(littlefuzz, dAtA)
4700 for i := range dAtA {
4701 dAtA[i] = byte(popr.Intn(256))
4702 }
4703 if err := p.VerboseEqual(msg); err != nil {
4704 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4705 }
4706 if !p.Equal(msg) {
4707 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4708 }
4709 if len(littlefuzz) > 0 {
4710 fuzzamount := 100
4711 for i := 0; i < fuzzamount; i++ {
4712 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4713 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4714 }
4715
4716 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4717 }
4718 }
4719
4720 func BenchmarkNidOptNonByteCustomTypeProtoMarshal(b *testing.B) {
4721 popr := math_rand.New(math_rand.NewSource(616))
4722 total := 0
4723 pops := make([]*NidOptNonByteCustomType, 10000)
4724 for i := 0; i < 10000; i++ {
4725 pops[i] = NewPopulatedNidOptNonByteCustomType(popr, false)
4726 }
4727 b.ResetTimer()
4728 for i := 0; i < b.N; i++ {
4729 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4730 if err != nil {
4731 panic(err)
4732 }
4733 total += len(dAtA)
4734 }
4735 b.SetBytes(int64(total / b.N))
4736 }
4737
4738 func BenchmarkNidOptNonByteCustomTypeProtoUnmarshal(b *testing.B) {
4739 popr := math_rand.New(math_rand.NewSource(616))
4740 total := 0
4741 datas := make([][]byte, 10000)
4742 for i := 0; i < 10000; i++ {
4743 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNonByteCustomType(popr, false))
4744 if err != nil {
4745 panic(err)
4746 }
4747 datas[i] = dAtA
4748 }
4749 msg := &NidOptNonByteCustomType{}
4750 b.ResetTimer()
4751 for i := 0; i < b.N; i++ {
4752 total += len(datas[i%10000])
4753 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4754 panic(err)
4755 }
4756 }
4757 b.SetBytes(int64(total / b.N))
4758 }
4759
4760 func TestNinOptNonByteCustomTypeProto(t *testing.T) {
4761 seed := time.Now().UnixNano()
4762 popr := math_rand.New(math_rand.NewSource(seed))
4763 p := NewPopulatedNinOptNonByteCustomType(popr, false)
4764 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4765 if err != nil {
4766 t.Fatalf("seed = %d, err = %v", seed, err)
4767 }
4768 msg := &NinOptNonByteCustomType{}
4769 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4770 t.Fatalf("seed = %d, err = %v", seed, err)
4771 }
4772 littlefuzz := make([]byte, len(dAtA))
4773 copy(littlefuzz, dAtA)
4774 for i := range dAtA {
4775 dAtA[i] = byte(popr.Intn(256))
4776 }
4777 if err := p.VerboseEqual(msg); err != nil {
4778 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4779 }
4780 if !p.Equal(msg) {
4781 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4782 }
4783 if len(littlefuzz) > 0 {
4784 fuzzamount := 100
4785 for i := 0; i < fuzzamount; i++ {
4786 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4787 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4788 }
4789
4790 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4791 }
4792 }
4793
4794 func BenchmarkNinOptNonByteCustomTypeProtoMarshal(b *testing.B) {
4795 popr := math_rand.New(math_rand.NewSource(616))
4796 total := 0
4797 pops := make([]*NinOptNonByteCustomType, 10000)
4798 for i := 0; i < 10000; i++ {
4799 pops[i] = NewPopulatedNinOptNonByteCustomType(popr, false)
4800 }
4801 b.ResetTimer()
4802 for i := 0; i < b.N; i++ {
4803 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4804 if err != nil {
4805 panic(err)
4806 }
4807 total += len(dAtA)
4808 }
4809 b.SetBytes(int64(total / b.N))
4810 }
4811
4812 func BenchmarkNinOptNonByteCustomTypeProtoUnmarshal(b *testing.B) {
4813 popr := math_rand.New(math_rand.NewSource(616))
4814 total := 0
4815 datas := make([][]byte, 10000)
4816 for i := 0; i < 10000; i++ {
4817 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNonByteCustomType(popr, false))
4818 if err != nil {
4819 panic(err)
4820 }
4821 datas[i] = dAtA
4822 }
4823 msg := &NinOptNonByteCustomType{}
4824 b.ResetTimer()
4825 for i := 0; i < b.N; i++ {
4826 total += len(datas[i%10000])
4827 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4828 panic(err)
4829 }
4830 }
4831 b.SetBytes(int64(total / b.N))
4832 }
4833
4834 func TestNidRepNonByteCustomTypeProto(t *testing.T) {
4835 seed := time.Now().UnixNano()
4836 popr := math_rand.New(math_rand.NewSource(seed))
4837 p := NewPopulatedNidRepNonByteCustomType(popr, false)
4838 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4839 if err != nil {
4840 t.Fatalf("seed = %d, err = %v", seed, err)
4841 }
4842 msg := &NidRepNonByteCustomType{}
4843 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4844 t.Fatalf("seed = %d, err = %v", seed, err)
4845 }
4846 littlefuzz := make([]byte, len(dAtA))
4847 copy(littlefuzz, dAtA)
4848 for i := range dAtA {
4849 dAtA[i] = byte(popr.Intn(256))
4850 }
4851 if err := p.VerboseEqual(msg); err != nil {
4852 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4853 }
4854 if !p.Equal(msg) {
4855 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4856 }
4857 if len(littlefuzz) > 0 {
4858 fuzzamount := 100
4859 for i := 0; i < fuzzamount; i++ {
4860 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4861 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4862 }
4863
4864 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4865 }
4866 }
4867
4868 func BenchmarkNidRepNonByteCustomTypeProtoMarshal(b *testing.B) {
4869 popr := math_rand.New(math_rand.NewSource(616))
4870 total := 0
4871 pops := make([]*NidRepNonByteCustomType, 10000)
4872 for i := 0; i < 10000; i++ {
4873 pops[i] = NewPopulatedNidRepNonByteCustomType(popr, false)
4874 }
4875 b.ResetTimer()
4876 for i := 0; i < b.N; i++ {
4877 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4878 if err != nil {
4879 panic(err)
4880 }
4881 total += len(dAtA)
4882 }
4883 b.SetBytes(int64(total / b.N))
4884 }
4885
4886 func BenchmarkNidRepNonByteCustomTypeProtoUnmarshal(b *testing.B) {
4887 popr := math_rand.New(math_rand.NewSource(616))
4888 total := 0
4889 datas := make([][]byte, 10000)
4890 for i := 0; i < 10000; i++ {
4891 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNonByteCustomType(popr, false))
4892 if err != nil {
4893 panic(err)
4894 }
4895 datas[i] = dAtA
4896 }
4897 msg := &NidRepNonByteCustomType{}
4898 b.ResetTimer()
4899 for i := 0; i < b.N; i++ {
4900 total += len(datas[i%10000])
4901 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4902 panic(err)
4903 }
4904 }
4905 b.SetBytes(int64(total / b.N))
4906 }
4907
4908 func TestNinRepNonByteCustomTypeProto(t *testing.T) {
4909 seed := time.Now().UnixNano()
4910 popr := math_rand.New(math_rand.NewSource(seed))
4911 p := NewPopulatedNinRepNonByteCustomType(popr, false)
4912 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4913 if err != nil {
4914 t.Fatalf("seed = %d, err = %v", seed, err)
4915 }
4916 msg := &NinRepNonByteCustomType{}
4917 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4918 t.Fatalf("seed = %d, err = %v", seed, err)
4919 }
4920 littlefuzz := make([]byte, len(dAtA))
4921 copy(littlefuzz, dAtA)
4922 for i := range dAtA {
4923 dAtA[i] = byte(popr.Intn(256))
4924 }
4925 if err := p.VerboseEqual(msg); err != nil {
4926 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
4927 }
4928 if !p.Equal(msg) {
4929 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
4930 }
4931 if len(littlefuzz) > 0 {
4932 fuzzamount := 100
4933 for i := 0; i < fuzzamount; i++ {
4934 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
4935 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
4936 }
4937
4938 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
4939 }
4940 }
4941
4942 func BenchmarkNinRepNonByteCustomTypeProtoMarshal(b *testing.B) {
4943 popr := math_rand.New(math_rand.NewSource(616))
4944 total := 0
4945 pops := make([]*NinRepNonByteCustomType, 10000)
4946 for i := 0; i < 10000; i++ {
4947 pops[i] = NewPopulatedNinRepNonByteCustomType(popr, false)
4948 }
4949 b.ResetTimer()
4950 for i := 0; i < b.N; i++ {
4951 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
4952 if err != nil {
4953 panic(err)
4954 }
4955 total += len(dAtA)
4956 }
4957 b.SetBytes(int64(total / b.N))
4958 }
4959
4960 func BenchmarkNinRepNonByteCustomTypeProtoUnmarshal(b *testing.B) {
4961 popr := math_rand.New(math_rand.NewSource(616))
4962 total := 0
4963 datas := make([][]byte, 10000)
4964 for i := 0; i < 10000; i++ {
4965 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNonByteCustomType(popr, false))
4966 if err != nil {
4967 panic(err)
4968 }
4969 datas[i] = dAtA
4970 }
4971 msg := &NinRepNonByteCustomType{}
4972 b.ResetTimer()
4973 for i := 0; i < b.N; i++ {
4974 total += len(datas[i%10000])
4975 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
4976 panic(err)
4977 }
4978 }
4979 b.SetBytes(int64(total / b.N))
4980 }
4981
4982 func TestProtoTypeProto(t *testing.T) {
4983 seed := time.Now().UnixNano()
4984 popr := math_rand.New(math_rand.NewSource(seed))
4985 p := NewPopulatedProtoType(popr, false)
4986 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
4987 if err != nil {
4988 t.Fatalf("seed = %d, err = %v", seed, err)
4989 }
4990 msg := &ProtoType{}
4991 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
4992 t.Fatalf("seed = %d, err = %v", seed, err)
4993 }
4994 littlefuzz := make([]byte, len(dAtA))
4995 copy(littlefuzz, dAtA)
4996 for i := range dAtA {
4997 dAtA[i] = byte(popr.Intn(256))
4998 }
4999 if err := p.VerboseEqual(msg); err != nil {
5000 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5001 }
5002 if !p.Equal(msg) {
5003 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
5004 }
5005 if len(littlefuzz) > 0 {
5006 fuzzamount := 100
5007 for i := 0; i < fuzzamount; i++ {
5008 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
5009 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
5010 }
5011
5012 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
5013 }
5014 }
5015
5016 func BenchmarkProtoTypeProtoMarshal(b *testing.B) {
5017 popr := math_rand.New(math_rand.NewSource(616))
5018 total := 0
5019 pops := make([]*ProtoType, 10000)
5020 for i := 0; i < 10000; i++ {
5021 pops[i] = NewPopulatedProtoType(popr, false)
5022 }
5023 b.ResetTimer()
5024 for i := 0; i < b.N; i++ {
5025 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
5026 if err != nil {
5027 panic(err)
5028 }
5029 total += len(dAtA)
5030 }
5031 b.SetBytes(int64(total / b.N))
5032 }
5033
5034 func BenchmarkProtoTypeProtoUnmarshal(b *testing.B) {
5035 popr := math_rand.New(math_rand.NewSource(616))
5036 total := 0
5037 datas := make([][]byte, 10000)
5038 for i := 0; i < 10000; i++ {
5039 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedProtoType(popr, false))
5040 if err != nil {
5041 panic(err)
5042 }
5043 datas[i] = dAtA
5044 }
5045 msg := &ProtoType{}
5046 b.ResetTimer()
5047 for i := 0; i < b.N; i++ {
5048 total += len(datas[i%10000])
5049 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
5050 panic(err)
5051 }
5052 }
5053 b.SetBytes(int64(total / b.N))
5054 }
5055
5056 func TestNidOptNativeJSON(t *testing.T) {
5057 seed := time.Now().UnixNano()
5058 popr := math_rand.New(math_rand.NewSource(seed))
5059 p := NewPopulatedNidOptNative(popr, true)
5060 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5061 jsondata, err := marshaler.MarshalToString(p)
5062 if err != nil {
5063 t.Fatalf("seed = %d, err = %v", seed, err)
5064 }
5065 msg := &NidOptNative{}
5066 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5067 if err != nil {
5068 t.Fatalf("seed = %d, err = %v", seed, err)
5069 }
5070 if err := p.VerboseEqual(msg); err != nil {
5071 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5072 }
5073 if !p.Equal(msg) {
5074 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5075 }
5076 }
5077 func TestNinOptNativeJSON(t *testing.T) {
5078 seed := time.Now().UnixNano()
5079 popr := math_rand.New(math_rand.NewSource(seed))
5080 p := NewPopulatedNinOptNative(popr, true)
5081 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5082 jsondata, err := marshaler.MarshalToString(p)
5083 if err != nil {
5084 t.Fatalf("seed = %d, err = %v", seed, err)
5085 }
5086 msg := &NinOptNative{}
5087 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5088 if err != nil {
5089 t.Fatalf("seed = %d, err = %v", seed, err)
5090 }
5091 if err := p.VerboseEqual(msg); err != nil {
5092 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5093 }
5094 if !p.Equal(msg) {
5095 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5096 }
5097 }
5098 func TestNidRepNativeJSON(t *testing.T) {
5099 seed := time.Now().UnixNano()
5100 popr := math_rand.New(math_rand.NewSource(seed))
5101 p := NewPopulatedNidRepNative(popr, true)
5102 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5103 jsondata, err := marshaler.MarshalToString(p)
5104 if err != nil {
5105 t.Fatalf("seed = %d, err = %v", seed, err)
5106 }
5107 msg := &NidRepNative{}
5108 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5109 if err != nil {
5110 t.Fatalf("seed = %d, err = %v", seed, err)
5111 }
5112 if err := p.VerboseEqual(msg); err != nil {
5113 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5114 }
5115 if !p.Equal(msg) {
5116 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5117 }
5118 }
5119 func TestNinRepNativeJSON(t *testing.T) {
5120 seed := time.Now().UnixNano()
5121 popr := math_rand.New(math_rand.NewSource(seed))
5122 p := NewPopulatedNinRepNative(popr, true)
5123 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5124 jsondata, err := marshaler.MarshalToString(p)
5125 if err != nil {
5126 t.Fatalf("seed = %d, err = %v", seed, err)
5127 }
5128 msg := &NinRepNative{}
5129 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5130 if err != nil {
5131 t.Fatalf("seed = %d, err = %v", seed, err)
5132 }
5133 if err := p.VerboseEqual(msg); err != nil {
5134 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5135 }
5136 if !p.Equal(msg) {
5137 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5138 }
5139 }
5140 func TestNidRepPackedNativeJSON(t *testing.T) {
5141 seed := time.Now().UnixNano()
5142 popr := math_rand.New(math_rand.NewSource(seed))
5143 p := NewPopulatedNidRepPackedNative(popr, true)
5144 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5145 jsondata, err := marshaler.MarshalToString(p)
5146 if err != nil {
5147 t.Fatalf("seed = %d, err = %v", seed, err)
5148 }
5149 msg := &NidRepPackedNative{}
5150 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5151 if err != nil {
5152 t.Fatalf("seed = %d, err = %v", seed, err)
5153 }
5154 if err := p.VerboseEqual(msg); err != nil {
5155 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5156 }
5157 if !p.Equal(msg) {
5158 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5159 }
5160 }
5161 func TestNinRepPackedNativeJSON(t *testing.T) {
5162 seed := time.Now().UnixNano()
5163 popr := math_rand.New(math_rand.NewSource(seed))
5164 p := NewPopulatedNinRepPackedNative(popr, true)
5165 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5166 jsondata, err := marshaler.MarshalToString(p)
5167 if err != nil {
5168 t.Fatalf("seed = %d, err = %v", seed, err)
5169 }
5170 msg := &NinRepPackedNative{}
5171 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5172 if err != nil {
5173 t.Fatalf("seed = %d, err = %v", seed, err)
5174 }
5175 if err := p.VerboseEqual(msg); err != nil {
5176 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5177 }
5178 if !p.Equal(msg) {
5179 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5180 }
5181 }
5182 func TestNidOptStructJSON(t *testing.T) {
5183 seed := time.Now().UnixNano()
5184 popr := math_rand.New(math_rand.NewSource(seed))
5185 p := NewPopulatedNidOptStruct(popr, true)
5186 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5187 jsondata, err := marshaler.MarshalToString(p)
5188 if err != nil {
5189 t.Fatalf("seed = %d, err = %v", seed, err)
5190 }
5191 msg := &NidOptStruct{}
5192 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5193 if err != nil {
5194 t.Fatalf("seed = %d, err = %v", seed, err)
5195 }
5196 if err := p.VerboseEqual(msg); err != nil {
5197 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5198 }
5199 if !p.Equal(msg) {
5200 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5201 }
5202 }
5203 func TestNinOptStructJSON(t *testing.T) {
5204 seed := time.Now().UnixNano()
5205 popr := math_rand.New(math_rand.NewSource(seed))
5206 p := NewPopulatedNinOptStruct(popr, true)
5207 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5208 jsondata, err := marshaler.MarshalToString(p)
5209 if err != nil {
5210 t.Fatalf("seed = %d, err = %v", seed, err)
5211 }
5212 msg := &NinOptStruct{}
5213 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5214 if err != nil {
5215 t.Fatalf("seed = %d, err = %v", seed, err)
5216 }
5217 if err := p.VerboseEqual(msg); err != nil {
5218 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5219 }
5220 if !p.Equal(msg) {
5221 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5222 }
5223 }
5224 func TestNidRepStructJSON(t *testing.T) {
5225 seed := time.Now().UnixNano()
5226 popr := math_rand.New(math_rand.NewSource(seed))
5227 p := NewPopulatedNidRepStruct(popr, true)
5228 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5229 jsondata, err := marshaler.MarshalToString(p)
5230 if err != nil {
5231 t.Fatalf("seed = %d, err = %v", seed, err)
5232 }
5233 msg := &NidRepStruct{}
5234 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5235 if err != nil {
5236 t.Fatalf("seed = %d, err = %v", seed, err)
5237 }
5238 if err := p.VerboseEqual(msg); err != nil {
5239 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5240 }
5241 if !p.Equal(msg) {
5242 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5243 }
5244 }
5245 func TestNinRepStructJSON(t *testing.T) {
5246 seed := time.Now().UnixNano()
5247 popr := math_rand.New(math_rand.NewSource(seed))
5248 p := NewPopulatedNinRepStruct(popr, true)
5249 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5250 jsondata, err := marshaler.MarshalToString(p)
5251 if err != nil {
5252 t.Fatalf("seed = %d, err = %v", seed, err)
5253 }
5254 msg := &NinRepStruct{}
5255 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5256 if err != nil {
5257 t.Fatalf("seed = %d, err = %v", seed, err)
5258 }
5259 if err := p.VerboseEqual(msg); err != nil {
5260 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5261 }
5262 if !p.Equal(msg) {
5263 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5264 }
5265 }
5266 func TestNidEmbeddedStructJSON(t *testing.T) {
5267 seed := time.Now().UnixNano()
5268 popr := math_rand.New(math_rand.NewSource(seed))
5269 p := NewPopulatedNidEmbeddedStruct(popr, true)
5270 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5271 jsondata, err := marshaler.MarshalToString(p)
5272 if err != nil {
5273 t.Fatalf("seed = %d, err = %v", seed, err)
5274 }
5275 msg := &NidEmbeddedStruct{}
5276 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5277 if err != nil {
5278 t.Fatalf("seed = %d, err = %v", seed, err)
5279 }
5280 if err := p.VerboseEqual(msg); err != nil {
5281 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5282 }
5283 if !p.Equal(msg) {
5284 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5285 }
5286 }
5287 func TestNinEmbeddedStructJSON(t *testing.T) {
5288 seed := time.Now().UnixNano()
5289 popr := math_rand.New(math_rand.NewSource(seed))
5290 p := NewPopulatedNinEmbeddedStruct(popr, true)
5291 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5292 jsondata, err := marshaler.MarshalToString(p)
5293 if err != nil {
5294 t.Fatalf("seed = %d, err = %v", seed, err)
5295 }
5296 msg := &NinEmbeddedStruct{}
5297 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5298 if err != nil {
5299 t.Fatalf("seed = %d, err = %v", seed, err)
5300 }
5301 if err := p.VerboseEqual(msg); err != nil {
5302 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5303 }
5304 if !p.Equal(msg) {
5305 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5306 }
5307 }
5308 func TestNidNestedStructJSON(t *testing.T) {
5309 seed := time.Now().UnixNano()
5310 popr := math_rand.New(math_rand.NewSource(seed))
5311 p := NewPopulatedNidNestedStruct(popr, true)
5312 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5313 jsondata, err := marshaler.MarshalToString(p)
5314 if err != nil {
5315 t.Fatalf("seed = %d, err = %v", seed, err)
5316 }
5317 msg := &NidNestedStruct{}
5318 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5319 if err != nil {
5320 t.Fatalf("seed = %d, err = %v", seed, err)
5321 }
5322 if err := p.VerboseEqual(msg); err != nil {
5323 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5324 }
5325 if !p.Equal(msg) {
5326 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5327 }
5328 }
5329 func TestNinNestedStructJSON(t *testing.T) {
5330 seed := time.Now().UnixNano()
5331 popr := math_rand.New(math_rand.NewSource(seed))
5332 p := NewPopulatedNinNestedStruct(popr, true)
5333 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5334 jsondata, err := marshaler.MarshalToString(p)
5335 if err != nil {
5336 t.Fatalf("seed = %d, err = %v", seed, err)
5337 }
5338 msg := &NinNestedStruct{}
5339 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5340 if err != nil {
5341 t.Fatalf("seed = %d, err = %v", seed, err)
5342 }
5343 if err := p.VerboseEqual(msg); err != nil {
5344 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5345 }
5346 if !p.Equal(msg) {
5347 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5348 }
5349 }
5350 func TestNidOptCustomJSON(t *testing.T) {
5351 seed := time.Now().UnixNano()
5352 popr := math_rand.New(math_rand.NewSource(seed))
5353 p := NewPopulatedNidOptCustom(popr, true)
5354 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5355 jsondata, err := marshaler.MarshalToString(p)
5356 if err != nil {
5357 t.Fatalf("seed = %d, err = %v", seed, err)
5358 }
5359 msg := &NidOptCustom{}
5360 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5361 if err != nil {
5362 t.Fatalf("seed = %d, err = %v", seed, err)
5363 }
5364 if err := p.VerboseEqual(msg); err != nil {
5365 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5366 }
5367 if !p.Equal(msg) {
5368 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5369 }
5370 }
5371 func TestCustomDashJSON(t *testing.T) {
5372 seed := time.Now().UnixNano()
5373 popr := math_rand.New(math_rand.NewSource(seed))
5374 p := NewPopulatedCustomDash(popr, true)
5375 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5376 jsondata, err := marshaler.MarshalToString(p)
5377 if err != nil {
5378 t.Fatalf("seed = %d, err = %v", seed, err)
5379 }
5380 msg := &CustomDash{}
5381 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5382 if err != nil {
5383 t.Fatalf("seed = %d, err = %v", seed, err)
5384 }
5385 if err := p.VerboseEqual(msg); err != nil {
5386 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5387 }
5388 if !p.Equal(msg) {
5389 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5390 }
5391 }
5392 func TestNinOptCustomJSON(t *testing.T) {
5393 seed := time.Now().UnixNano()
5394 popr := math_rand.New(math_rand.NewSource(seed))
5395 p := NewPopulatedNinOptCustom(popr, true)
5396 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5397 jsondata, err := marshaler.MarshalToString(p)
5398 if err != nil {
5399 t.Fatalf("seed = %d, err = %v", seed, err)
5400 }
5401 msg := &NinOptCustom{}
5402 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5403 if err != nil {
5404 t.Fatalf("seed = %d, err = %v", seed, err)
5405 }
5406 if err := p.VerboseEqual(msg); err != nil {
5407 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5408 }
5409 if !p.Equal(msg) {
5410 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5411 }
5412 }
5413 func TestNidRepCustomJSON(t *testing.T) {
5414 seed := time.Now().UnixNano()
5415 popr := math_rand.New(math_rand.NewSource(seed))
5416 p := NewPopulatedNidRepCustom(popr, true)
5417 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5418 jsondata, err := marshaler.MarshalToString(p)
5419 if err != nil {
5420 t.Fatalf("seed = %d, err = %v", seed, err)
5421 }
5422 msg := &NidRepCustom{}
5423 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5424 if err != nil {
5425 t.Fatalf("seed = %d, err = %v", seed, err)
5426 }
5427 if err := p.VerboseEqual(msg); err != nil {
5428 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5429 }
5430 if !p.Equal(msg) {
5431 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5432 }
5433 }
5434 func TestNinRepCustomJSON(t *testing.T) {
5435 seed := time.Now().UnixNano()
5436 popr := math_rand.New(math_rand.NewSource(seed))
5437 p := NewPopulatedNinRepCustom(popr, true)
5438 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5439 jsondata, err := marshaler.MarshalToString(p)
5440 if err != nil {
5441 t.Fatalf("seed = %d, err = %v", seed, err)
5442 }
5443 msg := &NinRepCustom{}
5444 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5445 if err != nil {
5446 t.Fatalf("seed = %d, err = %v", seed, err)
5447 }
5448 if err := p.VerboseEqual(msg); err != nil {
5449 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5450 }
5451 if !p.Equal(msg) {
5452 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5453 }
5454 }
5455 func TestNinOptNativeUnionJSON(t *testing.T) {
5456 seed := time.Now().UnixNano()
5457 popr := math_rand.New(math_rand.NewSource(seed))
5458 p := NewPopulatedNinOptNativeUnion(popr, true)
5459 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5460 jsondata, err := marshaler.MarshalToString(p)
5461 if err != nil {
5462 t.Fatalf("seed = %d, err = %v", seed, err)
5463 }
5464 msg := &NinOptNativeUnion{}
5465 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5466 if err != nil {
5467 t.Fatalf("seed = %d, err = %v", seed, err)
5468 }
5469 if err := p.VerboseEqual(msg); err != nil {
5470 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5471 }
5472 if !p.Equal(msg) {
5473 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5474 }
5475 }
5476 func TestNinOptStructUnionJSON(t *testing.T) {
5477 seed := time.Now().UnixNano()
5478 popr := math_rand.New(math_rand.NewSource(seed))
5479 p := NewPopulatedNinOptStructUnion(popr, true)
5480 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5481 jsondata, err := marshaler.MarshalToString(p)
5482 if err != nil {
5483 t.Fatalf("seed = %d, err = %v", seed, err)
5484 }
5485 msg := &NinOptStructUnion{}
5486 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5487 if err != nil {
5488 t.Fatalf("seed = %d, err = %v", seed, err)
5489 }
5490 if err := p.VerboseEqual(msg); err != nil {
5491 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5492 }
5493 if !p.Equal(msg) {
5494 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5495 }
5496 }
5497 func TestNinEmbeddedStructUnionJSON(t *testing.T) {
5498 seed := time.Now().UnixNano()
5499 popr := math_rand.New(math_rand.NewSource(seed))
5500 p := NewPopulatedNinEmbeddedStructUnion(popr, true)
5501 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5502 jsondata, err := marshaler.MarshalToString(p)
5503 if err != nil {
5504 t.Fatalf("seed = %d, err = %v", seed, err)
5505 }
5506 msg := &NinEmbeddedStructUnion{}
5507 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5508 if err != nil {
5509 t.Fatalf("seed = %d, err = %v", seed, err)
5510 }
5511 if err := p.VerboseEqual(msg); err != nil {
5512 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5513 }
5514 if !p.Equal(msg) {
5515 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5516 }
5517 }
5518 func TestNinNestedStructUnionJSON(t *testing.T) {
5519 seed := time.Now().UnixNano()
5520 popr := math_rand.New(math_rand.NewSource(seed))
5521 p := NewPopulatedNinNestedStructUnion(popr, true)
5522 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5523 jsondata, err := marshaler.MarshalToString(p)
5524 if err != nil {
5525 t.Fatalf("seed = %d, err = %v", seed, err)
5526 }
5527 msg := &NinNestedStructUnion{}
5528 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5529 if err != nil {
5530 t.Fatalf("seed = %d, err = %v", seed, err)
5531 }
5532 if err := p.VerboseEqual(msg); err != nil {
5533 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5534 }
5535 if !p.Equal(msg) {
5536 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5537 }
5538 }
5539 func TestTreeJSON(t *testing.T) {
5540 seed := time.Now().UnixNano()
5541 popr := math_rand.New(math_rand.NewSource(seed))
5542 p := NewPopulatedTree(popr, true)
5543 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5544 jsondata, err := marshaler.MarshalToString(p)
5545 if err != nil {
5546 t.Fatalf("seed = %d, err = %v", seed, err)
5547 }
5548 msg := &Tree{}
5549 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5550 if err != nil {
5551 t.Fatalf("seed = %d, err = %v", seed, err)
5552 }
5553 if err := p.VerboseEqual(msg); err != nil {
5554 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5555 }
5556 if !p.Equal(msg) {
5557 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5558 }
5559 }
5560 func TestOrBranchJSON(t *testing.T) {
5561 seed := time.Now().UnixNano()
5562 popr := math_rand.New(math_rand.NewSource(seed))
5563 p := NewPopulatedOrBranch(popr, true)
5564 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5565 jsondata, err := marshaler.MarshalToString(p)
5566 if err != nil {
5567 t.Fatalf("seed = %d, err = %v", seed, err)
5568 }
5569 msg := &OrBranch{}
5570 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5571 if err != nil {
5572 t.Fatalf("seed = %d, err = %v", seed, err)
5573 }
5574 if err := p.VerboseEqual(msg); err != nil {
5575 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5576 }
5577 if !p.Equal(msg) {
5578 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5579 }
5580 }
5581 func TestAndBranchJSON(t *testing.T) {
5582 seed := time.Now().UnixNano()
5583 popr := math_rand.New(math_rand.NewSource(seed))
5584 p := NewPopulatedAndBranch(popr, true)
5585 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5586 jsondata, err := marshaler.MarshalToString(p)
5587 if err != nil {
5588 t.Fatalf("seed = %d, err = %v", seed, err)
5589 }
5590 msg := &AndBranch{}
5591 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5592 if err != nil {
5593 t.Fatalf("seed = %d, err = %v", seed, err)
5594 }
5595 if err := p.VerboseEqual(msg); err != nil {
5596 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5597 }
5598 if !p.Equal(msg) {
5599 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5600 }
5601 }
5602 func TestLeafJSON(t *testing.T) {
5603 seed := time.Now().UnixNano()
5604 popr := math_rand.New(math_rand.NewSource(seed))
5605 p := NewPopulatedLeaf(popr, true)
5606 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5607 jsondata, err := marshaler.MarshalToString(p)
5608 if err != nil {
5609 t.Fatalf("seed = %d, err = %v", seed, err)
5610 }
5611 msg := &Leaf{}
5612 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5613 if err != nil {
5614 t.Fatalf("seed = %d, err = %v", seed, err)
5615 }
5616 if err := p.VerboseEqual(msg); err != nil {
5617 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5618 }
5619 if !p.Equal(msg) {
5620 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5621 }
5622 }
5623 func TestDeepTreeJSON(t *testing.T) {
5624 seed := time.Now().UnixNano()
5625 popr := math_rand.New(math_rand.NewSource(seed))
5626 p := NewPopulatedDeepTree(popr, true)
5627 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5628 jsondata, err := marshaler.MarshalToString(p)
5629 if err != nil {
5630 t.Fatalf("seed = %d, err = %v", seed, err)
5631 }
5632 msg := &DeepTree{}
5633 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5634 if err != nil {
5635 t.Fatalf("seed = %d, err = %v", seed, err)
5636 }
5637 if err := p.VerboseEqual(msg); err != nil {
5638 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5639 }
5640 if !p.Equal(msg) {
5641 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5642 }
5643 }
5644 func TestADeepBranchJSON(t *testing.T) {
5645 seed := time.Now().UnixNano()
5646 popr := math_rand.New(math_rand.NewSource(seed))
5647 p := NewPopulatedADeepBranch(popr, true)
5648 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5649 jsondata, err := marshaler.MarshalToString(p)
5650 if err != nil {
5651 t.Fatalf("seed = %d, err = %v", seed, err)
5652 }
5653 msg := &ADeepBranch{}
5654 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5655 if err != nil {
5656 t.Fatalf("seed = %d, err = %v", seed, err)
5657 }
5658 if err := p.VerboseEqual(msg); err != nil {
5659 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5660 }
5661 if !p.Equal(msg) {
5662 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5663 }
5664 }
5665 func TestAndDeepBranchJSON(t *testing.T) {
5666 seed := time.Now().UnixNano()
5667 popr := math_rand.New(math_rand.NewSource(seed))
5668 p := NewPopulatedAndDeepBranch(popr, true)
5669 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5670 jsondata, err := marshaler.MarshalToString(p)
5671 if err != nil {
5672 t.Fatalf("seed = %d, err = %v", seed, err)
5673 }
5674 msg := &AndDeepBranch{}
5675 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5676 if err != nil {
5677 t.Fatalf("seed = %d, err = %v", seed, err)
5678 }
5679 if err := p.VerboseEqual(msg); err != nil {
5680 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5681 }
5682 if !p.Equal(msg) {
5683 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5684 }
5685 }
5686 func TestDeepLeafJSON(t *testing.T) {
5687 seed := time.Now().UnixNano()
5688 popr := math_rand.New(math_rand.NewSource(seed))
5689 p := NewPopulatedDeepLeaf(popr, true)
5690 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5691 jsondata, err := marshaler.MarshalToString(p)
5692 if err != nil {
5693 t.Fatalf("seed = %d, err = %v", seed, err)
5694 }
5695 msg := &DeepLeaf{}
5696 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5697 if err != nil {
5698 t.Fatalf("seed = %d, err = %v", seed, err)
5699 }
5700 if err := p.VerboseEqual(msg); err != nil {
5701 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5702 }
5703 if !p.Equal(msg) {
5704 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5705 }
5706 }
5707 func TestNilJSON(t *testing.T) {
5708 seed := time.Now().UnixNano()
5709 popr := math_rand.New(math_rand.NewSource(seed))
5710 p := NewPopulatedNil(popr, true)
5711 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5712 jsondata, err := marshaler.MarshalToString(p)
5713 if err != nil {
5714 t.Fatalf("seed = %d, err = %v", seed, err)
5715 }
5716 msg := &Nil{}
5717 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5718 if err != nil {
5719 t.Fatalf("seed = %d, err = %v", seed, err)
5720 }
5721 if err := p.VerboseEqual(msg); err != nil {
5722 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5723 }
5724 if !p.Equal(msg) {
5725 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5726 }
5727 }
5728 func TestNidOptEnumJSON(t *testing.T) {
5729 seed := time.Now().UnixNano()
5730 popr := math_rand.New(math_rand.NewSource(seed))
5731 p := NewPopulatedNidOptEnum(popr, true)
5732 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5733 jsondata, err := marshaler.MarshalToString(p)
5734 if err != nil {
5735 t.Fatalf("seed = %d, err = %v", seed, err)
5736 }
5737 msg := &NidOptEnum{}
5738 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5739 if err != nil {
5740 t.Fatalf("seed = %d, err = %v", seed, err)
5741 }
5742 if err := p.VerboseEqual(msg); err != nil {
5743 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5744 }
5745 if !p.Equal(msg) {
5746 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5747 }
5748 }
5749 func TestNinOptEnumJSON(t *testing.T) {
5750 seed := time.Now().UnixNano()
5751 popr := math_rand.New(math_rand.NewSource(seed))
5752 p := NewPopulatedNinOptEnum(popr, true)
5753 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5754 jsondata, err := marshaler.MarshalToString(p)
5755 if err != nil {
5756 t.Fatalf("seed = %d, err = %v", seed, err)
5757 }
5758 msg := &NinOptEnum{}
5759 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5760 if err != nil {
5761 t.Fatalf("seed = %d, err = %v", seed, err)
5762 }
5763 if err := p.VerboseEqual(msg); err != nil {
5764 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5765 }
5766 if !p.Equal(msg) {
5767 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5768 }
5769 }
5770 func TestNidRepEnumJSON(t *testing.T) {
5771 seed := time.Now().UnixNano()
5772 popr := math_rand.New(math_rand.NewSource(seed))
5773 p := NewPopulatedNidRepEnum(popr, true)
5774 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5775 jsondata, err := marshaler.MarshalToString(p)
5776 if err != nil {
5777 t.Fatalf("seed = %d, err = %v", seed, err)
5778 }
5779 msg := &NidRepEnum{}
5780 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5781 if err != nil {
5782 t.Fatalf("seed = %d, err = %v", seed, err)
5783 }
5784 if err := p.VerboseEqual(msg); err != nil {
5785 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5786 }
5787 if !p.Equal(msg) {
5788 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5789 }
5790 }
5791 func TestNinRepEnumJSON(t *testing.T) {
5792 seed := time.Now().UnixNano()
5793 popr := math_rand.New(math_rand.NewSource(seed))
5794 p := NewPopulatedNinRepEnum(popr, true)
5795 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5796 jsondata, err := marshaler.MarshalToString(p)
5797 if err != nil {
5798 t.Fatalf("seed = %d, err = %v", seed, err)
5799 }
5800 msg := &NinRepEnum{}
5801 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5802 if err != nil {
5803 t.Fatalf("seed = %d, err = %v", seed, err)
5804 }
5805 if err := p.VerboseEqual(msg); err != nil {
5806 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5807 }
5808 if !p.Equal(msg) {
5809 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5810 }
5811 }
5812 func TestNinOptEnumDefaultJSON(t *testing.T) {
5813 seed := time.Now().UnixNano()
5814 popr := math_rand.New(math_rand.NewSource(seed))
5815 p := NewPopulatedNinOptEnumDefault(popr, true)
5816 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5817 jsondata, err := marshaler.MarshalToString(p)
5818 if err != nil {
5819 t.Fatalf("seed = %d, err = %v", seed, err)
5820 }
5821 msg := &NinOptEnumDefault{}
5822 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5823 if err != nil {
5824 t.Fatalf("seed = %d, err = %v", seed, err)
5825 }
5826 if err := p.VerboseEqual(msg); err != nil {
5827 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5828 }
5829 if !p.Equal(msg) {
5830 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5831 }
5832 }
5833 func TestAnotherNinOptEnumJSON(t *testing.T) {
5834 seed := time.Now().UnixNano()
5835 popr := math_rand.New(math_rand.NewSource(seed))
5836 p := NewPopulatedAnotherNinOptEnum(popr, true)
5837 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5838 jsondata, err := marshaler.MarshalToString(p)
5839 if err != nil {
5840 t.Fatalf("seed = %d, err = %v", seed, err)
5841 }
5842 msg := &AnotherNinOptEnum{}
5843 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5844 if err != nil {
5845 t.Fatalf("seed = %d, err = %v", seed, err)
5846 }
5847 if err := p.VerboseEqual(msg); err != nil {
5848 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5849 }
5850 if !p.Equal(msg) {
5851 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5852 }
5853 }
5854 func TestAnotherNinOptEnumDefaultJSON(t *testing.T) {
5855 seed := time.Now().UnixNano()
5856 popr := math_rand.New(math_rand.NewSource(seed))
5857 p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
5858 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5859 jsondata, err := marshaler.MarshalToString(p)
5860 if err != nil {
5861 t.Fatalf("seed = %d, err = %v", seed, err)
5862 }
5863 msg := &AnotherNinOptEnumDefault{}
5864 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5865 if err != nil {
5866 t.Fatalf("seed = %d, err = %v", seed, err)
5867 }
5868 if err := p.VerboseEqual(msg); err != nil {
5869 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5870 }
5871 if !p.Equal(msg) {
5872 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5873 }
5874 }
5875 func TestTimerJSON(t *testing.T) {
5876 seed := time.Now().UnixNano()
5877 popr := math_rand.New(math_rand.NewSource(seed))
5878 p := NewPopulatedTimer(popr, true)
5879 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5880 jsondata, err := marshaler.MarshalToString(p)
5881 if err != nil {
5882 t.Fatalf("seed = %d, err = %v", seed, err)
5883 }
5884 msg := &Timer{}
5885 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5886 if err != nil {
5887 t.Fatalf("seed = %d, err = %v", seed, err)
5888 }
5889 if err := p.VerboseEqual(msg); err != nil {
5890 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5891 }
5892 if !p.Equal(msg) {
5893 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5894 }
5895 }
5896 func TestMyExtendableJSON(t *testing.T) {
5897 seed := time.Now().UnixNano()
5898 popr := math_rand.New(math_rand.NewSource(seed))
5899 p := NewPopulatedMyExtendable(popr, true)
5900 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5901 jsondata, err := marshaler.MarshalToString(p)
5902 if err != nil {
5903 t.Fatalf("seed = %d, err = %v", seed, err)
5904 }
5905 msg := &MyExtendable{}
5906 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5907 if err != nil {
5908 t.Fatalf("seed = %d, err = %v", seed, err)
5909 }
5910 if err := p.VerboseEqual(msg); err != nil {
5911 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5912 }
5913 if !p.Equal(msg) {
5914 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5915 }
5916 }
5917 func TestOtherExtenableJSON(t *testing.T) {
5918 seed := time.Now().UnixNano()
5919 popr := math_rand.New(math_rand.NewSource(seed))
5920 p := NewPopulatedOtherExtenable(popr, true)
5921 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5922 jsondata, err := marshaler.MarshalToString(p)
5923 if err != nil {
5924 t.Fatalf("seed = %d, err = %v", seed, err)
5925 }
5926 msg := &OtherExtenable{}
5927 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5928 if err != nil {
5929 t.Fatalf("seed = %d, err = %v", seed, err)
5930 }
5931 if err := p.VerboseEqual(msg); err != nil {
5932 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5933 }
5934 if !p.Equal(msg) {
5935 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5936 }
5937 }
5938 func TestNestedDefinitionJSON(t *testing.T) {
5939 seed := time.Now().UnixNano()
5940 popr := math_rand.New(math_rand.NewSource(seed))
5941 p := NewPopulatedNestedDefinition(popr, true)
5942 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5943 jsondata, err := marshaler.MarshalToString(p)
5944 if err != nil {
5945 t.Fatalf("seed = %d, err = %v", seed, err)
5946 }
5947 msg := &NestedDefinition{}
5948 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5949 if err != nil {
5950 t.Fatalf("seed = %d, err = %v", seed, err)
5951 }
5952 if err := p.VerboseEqual(msg); err != nil {
5953 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5954 }
5955 if !p.Equal(msg) {
5956 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5957 }
5958 }
5959 func TestNestedDefinition_NestedMessageJSON(t *testing.T) {
5960 seed := time.Now().UnixNano()
5961 popr := math_rand.New(math_rand.NewSource(seed))
5962 p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
5963 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5964 jsondata, err := marshaler.MarshalToString(p)
5965 if err != nil {
5966 t.Fatalf("seed = %d, err = %v", seed, err)
5967 }
5968 msg := &NestedDefinition_NestedMessage{}
5969 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5970 if err != nil {
5971 t.Fatalf("seed = %d, err = %v", seed, err)
5972 }
5973 if err := p.VerboseEqual(msg); err != nil {
5974 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5975 }
5976 if !p.Equal(msg) {
5977 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5978 }
5979 }
5980 func TestNestedDefinition_NestedMessage_NestedNestedMsgJSON(t *testing.T) {
5981 seed := time.Now().UnixNano()
5982 popr := math_rand.New(math_rand.NewSource(seed))
5983 p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
5984 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
5985 jsondata, err := marshaler.MarshalToString(p)
5986 if err != nil {
5987 t.Fatalf("seed = %d, err = %v", seed, err)
5988 }
5989 msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
5990 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
5991 if err != nil {
5992 t.Fatalf("seed = %d, err = %v", seed, err)
5993 }
5994 if err := p.VerboseEqual(msg); err != nil {
5995 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
5996 }
5997 if !p.Equal(msg) {
5998 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
5999 }
6000 }
6001 func TestNestedScopeJSON(t *testing.T) {
6002 seed := time.Now().UnixNano()
6003 popr := math_rand.New(math_rand.NewSource(seed))
6004 p := NewPopulatedNestedScope(popr, true)
6005 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6006 jsondata, err := marshaler.MarshalToString(p)
6007 if err != nil {
6008 t.Fatalf("seed = %d, err = %v", seed, err)
6009 }
6010 msg := &NestedScope{}
6011 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6012 if err != nil {
6013 t.Fatalf("seed = %d, err = %v", seed, err)
6014 }
6015 if err := p.VerboseEqual(msg); err != nil {
6016 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6017 }
6018 if !p.Equal(msg) {
6019 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6020 }
6021 }
6022 func TestNinOptNativeDefaultJSON(t *testing.T) {
6023 seed := time.Now().UnixNano()
6024 popr := math_rand.New(math_rand.NewSource(seed))
6025 p := NewPopulatedNinOptNativeDefault(popr, true)
6026 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6027 jsondata, err := marshaler.MarshalToString(p)
6028 if err != nil {
6029 t.Fatalf("seed = %d, err = %v", seed, err)
6030 }
6031 msg := &NinOptNativeDefault{}
6032 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6033 if err != nil {
6034 t.Fatalf("seed = %d, err = %v", seed, err)
6035 }
6036 if err := p.VerboseEqual(msg); err != nil {
6037 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6038 }
6039 if !p.Equal(msg) {
6040 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6041 }
6042 }
6043 func TestCustomContainerJSON(t *testing.T) {
6044 seed := time.Now().UnixNano()
6045 popr := math_rand.New(math_rand.NewSource(seed))
6046 p := NewPopulatedCustomContainer(popr, true)
6047 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6048 jsondata, err := marshaler.MarshalToString(p)
6049 if err != nil {
6050 t.Fatalf("seed = %d, err = %v", seed, err)
6051 }
6052 msg := &CustomContainer{}
6053 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6054 if err != nil {
6055 t.Fatalf("seed = %d, err = %v", seed, err)
6056 }
6057 if err := p.VerboseEqual(msg); err != nil {
6058 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6059 }
6060 if !p.Equal(msg) {
6061 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6062 }
6063 }
6064 func TestCustomNameNidOptNativeJSON(t *testing.T) {
6065 seed := time.Now().UnixNano()
6066 popr := math_rand.New(math_rand.NewSource(seed))
6067 p := NewPopulatedCustomNameNidOptNative(popr, true)
6068 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6069 jsondata, err := marshaler.MarshalToString(p)
6070 if err != nil {
6071 t.Fatalf("seed = %d, err = %v", seed, err)
6072 }
6073 msg := &CustomNameNidOptNative{}
6074 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6075 if err != nil {
6076 t.Fatalf("seed = %d, err = %v", seed, err)
6077 }
6078 if err := p.VerboseEqual(msg); err != nil {
6079 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6080 }
6081 if !p.Equal(msg) {
6082 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6083 }
6084 }
6085 func TestCustomNameNinOptNativeJSON(t *testing.T) {
6086 seed := time.Now().UnixNano()
6087 popr := math_rand.New(math_rand.NewSource(seed))
6088 p := NewPopulatedCustomNameNinOptNative(popr, true)
6089 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6090 jsondata, err := marshaler.MarshalToString(p)
6091 if err != nil {
6092 t.Fatalf("seed = %d, err = %v", seed, err)
6093 }
6094 msg := &CustomNameNinOptNative{}
6095 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6096 if err != nil {
6097 t.Fatalf("seed = %d, err = %v", seed, err)
6098 }
6099 if err := p.VerboseEqual(msg); err != nil {
6100 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6101 }
6102 if !p.Equal(msg) {
6103 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6104 }
6105 }
6106 func TestCustomNameNinRepNativeJSON(t *testing.T) {
6107 seed := time.Now().UnixNano()
6108 popr := math_rand.New(math_rand.NewSource(seed))
6109 p := NewPopulatedCustomNameNinRepNative(popr, true)
6110 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6111 jsondata, err := marshaler.MarshalToString(p)
6112 if err != nil {
6113 t.Fatalf("seed = %d, err = %v", seed, err)
6114 }
6115 msg := &CustomNameNinRepNative{}
6116 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6117 if err != nil {
6118 t.Fatalf("seed = %d, err = %v", seed, err)
6119 }
6120 if err := p.VerboseEqual(msg); err != nil {
6121 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6122 }
6123 if !p.Equal(msg) {
6124 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6125 }
6126 }
6127 func TestCustomNameNinStructJSON(t *testing.T) {
6128 seed := time.Now().UnixNano()
6129 popr := math_rand.New(math_rand.NewSource(seed))
6130 p := NewPopulatedCustomNameNinStruct(popr, true)
6131 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6132 jsondata, err := marshaler.MarshalToString(p)
6133 if err != nil {
6134 t.Fatalf("seed = %d, err = %v", seed, err)
6135 }
6136 msg := &CustomNameNinStruct{}
6137 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6138 if err != nil {
6139 t.Fatalf("seed = %d, err = %v", seed, err)
6140 }
6141 if err := p.VerboseEqual(msg); err != nil {
6142 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6143 }
6144 if !p.Equal(msg) {
6145 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6146 }
6147 }
6148 func TestCustomNameCustomTypeJSON(t *testing.T) {
6149 seed := time.Now().UnixNano()
6150 popr := math_rand.New(math_rand.NewSource(seed))
6151 p := NewPopulatedCustomNameCustomType(popr, true)
6152 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6153 jsondata, err := marshaler.MarshalToString(p)
6154 if err != nil {
6155 t.Fatalf("seed = %d, err = %v", seed, err)
6156 }
6157 msg := &CustomNameCustomType{}
6158 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6159 if err != nil {
6160 t.Fatalf("seed = %d, err = %v", seed, err)
6161 }
6162 if err := p.VerboseEqual(msg); err != nil {
6163 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6164 }
6165 if !p.Equal(msg) {
6166 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6167 }
6168 }
6169 func TestCustomNameNinEmbeddedStructUnionJSON(t *testing.T) {
6170 seed := time.Now().UnixNano()
6171 popr := math_rand.New(math_rand.NewSource(seed))
6172 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
6173 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6174 jsondata, err := marshaler.MarshalToString(p)
6175 if err != nil {
6176 t.Fatalf("seed = %d, err = %v", seed, err)
6177 }
6178 msg := &CustomNameNinEmbeddedStructUnion{}
6179 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6180 if err != nil {
6181 t.Fatalf("seed = %d, err = %v", seed, err)
6182 }
6183 if err := p.VerboseEqual(msg); err != nil {
6184 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6185 }
6186 if !p.Equal(msg) {
6187 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6188 }
6189 }
6190 func TestCustomNameEnumJSON(t *testing.T) {
6191 seed := time.Now().UnixNano()
6192 popr := math_rand.New(math_rand.NewSource(seed))
6193 p := NewPopulatedCustomNameEnum(popr, true)
6194 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6195 jsondata, err := marshaler.MarshalToString(p)
6196 if err != nil {
6197 t.Fatalf("seed = %d, err = %v", seed, err)
6198 }
6199 msg := &CustomNameEnum{}
6200 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6201 if err != nil {
6202 t.Fatalf("seed = %d, err = %v", seed, err)
6203 }
6204 if err := p.VerboseEqual(msg); err != nil {
6205 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6206 }
6207 if !p.Equal(msg) {
6208 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6209 }
6210 }
6211 func TestNoExtensionsMapJSON(t *testing.T) {
6212 seed := time.Now().UnixNano()
6213 popr := math_rand.New(math_rand.NewSource(seed))
6214 p := NewPopulatedNoExtensionsMap(popr, true)
6215 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6216 jsondata, err := marshaler.MarshalToString(p)
6217 if err != nil {
6218 t.Fatalf("seed = %d, err = %v", seed, err)
6219 }
6220 msg := &NoExtensionsMap{}
6221 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6222 if err != nil {
6223 t.Fatalf("seed = %d, err = %v", seed, err)
6224 }
6225 if err := p.VerboseEqual(msg); err != nil {
6226 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6227 }
6228 if !p.Equal(msg) {
6229 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6230 }
6231 }
6232 func TestUnrecognizedJSON(t *testing.T) {
6233 seed := time.Now().UnixNano()
6234 popr := math_rand.New(math_rand.NewSource(seed))
6235 p := NewPopulatedUnrecognized(popr, true)
6236 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6237 jsondata, err := marshaler.MarshalToString(p)
6238 if err != nil {
6239 t.Fatalf("seed = %d, err = %v", seed, err)
6240 }
6241 msg := &Unrecognized{}
6242 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6243 if err != nil {
6244 t.Fatalf("seed = %d, err = %v", seed, err)
6245 }
6246 if err := p.VerboseEqual(msg); err != nil {
6247 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6248 }
6249 if !p.Equal(msg) {
6250 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6251 }
6252 }
6253 func TestUnrecognizedWithInnerJSON(t *testing.T) {
6254 seed := time.Now().UnixNano()
6255 popr := math_rand.New(math_rand.NewSource(seed))
6256 p := NewPopulatedUnrecognizedWithInner(popr, true)
6257 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6258 jsondata, err := marshaler.MarshalToString(p)
6259 if err != nil {
6260 t.Fatalf("seed = %d, err = %v", seed, err)
6261 }
6262 msg := &UnrecognizedWithInner{}
6263 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6264 if err != nil {
6265 t.Fatalf("seed = %d, err = %v", seed, err)
6266 }
6267 if err := p.VerboseEqual(msg); err != nil {
6268 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6269 }
6270 if !p.Equal(msg) {
6271 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6272 }
6273 }
6274 func TestUnrecognizedWithInner_InnerJSON(t *testing.T) {
6275 seed := time.Now().UnixNano()
6276 popr := math_rand.New(math_rand.NewSource(seed))
6277 p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
6278 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6279 jsondata, err := marshaler.MarshalToString(p)
6280 if err != nil {
6281 t.Fatalf("seed = %d, err = %v", seed, err)
6282 }
6283 msg := &UnrecognizedWithInner_Inner{}
6284 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6285 if err != nil {
6286 t.Fatalf("seed = %d, err = %v", seed, err)
6287 }
6288 if err := p.VerboseEqual(msg); err != nil {
6289 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6290 }
6291 if !p.Equal(msg) {
6292 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6293 }
6294 }
6295 func TestUnrecognizedWithEmbedJSON(t *testing.T) {
6296 seed := time.Now().UnixNano()
6297 popr := math_rand.New(math_rand.NewSource(seed))
6298 p := NewPopulatedUnrecognizedWithEmbed(popr, true)
6299 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6300 jsondata, err := marshaler.MarshalToString(p)
6301 if err != nil {
6302 t.Fatalf("seed = %d, err = %v", seed, err)
6303 }
6304 msg := &UnrecognizedWithEmbed{}
6305 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6306 if err != nil {
6307 t.Fatalf("seed = %d, err = %v", seed, err)
6308 }
6309 if err := p.VerboseEqual(msg); err != nil {
6310 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6311 }
6312 if !p.Equal(msg) {
6313 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6314 }
6315 }
6316 func TestUnrecognizedWithEmbed_EmbeddedJSON(t *testing.T) {
6317 seed := time.Now().UnixNano()
6318 popr := math_rand.New(math_rand.NewSource(seed))
6319 p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
6320 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6321 jsondata, err := marshaler.MarshalToString(p)
6322 if err != nil {
6323 t.Fatalf("seed = %d, err = %v", seed, err)
6324 }
6325 msg := &UnrecognizedWithEmbed_Embedded{}
6326 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6327 if err != nil {
6328 t.Fatalf("seed = %d, err = %v", seed, err)
6329 }
6330 if err := p.VerboseEqual(msg); err != nil {
6331 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6332 }
6333 if !p.Equal(msg) {
6334 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6335 }
6336 }
6337 func TestNodeJSON(t *testing.T) {
6338 seed := time.Now().UnixNano()
6339 popr := math_rand.New(math_rand.NewSource(seed))
6340 p := NewPopulatedNode(popr, true)
6341 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6342 jsondata, err := marshaler.MarshalToString(p)
6343 if err != nil {
6344 t.Fatalf("seed = %d, err = %v", seed, err)
6345 }
6346 msg := &Node{}
6347 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6348 if err != nil {
6349 t.Fatalf("seed = %d, err = %v", seed, err)
6350 }
6351 if err := p.VerboseEqual(msg); err != nil {
6352 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6353 }
6354 if !p.Equal(msg) {
6355 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6356 }
6357 }
6358 func TestNonByteCustomTypeJSON(t *testing.T) {
6359 seed := time.Now().UnixNano()
6360 popr := math_rand.New(math_rand.NewSource(seed))
6361 p := NewPopulatedNonByteCustomType(popr, true)
6362 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6363 jsondata, err := marshaler.MarshalToString(p)
6364 if err != nil {
6365 t.Fatalf("seed = %d, err = %v", seed, err)
6366 }
6367 msg := &NonByteCustomType{}
6368 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6369 if err != nil {
6370 t.Fatalf("seed = %d, err = %v", seed, err)
6371 }
6372 if err := p.VerboseEqual(msg); err != nil {
6373 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6374 }
6375 if !p.Equal(msg) {
6376 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6377 }
6378 }
6379 func TestNidOptNonByteCustomTypeJSON(t *testing.T) {
6380 seed := time.Now().UnixNano()
6381 popr := math_rand.New(math_rand.NewSource(seed))
6382 p := NewPopulatedNidOptNonByteCustomType(popr, true)
6383 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6384 jsondata, err := marshaler.MarshalToString(p)
6385 if err != nil {
6386 t.Fatalf("seed = %d, err = %v", seed, err)
6387 }
6388 msg := &NidOptNonByteCustomType{}
6389 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6390 if err != nil {
6391 t.Fatalf("seed = %d, err = %v", seed, err)
6392 }
6393 if err := p.VerboseEqual(msg); err != nil {
6394 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6395 }
6396 if !p.Equal(msg) {
6397 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6398 }
6399 }
6400 func TestNinOptNonByteCustomTypeJSON(t *testing.T) {
6401 seed := time.Now().UnixNano()
6402 popr := math_rand.New(math_rand.NewSource(seed))
6403 p := NewPopulatedNinOptNonByteCustomType(popr, true)
6404 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6405 jsondata, err := marshaler.MarshalToString(p)
6406 if err != nil {
6407 t.Fatalf("seed = %d, err = %v", seed, err)
6408 }
6409 msg := &NinOptNonByteCustomType{}
6410 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6411 if err != nil {
6412 t.Fatalf("seed = %d, err = %v", seed, err)
6413 }
6414 if err := p.VerboseEqual(msg); err != nil {
6415 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6416 }
6417 if !p.Equal(msg) {
6418 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6419 }
6420 }
6421 func TestNidRepNonByteCustomTypeJSON(t *testing.T) {
6422 seed := time.Now().UnixNano()
6423 popr := math_rand.New(math_rand.NewSource(seed))
6424 p := NewPopulatedNidRepNonByteCustomType(popr, true)
6425 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6426 jsondata, err := marshaler.MarshalToString(p)
6427 if err != nil {
6428 t.Fatalf("seed = %d, err = %v", seed, err)
6429 }
6430 msg := &NidRepNonByteCustomType{}
6431 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6432 if err != nil {
6433 t.Fatalf("seed = %d, err = %v", seed, err)
6434 }
6435 if err := p.VerboseEqual(msg); err != nil {
6436 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6437 }
6438 if !p.Equal(msg) {
6439 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6440 }
6441 }
6442 func TestNinRepNonByteCustomTypeJSON(t *testing.T) {
6443 seed := time.Now().UnixNano()
6444 popr := math_rand.New(math_rand.NewSource(seed))
6445 p := NewPopulatedNinRepNonByteCustomType(popr, true)
6446 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6447 jsondata, err := marshaler.MarshalToString(p)
6448 if err != nil {
6449 t.Fatalf("seed = %d, err = %v", seed, err)
6450 }
6451 msg := &NinRepNonByteCustomType{}
6452 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6453 if err != nil {
6454 t.Fatalf("seed = %d, err = %v", seed, err)
6455 }
6456 if err := p.VerboseEqual(msg); err != nil {
6457 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6458 }
6459 if !p.Equal(msg) {
6460 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6461 }
6462 }
6463 func TestProtoTypeJSON(t *testing.T) {
6464 seed := time.Now().UnixNano()
6465 popr := math_rand.New(math_rand.NewSource(seed))
6466 p := NewPopulatedProtoType(popr, true)
6467 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
6468 jsondata, err := marshaler.MarshalToString(p)
6469 if err != nil {
6470 t.Fatalf("seed = %d, err = %v", seed, err)
6471 }
6472 msg := &ProtoType{}
6473 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
6474 if err != nil {
6475 t.Fatalf("seed = %d, err = %v", seed, err)
6476 }
6477 if err := p.VerboseEqual(msg); err != nil {
6478 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6479 }
6480 if !p.Equal(msg) {
6481 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
6482 }
6483 }
6484 func TestNidOptNativeProtoText(t *testing.T) {
6485 seed := time.Now().UnixNano()
6486 popr := math_rand.New(math_rand.NewSource(seed))
6487 p := NewPopulatedNidOptNative(popr, true)
6488 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6489 msg := &NidOptNative{}
6490 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6491 t.Fatalf("seed = %d, err = %v", seed, err)
6492 }
6493 if err := p.VerboseEqual(msg); err != nil {
6494 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6495 }
6496 if !p.Equal(msg) {
6497 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6498 }
6499 }
6500
6501 func TestNidOptNativeProtoCompactText(t *testing.T) {
6502 seed := time.Now().UnixNano()
6503 popr := math_rand.New(math_rand.NewSource(seed))
6504 p := NewPopulatedNidOptNative(popr, true)
6505 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6506 msg := &NidOptNative{}
6507 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6508 t.Fatalf("seed = %d, err = %v", seed, err)
6509 }
6510 if err := p.VerboseEqual(msg); err != nil {
6511 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6512 }
6513 if !p.Equal(msg) {
6514 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6515 }
6516 }
6517
6518 func TestNinOptNativeProtoText(t *testing.T) {
6519 seed := time.Now().UnixNano()
6520 popr := math_rand.New(math_rand.NewSource(seed))
6521 p := NewPopulatedNinOptNative(popr, true)
6522 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6523 msg := &NinOptNative{}
6524 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6525 t.Fatalf("seed = %d, err = %v", seed, err)
6526 }
6527 if err := p.VerboseEqual(msg); err != nil {
6528 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6529 }
6530 if !p.Equal(msg) {
6531 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6532 }
6533 }
6534
6535 func TestNinOptNativeProtoCompactText(t *testing.T) {
6536 seed := time.Now().UnixNano()
6537 popr := math_rand.New(math_rand.NewSource(seed))
6538 p := NewPopulatedNinOptNative(popr, true)
6539 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6540 msg := &NinOptNative{}
6541 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6542 t.Fatalf("seed = %d, err = %v", seed, err)
6543 }
6544 if err := p.VerboseEqual(msg); err != nil {
6545 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6546 }
6547 if !p.Equal(msg) {
6548 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6549 }
6550 }
6551
6552 func TestNidRepNativeProtoText(t *testing.T) {
6553 seed := time.Now().UnixNano()
6554 popr := math_rand.New(math_rand.NewSource(seed))
6555 p := NewPopulatedNidRepNative(popr, true)
6556 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6557 msg := &NidRepNative{}
6558 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6559 t.Fatalf("seed = %d, err = %v", seed, err)
6560 }
6561 if err := p.VerboseEqual(msg); err != nil {
6562 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6563 }
6564 if !p.Equal(msg) {
6565 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6566 }
6567 }
6568
6569 func TestNidRepNativeProtoCompactText(t *testing.T) {
6570 seed := time.Now().UnixNano()
6571 popr := math_rand.New(math_rand.NewSource(seed))
6572 p := NewPopulatedNidRepNative(popr, true)
6573 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6574 msg := &NidRepNative{}
6575 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6576 t.Fatalf("seed = %d, err = %v", seed, err)
6577 }
6578 if err := p.VerboseEqual(msg); err != nil {
6579 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6580 }
6581 if !p.Equal(msg) {
6582 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6583 }
6584 }
6585
6586 func TestNinRepNativeProtoText(t *testing.T) {
6587 seed := time.Now().UnixNano()
6588 popr := math_rand.New(math_rand.NewSource(seed))
6589 p := NewPopulatedNinRepNative(popr, true)
6590 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6591 msg := &NinRepNative{}
6592 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6593 t.Fatalf("seed = %d, err = %v", seed, err)
6594 }
6595 if err := p.VerboseEqual(msg); err != nil {
6596 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6597 }
6598 if !p.Equal(msg) {
6599 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6600 }
6601 }
6602
6603 func TestNinRepNativeProtoCompactText(t *testing.T) {
6604 seed := time.Now().UnixNano()
6605 popr := math_rand.New(math_rand.NewSource(seed))
6606 p := NewPopulatedNinRepNative(popr, true)
6607 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6608 msg := &NinRepNative{}
6609 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6610 t.Fatalf("seed = %d, err = %v", seed, err)
6611 }
6612 if err := p.VerboseEqual(msg); err != nil {
6613 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6614 }
6615 if !p.Equal(msg) {
6616 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6617 }
6618 }
6619
6620 func TestNidRepPackedNativeProtoText(t *testing.T) {
6621 seed := time.Now().UnixNano()
6622 popr := math_rand.New(math_rand.NewSource(seed))
6623 p := NewPopulatedNidRepPackedNative(popr, true)
6624 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6625 msg := &NidRepPackedNative{}
6626 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6627 t.Fatalf("seed = %d, err = %v", seed, err)
6628 }
6629 if err := p.VerboseEqual(msg); err != nil {
6630 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6631 }
6632 if !p.Equal(msg) {
6633 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6634 }
6635 }
6636
6637 func TestNidRepPackedNativeProtoCompactText(t *testing.T) {
6638 seed := time.Now().UnixNano()
6639 popr := math_rand.New(math_rand.NewSource(seed))
6640 p := NewPopulatedNidRepPackedNative(popr, true)
6641 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6642 msg := &NidRepPackedNative{}
6643 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6644 t.Fatalf("seed = %d, err = %v", seed, err)
6645 }
6646 if err := p.VerboseEqual(msg); err != nil {
6647 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6648 }
6649 if !p.Equal(msg) {
6650 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6651 }
6652 }
6653
6654 func TestNinRepPackedNativeProtoText(t *testing.T) {
6655 seed := time.Now().UnixNano()
6656 popr := math_rand.New(math_rand.NewSource(seed))
6657 p := NewPopulatedNinRepPackedNative(popr, true)
6658 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6659 msg := &NinRepPackedNative{}
6660 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6661 t.Fatalf("seed = %d, err = %v", seed, err)
6662 }
6663 if err := p.VerboseEqual(msg); err != nil {
6664 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6665 }
6666 if !p.Equal(msg) {
6667 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6668 }
6669 }
6670
6671 func TestNinRepPackedNativeProtoCompactText(t *testing.T) {
6672 seed := time.Now().UnixNano()
6673 popr := math_rand.New(math_rand.NewSource(seed))
6674 p := NewPopulatedNinRepPackedNative(popr, true)
6675 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6676 msg := &NinRepPackedNative{}
6677 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6678 t.Fatalf("seed = %d, err = %v", seed, err)
6679 }
6680 if err := p.VerboseEqual(msg); err != nil {
6681 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6682 }
6683 if !p.Equal(msg) {
6684 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6685 }
6686 }
6687
6688 func TestNidOptStructProtoText(t *testing.T) {
6689 seed := time.Now().UnixNano()
6690 popr := math_rand.New(math_rand.NewSource(seed))
6691 p := NewPopulatedNidOptStruct(popr, true)
6692 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6693 msg := &NidOptStruct{}
6694 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6695 t.Fatalf("seed = %d, err = %v", seed, err)
6696 }
6697 if err := p.VerboseEqual(msg); err != nil {
6698 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6699 }
6700 if !p.Equal(msg) {
6701 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6702 }
6703 }
6704
6705 func TestNidOptStructProtoCompactText(t *testing.T) {
6706 seed := time.Now().UnixNano()
6707 popr := math_rand.New(math_rand.NewSource(seed))
6708 p := NewPopulatedNidOptStruct(popr, true)
6709 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6710 msg := &NidOptStruct{}
6711 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6712 t.Fatalf("seed = %d, err = %v", seed, err)
6713 }
6714 if err := p.VerboseEqual(msg); err != nil {
6715 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6716 }
6717 if !p.Equal(msg) {
6718 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6719 }
6720 }
6721
6722 func TestNinOptStructProtoText(t *testing.T) {
6723 seed := time.Now().UnixNano()
6724 popr := math_rand.New(math_rand.NewSource(seed))
6725 p := NewPopulatedNinOptStruct(popr, true)
6726 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6727 msg := &NinOptStruct{}
6728 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6729 t.Fatalf("seed = %d, err = %v", seed, err)
6730 }
6731 if err := p.VerboseEqual(msg); err != nil {
6732 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6733 }
6734 if !p.Equal(msg) {
6735 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6736 }
6737 }
6738
6739 func TestNinOptStructProtoCompactText(t *testing.T) {
6740 seed := time.Now().UnixNano()
6741 popr := math_rand.New(math_rand.NewSource(seed))
6742 p := NewPopulatedNinOptStruct(popr, true)
6743 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6744 msg := &NinOptStruct{}
6745 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6746 t.Fatalf("seed = %d, err = %v", seed, err)
6747 }
6748 if err := p.VerboseEqual(msg); err != nil {
6749 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6750 }
6751 if !p.Equal(msg) {
6752 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6753 }
6754 }
6755
6756 func TestNidRepStructProtoText(t *testing.T) {
6757 seed := time.Now().UnixNano()
6758 popr := math_rand.New(math_rand.NewSource(seed))
6759 p := NewPopulatedNidRepStruct(popr, true)
6760 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6761 msg := &NidRepStruct{}
6762 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6763 t.Fatalf("seed = %d, err = %v", seed, err)
6764 }
6765 if err := p.VerboseEqual(msg); err != nil {
6766 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6767 }
6768 if !p.Equal(msg) {
6769 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6770 }
6771 }
6772
6773 func TestNidRepStructProtoCompactText(t *testing.T) {
6774 seed := time.Now().UnixNano()
6775 popr := math_rand.New(math_rand.NewSource(seed))
6776 p := NewPopulatedNidRepStruct(popr, true)
6777 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6778 msg := &NidRepStruct{}
6779 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6780 t.Fatalf("seed = %d, err = %v", seed, err)
6781 }
6782 if err := p.VerboseEqual(msg); err != nil {
6783 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6784 }
6785 if !p.Equal(msg) {
6786 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6787 }
6788 }
6789
6790 func TestNinRepStructProtoText(t *testing.T) {
6791 seed := time.Now().UnixNano()
6792 popr := math_rand.New(math_rand.NewSource(seed))
6793 p := NewPopulatedNinRepStruct(popr, true)
6794 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6795 msg := &NinRepStruct{}
6796 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6797 t.Fatalf("seed = %d, err = %v", seed, err)
6798 }
6799 if err := p.VerboseEqual(msg); err != nil {
6800 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6801 }
6802 if !p.Equal(msg) {
6803 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6804 }
6805 }
6806
6807 func TestNinRepStructProtoCompactText(t *testing.T) {
6808 seed := time.Now().UnixNano()
6809 popr := math_rand.New(math_rand.NewSource(seed))
6810 p := NewPopulatedNinRepStruct(popr, true)
6811 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6812 msg := &NinRepStruct{}
6813 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6814 t.Fatalf("seed = %d, err = %v", seed, err)
6815 }
6816 if err := p.VerboseEqual(msg); err != nil {
6817 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6818 }
6819 if !p.Equal(msg) {
6820 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6821 }
6822 }
6823
6824 func TestNidEmbeddedStructProtoText(t *testing.T) {
6825 seed := time.Now().UnixNano()
6826 popr := math_rand.New(math_rand.NewSource(seed))
6827 p := NewPopulatedNidEmbeddedStruct(popr, true)
6828 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6829 msg := &NidEmbeddedStruct{}
6830 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6831 t.Fatalf("seed = %d, err = %v", seed, err)
6832 }
6833 if err := p.VerboseEqual(msg); err != nil {
6834 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6835 }
6836 if !p.Equal(msg) {
6837 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6838 }
6839 }
6840
6841 func TestNidEmbeddedStructProtoCompactText(t *testing.T) {
6842 seed := time.Now().UnixNano()
6843 popr := math_rand.New(math_rand.NewSource(seed))
6844 p := NewPopulatedNidEmbeddedStruct(popr, true)
6845 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6846 msg := &NidEmbeddedStruct{}
6847 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6848 t.Fatalf("seed = %d, err = %v", seed, err)
6849 }
6850 if err := p.VerboseEqual(msg); err != nil {
6851 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6852 }
6853 if !p.Equal(msg) {
6854 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6855 }
6856 }
6857
6858 func TestNinEmbeddedStructProtoText(t *testing.T) {
6859 seed := time.Now().UnixNano()
6860 popr := math_rand.New(math_rand.NewSource(seed))
6861 p := NewPopulatedNinEmbeddedStruct(popr, true)
6862 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6863 msg := &NinEmbeddedStruct{}
6864 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6865 t.Fatalf("seed = %d, err = %v", seed, err)
6866 }
6867 if err := p.VerboseEqual(msg); err != nil {
6868 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6869 }
6870 if !p.Equal(msg) {
6871 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6872 }
6873 }
6874
6875 func TestNinEmbeddedStructProtoCompactText(t *testing.T) {
6876 seed := time.Now().UnixNano()
6877 popr := math_rand.New(math_rand.NewSource(seed))
6878 p := NewPopulatedNinEmbeddedStruct(popr, true)
6879 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6880 msg := &NinEmbeddedStruct{}
6881 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6882 t.Fatalf("seed = %d, err = %v", seed, err)
6883 }
6884 if err := p.VerboseEqual(msg); err != nil {
6885 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6886 }
6887 if !p.Equal(msg) {
6888 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6889 }
6890 }
6891
6892 func TestNidNestedStructProtoText(t *testing.T) {
6893 seed := time.Now().UnixNano()
6894 popr := math_rand.New(math_rand.NewSource(seed))
6895 p := NewPopulatedNidNestedStruct(popr, true)
6896 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6897 msg := &NidNestedStruct{}
6898 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6899 t.Fatalf("seed = %d, err = %v", seed, err)
6900 }
6901 if err := p.VerboseEqual(msg); err != nil {
6902 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6903 }
6904 if !p.Equal(msg) {
6905 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6906 }
6907 }
6908
6909 func TestNidNestedStructProtoCompactText(t *testing.T) {
6910 seed := time.Now().UnixNano()
6911 popr := math_rand.New(math_rand.NewSource(seed))
6912 p := NewPopulatedNidNestedStruct(popr, true)
6913 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6914 msg := &NidNestedStruct{}
6915 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6916 t.Fatalf("seed = %d, err = %v", seed, err)
6917 }
6918 if err := p.VerboseEqual(msg); err != nil {
6919 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6920 }
6921 if !p.Equal(msg) {
6922 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6923 }
6924 }
6925
6926 func TestNinNestedStructProtoText(t *testing.T) {
6927 seed := time.Now().UnixNano()
6928 popr := math_rand.New(math_rand.NewSource(seed))
6929 p := NewPopulatedNinNestedStruct(popr, true)
6930 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6931 msg := &NinNestedStruct{}
6932 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6933 t.Fatalf("seed = %d, err = %v", seed, err)
6934 }
6935 if err := p.VerboseEqual(msg); err != nil {
6936 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6937 }
6938 if !p.Equal(msg) {
6939 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6940 }
6941 }
6942
6943 func TestNinNestedStructProtoCompactText(t *testing.T) {
6944 seed := time.Now().UnixNano()
6945 popr := math_rand.New(math_rand.NewSource(seed))
6946 p := NewPopulatedNinNestedStruct(popr, true)
6947 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6948 msg := &NinNestedStruct{}
6949 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6950 t.Fatalf("seed = %d, err = %v", seed, err)
6951 }
6952 if err := p.VerboseEqual(msg); err != nil {
6953 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6954 }
6955 if !p.Equal(msg) {
6956 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6957 }
6958 }
6959
6960 func TestNidOptCustomProtoText(t *testing.T) {
6961 seed := time.Now().UnixNano()
6962 popr := math_rand.New(math_rand.NewSource(seed))
6963 p := NewPopulatedNidOptCustom(popr, true)
6964 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6965 msg := &NidOptCustom{}
6966 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6967 t.Fatalf("seed = %d, err = %v", seed, err)
6968 }
6969 if err := p.VerboseEqual(msg); err != nil {
6970 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6971 }
6972 if !p.Equal(msg) {
6973 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6974 }
6975 }
6976
6977 func TestNidOptCustomProtoCompactText(t *testing.T) {
6978 seed := time.Now().UnixNano()
6979 popr := math_rand.New(math_rand.NewSource(seed))
6980 p := NewPopulatedNidOptCustom(popr, true)
6981 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
6982 msg := &NidOptCustom{}
6983 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
6984 t.Fatalf("seed = %d, err = %v", seed, err)
6985 }
6986 if err := p.VerboseEqual(msg); err != nil {
6987 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
6988 }
6989 if !p.Equal(msg) {
6990 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
6991 }
6992 }
6993
6994 func TestCustomDashProtoText(t *testing.T) {
6995 seed := time.Now().UnixNano()
6996 popr := math_rand.New(math_rand.NewSource(seed))
6997 p := NewPopulatedCustomDash(popr, true)
6998 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
6999 msg := &CustomDash{}
7000 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7001 t.Fatalf("seed = %d, err = %v", seed, err)
7002 }
7003 if err := p.VerboseEqual(msg); err != nil {
7004 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7005 }
7006 if !p.Equal(msg) {
7007 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7008 }
7009 }
7010
7011 func TestCustomDashProtoCompactText(t *testing.T) {
7012 seed := time.Now().UnixNano()
7013 popr := math_rand.New(math_rand.NewSource(seed))
7014 p := NewPopulatedCustomDash(popr, true)
7015 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7016 msg := &CustomDash{}
7017 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7018 t.Fatalf("seed = %d, err = %v", seed, err)
7019 }
7020 if err := p.VerboseEqual(msg); err != nil {
7021 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7022 }
7023 if !p.Equal(msg) {
7024 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7025 }
7026 }
7027
7028 func TestNinOptCustomProtoText(t *testing.T) {
7029 seed := time.Now().UnixNano()
7030 popr := math_rand.New(math_rand.NewSource(seed))
7031 p := NewPopulatedNinOptCustom(popr, true)
7032 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7033 msg := &NinOptCustom{}
7034 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7035 t.Fatalf("seed = %d, err = %v", seed, err)
7036 }
7037 if err := p.VerboseEqual(msg); err != nil {
7038 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7039 }
7040 if !p.Equal(msg) {
7041 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7042 }
7043 }
7044
7045 func TestNinOptCustomProtoCompactText(t *testing.T) {
7046 seed := time.Now().UnixNano()
7047 popr := math_rand.New(math_rand.NewSource(seed))
7048 p := NewPopulatedNinOptCustom(popr, true)
7049 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7050 msg := &NinOptCustom{}
7051 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7052 t.Fatalf("seed = %d, err = %v", seed, err)
7053 }
7054 if err := p.VerboseEqual(msg); err != nil {
7055 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7056 }
7057 if !p.Equal(msg) {
7058 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7059 }
7060 }
7061
7062 func TestNidRepCustomProtoText(t *testing.T) {
7063 seed := time.Now().UnixNano()
7064 popr := math_rand.New(math_rand.NewSource(seed))
7065 p := NewPopulatedNidRepCustom(popr, true)
7066 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7067 msg := &NidRepCustom{}
7068 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7069 t.Fatalf("seed = %d, err = %v", seed, err)
7070 }
7071 if err := p.VerboseEqual(msg); err != nil {
7072 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7073 }
7074 if !p.Equal(msg) {
7075 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7076 }
7077 }
7078
7079 func TestNidRepCustomProtoCompactText(t *testing.T) {
7080 seed := time.Now().UnixNano()
7081 popr := math_rand.New(math_rand.NewSource(seed))
7082 p := NewPopulatedNidRepCustom(popr, true)
7083 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7084 msg := &NidRepCustom{}
7085 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7086 t.Fatalf("seed = %d, err = %v", seed, err)
7087 }
7088 if err := p.VerboseEqual(msg); err != nil {
7089 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7090 }
7091 if !p.Equal(msg) {
7092 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7093 }
7094 }
7095
7096 func TestNinRepCustomProtoText(t *testing.T) {
7097 seed := time.Now().UnixNano()
7098 popr := math_rand.New(math_rand.NewSource(seed))
7099 p := NewPopulatedNinRepCustom(popr, true)
7100 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7101 msg := &NinRepCustom{}
7102 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7103 t.Fatalf("seed = %d, err = %v", seed, err)
7104 }
7105 if err := p.VerboseEqual(msg); err != nil {
7106 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7107 }
7108 if !p.Equal(msg) {
7109 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7110 }
7111 }
7112
7113 func TestNinRepCustomProtoCompactText(t *testing.T) {
7114 seed := time.Now().UnixNano()
7115 popr := math_rand.New(math_rand.NewSource(seed))
7116 p := NewPopulatedNinRepCustom(popr, true)
7117 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7118 msg := &NinRepCustom{}
7119 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7120 t.Fatalf("seed = %d, err = %v", seed, err)
7121 }
7122 if err := p.VerboseEqual(msg); err != nil {
7123 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7124 }
7125 if !p.Equal(msg) {
7126 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7127 }
7128 }
7129
7130 func TestNinOptNativeUnionProtoText(t *testing.T) {
7131 seed := time.Now().UnixNano()
7132 popr := math_rand.New(math_rand.NewSource(seed))
7133 p := NewPopulatedNinOptNativeUnion(popr, true)
7134 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7135 msg := &NinOptNativeUnion{}
7136 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7137 t.Fatalf("seed = %d, err = %v", seed, err)
7138 }
7139 if err := p.VerboseEqual(msg); err != nil {
7140 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7141 }
7142 if !p.Equal(msg) {
7143 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7144 }
7145 }
7146
7147 func TestNinOptNativeUnionProtoCompactText(t *testing.T) {
7148 seed := time.Now().UnixNano()
7149 popr := math_rand.New(math_rand.NewSource(seed))
7150 p := NewPopulatedNinOptNativeUnion(popr, true)
7151 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7152 msg := &NinOptNativeUnion{}
7153 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7154 t.Fatalf("seed = %d, err = %v", seed, err)
7155 }
7156 if err := p.VerboseEqual(msg); err != nil {
7157 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7158 }
7159 if !p.Equal(msg) {
7160 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7161 }
7162 }
7163
7164 func TestNinOptStructUnionProtoText(t *testing.T) {
7165 seed := time.Now().UnixNano()
7166 popr := math_rand.New(math_rand.NewSource(seed))
7167 p := NewPopulatedNinOptStructUnion(popr, true)
7168 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7169 msg := &NinOptStructUnion{}
7170 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7171 t.Fatalf("seed = %d, err = %v", seed, err)
7172 }
7173 if err := p.VerboseEqual(msg); err != nil {
7174 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7175 }
7176 if !p.Equal(msg) {
7177 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7178 }
7179 }
7180
7181 func TestNinOptStructUnionProtoCompactText(t *testing.T) {
7182 seed := time.Now().UnixNano()
7183 popr := math_rand.New(math_rand.NewSource(seed))
7184 p := NewPopulatedNinOptStructUnion(popr, true)
7185 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7186 msg := &NinOptStructUnion{}
7187 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7188 t.Fatalf("seed = %d, err = %v", seed, err)
7189 }
7190 if err := p.VerboseEqual(msg); err != nil {
7191 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7192 }
7193 if !p.Equal(msg) {
7194 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7195 }
7196 }
7197
7198 func TestNinEmbeddedStructUnionProtoText(t *testing.T) {
7199 seed := time.Now().UnixNano()
7200 popr := math_rand.New(math_rand.NewSource(seed))
7201 p := NewPopulatedNinEmbeddedStructUnion(popr, true)
7202 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7203 msg := &NinEmbeddedStructUnion{}
7204 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7205 t.Fatalf("seed = %d, err = %v", seed, err)
7206 }
7207 if err := p.VerboseEqual(msg); err != nil {
7208 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7209 }
7210 if !p.Equal(msg) {
7211 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7212 }
7213 }
7214
7215 func TestNinEmbeddedStructUnionProtoCompactText(t *testing.T) {
7216 seed := time.Now().UnixNano()
7217 popr := math_rand.New(math_rand.NewSource(seed))
7218 p := NewPopulatedNinEmbeddedStructUnion(popr, true)
7219 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7220 msg := &NinEmbeddedStructUnion{}
7221 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7222 t.Fatalf("seed = %d, err = %v", seed, err)
7223 }
7224 if err := p.VerboseEqual(msg); err != nil {
7225 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7226 }
7227 if !p.Equal(msg) {
7228 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7229 }
7230 }
7231
7232 func TestNinNestedStructUnionProtoText(t *testing.T) {
7233 seed := time.Now().UnixNano()
7234 popr := math_rand.New(math_rand.NewSource(seed))
7235 p := NewPopulatedNinNestedStructUnion(popr, true)
7236 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7237 msg := &NinNestedStructUnion{}
7238 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7239 t.Fatalf("seed = %d, err = %v", seed, err)
7240 }
7241 if err := p.VerboseEqual(msg); err != nil {
7242 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7243 }
7244 if !p.Equal(msg) {
7245 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7246 }
7247 }
7248
7249 func TestNinNestedStructUnionProtoCompactText(t *testing.T) {
7250 seed := time.Now().UnixNano()
7251 popr := math_rand.New(math_rand.NewSource(seed))
7252 p := NewPopulatedNinNestedStructUnion(popr, true)
7253 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7254 msg := &NinNestedStructUnion{}
7255 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7256 t.Fatalf("seed = %d, err = %v", seed, err)
7257 }
7258 if err := p.VerboseEqual(msg); err != nil {
7259 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7260 }
7261 if !p.Equal(msg) {
7262 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7263 }
7264 }
7265
7266 func TestTreeProtoText(t *testing.T) {
7267 seed := time.Now().UnixNano()
7268 popr := math_rand.New(math_rand.NewSource(seed))
7269 p := NewPopulatedTree(popr, true)
7270 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7271 msg := &Tree{}
7272 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7273 t.Fatalf("seed = %d, err = %v", seed, err)
7274 }
7275 if err := p.VerboseEqual(msg); err != nil {
7276 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7277 }
7278 if !p.Equal(msg) {
7279 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7280 }
7281 }
7282
7283 func TestTreeProtoCompactText(t *testing.T) {
7284 seed := time.Now().UnixNano()
7285 popr := math_rand.New(math_rand.NewSource(seed))
7286 p := NewPopulatedTree(popr, true)
7287 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7288 msg := &Tree{}
7289 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7290 t.Fatalf("seed = %d, err = %v", seed, err)
7291 }
7292 if err := p.VerboseEqual(msg); err != nil {
7293 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7294 }
7295 if !p.Equal(msg) {
7296 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7297 }
7298 }
7299
7300 func TestOrBranchProtoText(t *testing.T) {
7301 seed := time.Now().UnixNano()
7302 popr := math_rand.New(math_rand.NewSource(seed))
7303 p := NewPopulatedOrBranch(popr, true)
7304 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7305 msg := &OrBranch{}
7306 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7307 t.Fatalf("seed = %d, err = %v", seed, err)
7308 }
7309 if err := p.VerboseEqual(msg); err != nil {
7310 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7311 }
7312 if !p.Equal(msg) {
7313 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7314 }
7315 }
7316
7317 func TestOrBranchProtoCompactText(t *testing.T) {
7318 seed := time.Now().UnixNano()
7319 popr := math_rand.New(math_rand.NewSource(seed))
7320 p := NewPopulatedOrBranch(popr, true)
7321 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7322 msg := &OrBranch{}
7323 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7324 t.Fatalf("seed = %d, err = %v", seed, err)
7325 }
7326 if err := p.VerboseEqual(msg); err != nil {
7327 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7328 }
7329 if !p.Equal(msg) {
7330 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7331 }
7332 }
7333
7334 func TestAndBranchProtoText(t *testing.T) {
7335 seed := time.Now().UnixNano()
7336 popr := math_rand.New(math_rand.NewSource(seed))
7337 p := NewPopulatedAndBranch(popr, true)
7338 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7339 msg := &AndBranch{}
7340 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7341 t.Fatalf("seed = %d, err = %v", seed, err)
7342 }
7343 if err := p.VerboseEqual(msg); err != nil {
7344 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7345 }
7346 if !p.Equal(msg) {
7347 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7348 }
7349 }
7350
7351 func TestAndBranchProtoCompactText(t *testing.T) {
7352 seed := time.Now().UnixNano()
7353 popr := math_rand.New(math_rand.NewSource(seed))
7354 p := NewPopulatedAndBranch(popr, true)
7355 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7356 msg := &AndBranch{}
7357 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7358 t.Fatalf("seed = %d, err = %v", seed, err)
7359 }
7360 if err := p.VerboseEqual(msg); err != nil {
7361 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7362 }
7363 if !p.Equal(msg) {
7364 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7365 }
7366 }
7367
7368 func TestLeafProtoText(t *testing.T) {
7369 seed := time.Now().UnixNano()
7370 popr := math_rand.New(math_rand.NewSource(seed))
7371 p := NewPopulatedLeaf(popr, true)
7372 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7373 msg := &Leaf{}
7374 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7375 t.Fatalf("seed = %d, err = %v", seed, err)
7376 }
7377 if err := p.VerboseEqual(msg); err != nil {
7378 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7379 }
7380 if !p.Equal(msg) {
7381 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7382 }
7383 }
7384
7385 func TestLeafProtoCompactText(t *testing.T) {
7386 seed := time.Now().UnixNano()
7387 popr := math_rand.New(math_rand.NewSource(seed))
7388 p := NewPopulatedLeaf(popr, true)
7389 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7390 msg := &Leaf{}
7391 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7392 t.Fatalf("seed = %d, err = %v", seed, err)
7393 }
7394 if err := p.VerboseEqual(msg); err != nil {
7395 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7396 }
7397 if !p.Equal(msg) {
7398 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7399 }
7400 }
7401
7402 func TestDeepTreeProtoText(t *testing.T) {
7403 seed := time.Now().UnixNano()
7404 popr := math_rand.New(math_rand.NewSource(seed))
7405 p := NewPopulatedDeepTree(popr, true)
7406 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7407 msg := &DeepTree{}
7408 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7409 t.Fatalf("seed = %d, err = %v", seed, err)
7410 }
7411 if err := p.VerboseEqual(msg); err != nil {
7412 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7413 }
7414 if !p.Equal(msg) {
7415 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7416 }
7417 }
7418
7419 func TestDeepTreeProtoCompactText(t *testing.T) {
7420 seed := time.Now().UnixNano()
7421 popr := math_rand.New(math_rand.NewSource(seed))
7422 p := NewPopulatedDeepTree(popr, true)
7423 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7424 msg := &DeepTree{}
7425 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7426 t.Fatalf("seed = %d, err = %v", seed, err)
7427 }
7428 if err := p.VerboseEqual(msg); err != nil {
7429 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7430 }
7431 if !p.Equal(msg) {
7432 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7433 }
7434 }
7435
7436 func TestADeepBranchProtoText(t *testing.T) {
7437 seed := time.Now().UnixNano()
7438 popr := math_rand.New(math_rand.NewSource(seed))
7439 p := NewPopulatedADeepBranch(popr, true)
7440 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7441 msg := &ADeepBranch{}
7442 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7443 t.Fatalf("seed = %d, err = %v", seed, err)
7444 }
7445 if err := p.VerboseEqual(msg); err != nil {
7446 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7447 }
7448 if !p.Equal(msg) {
7449 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7450 }
7451 }
7452
7453 func TestADeepBranchProtoCompactText(t *testing.T) {
7454 seed := time.Now().UnixNano()
7455 popr := math_rand.New(math_rand.NewSource(seed))
7456 p := NewPopulatedADeepBranch(popr, true)
7457 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7458 msg := &ADeepBranch{}
7459 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7460 t.Fatalf("seed = %d, err = %v", seed, err)
7461 }
7462 if err := p.VerboseEqual(msg); err != nil {
7463 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7464 }
7465 if !p.Equal(msg) {
7466 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7467 }
7468 }
7469
7470 func TestAndDeepBranchProtoText(t *testing.T) {
7471 seed := time.Now().UnixNano()
7472 popr := math_rand.New(math_rand.NewSource(seed))
7473 p := NewPopulatedAndDeepBranch(popr, true)
7474 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7475 msg := &AndDeepBranch{}
7476 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7477 t.Fatalf("seed = %d, err = %v", seed, err)
7478 }
7479 if err := p.VerboseEqual(msg); err != nil {
7480 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7481 }
7482 if !p.Equal(msg) {
7483 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7484 }
7485 }
7486
7487 func TestAndDeepBranchProtoCompactText(t *testing.T) {
7488 seed := time.Now().UnixNano()
7489 popr := math_rand.New(math_rand.NewSource(seed))
7490 p := NewPopulatedAndDeepBranch(popr, true)
7491 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7492 msg := &AndDeepBranch{}
7493 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7494 t.Fatalf("seed = %d, err = %v", seed, err)
7495 }
7496 if err := p.VerboseEqual(msg); err != nil {
7497 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7498 }
7499 if !p.Equal(msg) {
7500 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7501 }
7502 }
7503
7504 func TestDeepLeafProtoText(t *testing.T) {
7505 seed := time.Now().UnixNano()
7506 popr := math_rand.New(math_rand.NewSource(seed))
7507 p := NewPopulatedDeepLeaf(popr, true)
7508 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7509 msg := &DeepLeaf{}
7510 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7511 t.Fatalf("seed = %d, err = %v", seed, err)
7512 }
7513 if err := p.VerboseEqual(msg); err != nil {
7514 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7515 }
7516 if !p.Equal(msg) {
7517 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7518 }
7519 }
7520
7521 func TestDeepLeafProtoCompactText(t *testing.T) {
7522 seed := time.Now().UnixNano()
7523 popr := math_rand.New(math_rand.NewSource(seed))
7524 p := NewPopulatedDeepLeaf(popr, true)
7525 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7526 msg := &DeepLeaf{}
7527 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7528 t.Fatalf("seed = %d, err = %v", seed, err)
7529 }
7530 if err := p.VerboseEqual(msg); err != nil {
7531 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7532 }
7533 if !p.Equal(msg) {
7534 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7535 }
7536 }
7537
7538 func TestNilProtoText(t *testing.T) {
7539 seed := time.Now().UnixNano()
7540 popr := math_rand.New(math_rand.NewSource(seed))
7541 p := NewPopulatedNil(popr, true)
7542 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7543 msg := &Nil{}
7544 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7545 t.Fatalf("seed = %d, err = %v", seed, err)
7546 }
7547 if err := p.VerboseEqual(msg); err != nil {
7548 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7549 }
7550 if !p.Equal(msg) {
7551 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7552 }
7553 }
7554
7555 func TestNilProtoCompactText(t *testing.T) {
7556 seed := time.Now().UnixNano()
7557 popr := math_rand.New(math_rand.NewSource(seed))
7558 p := NewPopulatedNil(popr, true)
7559 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7560 msg := &Nil{}
7561 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7562 t.Fatalf("seed = %d, err = %v", seed, err)
7563 }
7564 if err := p.VerboseEqual(msg); err != nil {
7565 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7566 }
7567 if !p.Equal(msg) {
7568 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7569 }
7570 }
7571
7572 func TestNidOptEnumProtoText(t *testing.T) {
7573 seed := time.Now().UnixNano()
7574 popr := math_rand.New(math_rand.NewSource(seed))
7575 p := NewPopulatedNidOptEnum(popr, true)
7576 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7577 msg := &NidOptEnum{}
7578 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7579 t.Fatalf("seed = %d, err = %v", seed, err)
7580 }
7581 if err := p.VerboseEqual(msg); err != nil {
7582 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7583 }
7584 if !p.Equal(msg) {
7585 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7586 }
7587 }
7588
7589 func TestNidOptEnumProtoCompactText(t *testing.T) {
7590 seed := time.Now().UnixNano()
7591 popr := math_rand.New(math_rand.NewSource(seed))
7592 p := NewPopulatedNidOptEnum(popr, true)
7593 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7594 msg := &NidOptEnum{}
7595 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7596 t.Fatalf("seed = %d, err = %v", seed, err)
7597 }
7598 if err := p.VerboseEqual(msg); err != nil {
7599 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7600 }
7601 if !p.Equal(msg) {
7602 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7603 }
7604 }
7605
7606 func TestNinOptEnumProtoText(t *testing.T) {
7607 seed := time.Now().UnixNano()
7608 popr := math_rand.New(math_rand.NewSource(seed))
7609 p := NewPopulatedNinOptEnum(popr, true)
7610 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7611 msg := &NinOptEnum{}
7612 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7613 t.Fatalf("seed = %d, err = %v", seed, err)
7614 }
7615 if err := p.VerboseEqual(msg); err != nil {
7616 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7617 }
7618 if !p.Equal(msg) {
7619 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7620 }
7621 }
7622
7623 func TestNinOptEnumProtoCompactText(t *testing.T) {
7624 seed := time.Now().UnixNano()
7625 popr := math_rand.New(math_rand.NewSource(seed))
7626 p := NewPopulatedNinOptEnum(popr, true)
7627 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7628 msg := &NinOptEnum{}
7629 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7630 t.Fatalf("seed = %d, err = %v", seed, err)
7631 }
7632 if err := p.VerboseEqual(msg); err != nil {
7633 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7634 }
7635 if !p.Equal(msg) {
7636 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7637 }
7638 }
7639
7640 func TestNidRepEnumProtoText(t *testing.T) {
7641 seed := time.Now().UnixNano()
7642 popr := math_rand.New(math_rand.NewSource(seed))
7643 p := NewPopulatedNidRepEnum(popr, true)
7644 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7645 msg := &NidRepEnum{}
7646 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7647 t.Fatalf("seed = %d, err = %v", seed, err)
7648 }
7649 if err := p.VerboseEqual(msg); err != nil {
7650 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7651 }
7652 if !p.Equal(msg) {
7653 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7654 }
7655 }
7656
7657 func TestNidRepEnumProtoCompactText(t *testing.T) {
7658 seed := time.Now().UnixNano()
7659 popr := math_rand.New(math_rand.NewSource(seed))
7660 p := NewPopulatedNidRepEnum(popr, true)
7661 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7662 msg := &NidRepEnum{}
7663 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7664 t.Fatalf("seed = %d, err = %v", seed, err)
7665 }
7666 if err := p.VerboseEqual(msg); err != nil {
7667 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7668 }
7669 if !p.Equal(msg) {
7670 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7671 }
7672 }
7673
7674 func TestNinRepEnumProtoText(t *testing.T) {
7675 seed := time.Now().UnixNano()
7676 popr := math_rand.New(math_rand.NewSource(seed))
7677 p := NewPopulatedNinRepEnum(popr, true)
7678 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7679 msg := &NinRepEnum{}
7680 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7681 t.Fatalf("seed = %d, err = %v", seed, err)
7682 }
7683 if err := p.VerboseEqual(msg); err != nil {
7684 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7685 }
7686 if !p.Equal(msg) {
7687 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7688 }
7689 }
7690
7691 func TestNinRepEnumProtoCompactText(t *testing.T) {
7692 seed := time.Now().UnixNano()
7693 popr := math_rand.New(math_rand.NewSource(seed))
7694 p := NewPopulatedNinRepEnum(popr, true)
7695 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7696 msg := &NinRepEnum{}
7697 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7698 t.Fatalf("seed = %d, err = %v", seed, err)
7699 }
7700 if err := p.VerboseEqual(msg); err != nil {
7701 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7702 }
7703 if !p.Equal(msg) {
7704 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7705 }
7706 }
7707
7708 func TestNinOptEnumDefaultProtoText(t *testing.T) {
7709 seed := time.Now().UnixNano()
7710 popr := math_rand.New(math_rand.NewSource(seed))
7711 p := NewPopulatedNinOptEnumDefault(popr, true)
7712 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7713 msg := &NinOptEnumDefault{}
7714 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7715 t.Fatalf("seed = %d, err = %v", seed, err)
7716 }
7717 if err := p.VerboseEqual(msg); err != nil {
7718 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7719 }
7720 if !p.Equal(msg) {
7721 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7722 }
7723 }
7724
7725 func TestNinOptEnumDefaultProtoCompactText(t *testing.T) {
7726 seed := time.Now().UnixNano()
7727 popr := math_rand.New(math_rand.NewSource(seed))
7728 p := NewPopulatedNinOptEnumDefault(popr, true)
7729 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7730 msg := &NinOptEnumDefault{}
7731 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7732 t.Fatalf("seed = %d, err = %v", seed, err)
7733 }
7734 if err := p.VerboseEqual(msg); err != nil {
7735 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7736 }
7737 if !p.Equal(msg) {
7738 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7739 }
7740 }
7741
7742 func TestAnotherNinOptEnumProtoText(t *testing.T) {
7743 seed := time.Now().UnixNano()
7744 popr := math_rand.New(math_rand.NewSource(seed))
7745 p := NewPopulatedAnotherNinOptEnum(popr, true)
7746 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7747 msg := &AnotherNinOptEnum{}
7748 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7749 t.Fatalf("seed = %d, err = %v", seed, err)
7750 }
7751 if err := p.VerboseEqual(msg); err != nil {
7752 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7753 }
7754 if !p.Equal(msg) {
7755 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7756 }
7757 }
7758
7759 func TestAnotherNinOptEnumProtoCompactText(t *testing.T) {
7760 seed := time.Now().UnixNano()
7761 popr := math_rand.New(math_rand.NewSource(seed))
7762 p := NewPopulatedAnotherNinOptEnum(popr, true)
7763 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7764 msg := &AnotherNinOptEnum{}
7765 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7766 t.Fatalf("seed = %d, err = %v", seed, err)
7767 }
7768 if err := p.VerboseEqual(msg); err != nil {
7769 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7770 }
7771 if !p.Equal(msg) {
7772 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7773 }
7774 }
7775
7776 func TestAnotherNinOptEnumDefaultProtoText(t *testing.T) {
7777 seed := time.Now().UnixNano()
7778 popr := math_rand.New(math_rand.NewSource(seed))
7779 p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
7780 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7781 msg := &AnotherNinOptEnumDefault{}
7782 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7783 t.Fatalf("seed = %d, err = %v", seed, err)
7784 }
7785 if err := p.VerboseEqual(msg); err != nil {
7786 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7787 }
7788 if !p.Equal(msg) {
7789 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7790 }
7791 }
7792
7793 func TestAnotherNinOptEnumDefaultProtoCompactText(t *testing.T) {
7794 seed := time.Now().UnixNano()
7795 popr := math_rand.New(math_rand.NewSource(seed))
7796 p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
7797 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7798 msg := &AnotherNinOptEnumDefault{}
7799 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7800 t.Fatalf("seed = %d, err = %v", seed, err)
7801 }
7802 if err := p.VerboseEqual(msg); err != nil {
7803 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7804 }
7805 if !p.Equal(msg) {
7806 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7807 }
7808 }
7809
7810 func TestTimerProtoText(t *testing.T) {
7811 seed := time.Now().UnixNano()
7812 popr := math_rand.New(math_rand.NewSource(seed))
7813 p := NewPopulatedTimer(popr, true)
7814 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7815 msg := &Timer{}
7816 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7817 t.Fatalf("seed = %d, err = %v", seed, err)
7818 }
7819 if err := p.VerboseEqual(msg); err != nil {
7820 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7821 }
7822 if !p.Equal(msg) {
7823 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7824 }
7825 }
7826
7827 func TestTimerProtoCompactText(t *testing.T) {
7828 seed := time.Now().UnixNano()
7829 popr := math_rand.New(math_rand.NewSource(seed))
7830 p := NewPopulatedTimer(popr, true)
7831 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7832 msg := &Timer{}
7833 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7834 t.Fatalf("seed = %d, err = %v", seed, err)
7835 }
7836 if err := p.VerboseEqual(msg); err != nil {
7837 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7838 }
7839 if !p.Equal(msg) {
7840 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7841 }
7842 }
7843
7844 func TestMyExtendableProtoText(t *testing.T) {
7845 seed := time.Now().UnixNano()
7846 popr := math_rand.New(math_rand.NewSource(seed))
7847 p := NewPopulatedMyExtendable(popr, true)
7848 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7849 msg := &MyExtendable{}
7850 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7851 t.Fatalf("seed = %d, err = %v", seed, err)
7852 }
7853 if err := p.VerboseEqual(msg); err != nil {
7854 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7855 }
7856 if !p.Equal(msg) {
7857 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7858 }
7859 }
7860
7861 func TestMyExtendableProtoCompactText(t *testing.T) {
7862 seed := time.Now().UnixNano()
7863 popr := math_rand.New(math_rand.NewSource(seed))
7864 p := NewPopulatedMyExtendable(popr, true)
7865 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7866 msg := &MyExtendable{}
7867 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7868 t.Fatalf("seed = %d, err = %v", seed, err)
7869 }
7870 if err := p.VerboseEqual(msg); err != nil {
7871 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7872 }
7873 if !p.Equal(msg) {
7874 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7875 }
7876 }
7877
7878 func TestOtherExtenableProtoText(t *testing.T) {
7879 seed := time.Now().UnixNano()
7880 popr := math_rand.New(math_rand.NewSource(seed))
7881 p := NewPopulatedOtherExtenable(popr, true)
7882 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7883 msg := &OtherExtenable{}
7884 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7885 t.Fatalf("seed = %d, err = %v", seed, err)
7886 }
7887 if err := p.VerboseEqual(msg); err != nil {
7888 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7889 }
7890 if !p.Equal(msg) {
7891 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7892 }
7893 }
7894
7895 func TestOtherExtenableProtoCompactText(t *testing.T) {
7896 seed := time.Now().UnixNano()
7897 popr := math_rand.New(math_rand.NewSource(seed))
7898 p := NewPopulatedOtherExtenable(popr, true)
7899 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7900 msg := &OtherExtenable{}
7901 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7902 t.Fatalf("seed = %d, err = %v", seed, err)
7903 }
7904 if err := p.VerboseEqual(msg); err != nil {
7905 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7906 }
7907 if !p.Equal(msg) {
7908 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7909 }
7910 }
7911
7912 func TestNestedDefinitionProtoText(t *testing.T) {
7913 seed := time.Now().UnixNano()
7914 popr := math_rand.New(math_rand.NewSource(seed))
7915 p := NewPopulatedNestedDefinition(popr, true)
7916 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7917 msg := &NestedDefinition{}
7918 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7919 t.Fatalf("seed = %d, err = %v", seed, err)
7920 }
7921 if err := p.VerboseEqual(msg); err != nil {
7922 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7923 }
7924 if !p.Equal(msg) {
7925 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7926 }
7927 }
7928
7929 func TestNestedDefinitionProtoCompactText(t *testing.T) {
7930 seed := time.Now().UnixNano()
7931 popr := math_rand.New(math_rand.NewSource(seed))
7932 p := NewPopulatedNestedDefinition(popr, true)
7933 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7934 msg := &NestedDefinition{}
7935 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7936 t.Fatalf("seed = %d, err = %v", seed, err)
7937 }
7938 if err := p.VerboseEqual(msg); err != nil {
7939 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7940 }
7941 if !p.Equal(msg) {
7942 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7943 }
7944 }
7945
7946 func TestNestedDefinition_NestedMessageProtoText(t *testing.T) {
7947 seed := time.Now().UnixNano()
7948 popr := math_rand.New(math_rand.NewSource(seed))
7949 p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
7950 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7951 msg := &NestedDefinition_NestedMessage{}
7952 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7953 t.Fatalf("seed = %d, err = %v", seed, err)
7954 }
7955 if err := p.VerboseEqual(msg); err != nil {
7956 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7957 }
7958 if !p.Equal(msg) {
7959 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7960 }
7961 }
7962
7963 func TestNestedDefinition_NestedMessageProtoCompactText(t *testing.T) {
7964 seed := time.Now().UnixNano()
7965 popr := math_rand.New(math_rand.NewSource(seed))
7966 p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
7967 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
7968 msg := &NestedDefinition_NestedMessage{}
7969 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7970 t.Fatalf("seed = %d, err = %v", seed, err)
7971 }
7972 if err := p.VerboseEqual(msg); err != nil {
7973 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7974 }
7975 if !p.Equal(msg) {
7976 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7977 }
7978 }
7979
7980 func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoText(t *testing.T) {
7981 seed := time.Now().UnixNano()
7982 popr := math_rand.New(math_rand.NewSource(seed))
7983 p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
7984 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
7985 msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
7986 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
7987 t.Fatalf("seed = %d, err = %v", seed, err)
7988 }
7989 if err := p.VerboseEqual(msg); err != nil {
7990 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
7991 }
7992 if !p.Equal(msg) {
7993 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
7994 }
7995 }
7996
7997 func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoCompactText(t *testing.T) {
7998 seed := time.Now().UnixNano()
7999 popr := math_rand.New(math_rand.NewSource(seed))
8000 p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
8001 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8002 msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
8003 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8004 t.Fatalf("seed = %d, err = %v", seed, err)
8005 }
8006 if err := p.VerboseEqual(msg); err != nil {
8007 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8008 }
8009 if !p.Equal(msg) {
8010 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8011 }
8012 }
8013
8014 func TestNestedScopeProtoText(t *testing.T) {
8015 seed := time.Now().UnixNano()
8016 popr := math_rand.New(math_rand.NewSource(seed))
8017 p := NewPopulatedNestedScope(popr, true)
8018 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8019 msg := &NestedScope{}
8020 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8021 t.Fatalf("seed = %d, err = %v", seed, err)
8022 }
8023 if err := p.VerboseEqual(msg); err != nil {
8024 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8025 }
8026 if !p.Equal(msg) {
8027 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8028 }
8029 }
8030
8031 func TestNestedScopeProtoCompactText(t *testing.T) {
8032 seed := time.Now().UnixNano()
8033 popr := math_rand.New(math_rand.NewSource(seed))
8034 p := NewPopulatedNestedScope(popr, true)
8035 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8036 msg := &NestedScope{}
8037 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8038 t.Fatalf("seed = %d, err = %v", seed, err)
8039 }
8040 if err := p.VerboseEqual(msg); err != nil {
8041 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8042 }
8043 if !p.Equal(msg) {
8044 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8045 }
8046 }
8047
8048 func TestNinOptNativeDefaultProtoText(t *testing.T) {
8049 seed := time.Now().UnixNano()
8050 popr := math_rand.New(math_rand.NewSource(seed))
8051 p := NewPopulatedNinOptNativeDefault(popr, true)
8052 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8053 msg := &NinOptNativeDefault{}
8054 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8055 t.Fatalf("seed = %d, err = %v", seed, err)
8056 }
8057 if err := p.VerboseEqual(msg); err != nil {
8058 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8059 }
8060 if !p.Equal(msg) {
8061 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8062 }
8063 }
8064
8065 func TestNinOptNativeDefaultProtoCompactText(t *testing.T) {
8066 seed := time.Now().UnixNano()
8067 popr := math_rand.New(math_rand.NewSource(seed))
8068 p := NewPopulatedNinOptNativeDefault(popr, true)
8069 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8070 msg := &NinOptNativeDefault{}
8071 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8072 t.Fatalf("seed = %d, err = %v", seed, err)
8073 }
8074 if err := p.VerboseEqual(msg); err != nil {
8075 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8076 }
8077 if !p.Equal(msg) {
8078 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8079 }
8080 }
8081
8082 func TestCustomContainerProtoText(t *testing.T) {
8083 seed := time.Now().UnixNano()
8084 popr := math_rand.New(math_rand.NewSource(seed))
8085 p := NewPopulatedCustomContainer(popr, true)
8086 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8087 msg := &CustomContainer{}
8088 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8089 t.Fatalf("seed = %d, err = %v", seed, err)
8090 }
8091 if err := p.VerboseEqual(msg); err != nil {
8092 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8093 }
8094 if !p.Equal(msg) {
8095 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8096 }
8097 }
8098
8099 func TestCustomContainerProtoCompactText(t *testing.T) {
8100 seed := time.Now().UnixNano()
8101 popr := math_rand.New(math_rand.NewSource(seed))
8102 p := NewPopulatedCustomContainer(popr, true)
8103 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8104 msg := &CustomContainer{}
8105 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8106 t.Fatalf("seed = %d, err = %v", seed, err)
8107 }
8108 if err := p.VerboseEqual(msg); err != nil {
8109 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8110 }
8111 if !p.Equal(msg) {
8112 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8113 }
8114 }
8115
8116 func TestCustomNameNidOptNativeProtoText(t *testing.T) {
8117 seed := time.Now().UnixNano()
8118 popr := math_rand.New(math_rand.NewSource(seed))
8119 p := NewPopulatedCustomNameNidOptNative(popr, true)
8120 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8121 msg := &CustomNameNidOptNative{}
8122 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8123 t.Fatalf("seed = %d, err = %v", seed, err)
8124 }
8125 if err := p.VerboseEqual(msg); err != nil {
8126 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8127 }
8128 if !p.Equal(msg) {
8129 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8130 }
8131 }
8132
8133 func TestCustomNameNidOptNativeProtoCompactText(t *testing.T) {
8134 seed := time.Now().UnixNano()
8135 popr := math_rand.New(math_rand.NewSource(seed))
8136 p := NewPopulatedCustomNameNidOptNative(popr, true)
8137 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8138 msg := &CustomNameNidOptNative{}
8139 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8140 t.Fatalf("seed = %d, err = %v", seed, err)
8141 }
8142 if err := p.VerboseEqual(msg); err != nil {
8143 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8144 }
8145 if !p.Equal(msg) {
8146 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8147 }
8148 }
8149
8150 func TestCustomNameNinOptNativeProtoText(t *testing.T) {
8151 seed := time.Now().UnixNano()
8152 popr := math_rand.New(math_rand.NewSource(seed))
8153 p := NewPopulatedCustomNameNinOptNative(popr, true)
8154 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8155 msg := &CustomNameNinOptNative{}
8156 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8157 t.Fatalf("seed = %d, err = %v", seed, err)
8158 }
8159 if err := p.VerboseEqual(msg); err != nil {
8160 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8161 }
8162 if !p.Equal(msg) {
8163 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8164 }
8165 }
8166
8167 func TestCustomNameNinOptNativeProtoCompactText(t *testing.T) {
8168 seed := time.Now().UnixNano()
8169 popr := math_rand.New(math_rand.NewSource(seed))
8170 p := NewPopulatedCustomNameNinOptNative(popr, true)
8171 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8172 msg := &CustomNameNinOptNative{}
8173 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8174 t.Fatalf("seed = %d, err = %v", seed, err)
8175 }
8176 if err := p.VerboseEqual(msg); err != nil {
8177 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8178 }
8179 if !p.Equal(msg) {
8180 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8181 }
8182 }
8183
8184 func TestCustomNameNinRepNativeProtoText(t *testing.T) {
8185 seed := time.Now().UnixNano()
8186 popr := math_rand.New(math_rand.NewSource(seed))
8187 p := NewPopulatedCustomNameNinRepNative(popr, true)
8188 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8189 msg := &CustomNameNinRepNative{}
8190 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8191 t.Fatalf("seed = %d, err = %v", seed, err)
8192 }
8193 if err := p.VerboseEqual(msg); err != nil {
8194 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8195 }
8196 if !p.Equal(msg) {
8197 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8198 }
8199 }
8200
8201 func TestCustomNameNinRepNativeProtoCompactText(t *testing.T) {
8202 seed := time.Now().UnixNano()
8203 popr := math_rand.New(math_rand.NewSource(seed))
8204 p := NewPopulatedCustomNameNinRepNative(popr, true)
8205 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8206 msg := &CustomNameNinRepNative{}
8207 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8208 t.Fatalf("seed = %d, err = %v", seed, err)
8209 }
8210 if err := p.VerboseEqual(msg); err != nil {
8211 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8212 }
8213 if !p.Equal(msg) {
8214 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8215 }
8216 }
8217
8218 func TestCustomNameNinStructProtoText(t *testing.T) {
8219 seed := time.Now().UnixNano()
8220 popr := math_rand.New(math_rand.NewSource(seed))
8221 p := NewPopulatedCustomNameNinStruct(popr, true)
8222 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8223 msg := &CustomNameNinStruct{}
8224 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8225 t.Fatalf("seed = %d, err = %v", seed, err)
8226 }
8227 if err := p.VerboseEqual(msg); err != nil {
8228 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8229 }
8230 if !p.Equal(msg) {
8231 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8232 }
8233 }
8234
8235 func TestCustomNameNinStructProtoCompactText(t *testing.T) {
8236 seed := time.Now().UnixNano()
8237 popr := math_rand.New(math_rand.NewSource(seed))
8238 p := NewPopulatedCustomNameNinStruct(popr, true)
8239 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8240 msg := &CustomNameNinStruct{}
8241 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8242 t.Fatalf("seed = %d, err = %v", seed, err)
8243 }
8244 if err := p.VerboseEqual(msg); err != nil {
8245 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8246 }
8247 if !p.Equal(msg) {
8248 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8249 }
8250 }
8251
8252 func TestCustomNameCustomTypeProtoText(t *testing.T) {
8253 seed := time.Now().UnixNano()
8254 popr := math_rand.New(math_rand.NewSource(seed))
8255 p := NewPopulatedCustomNameCustomType(popr, true)
8256 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8257 msg := &CustomNameCustomType{}
8258 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8259 t.Fatalf("seed = %d, err = %v", seed, err)
8260 }
8261 if err := p.VerboseEqual(msg); err != nil {
8262 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8263 }
8264 if !p.Equal(msg) {
8265 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8266 }
8267 }
8268
8269 func TestCustomNameCustomTypeProtoCompactText(t *testing.T) {
8270 seed := time.Now().UnixNano()
8271 popr := math_rand.New(math_rand.NewSource(seed))
8272 p := NewPopulatedCustomNameCustomType(popr, true)
8273 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8274 msg := &CustomNameCustomType{}
8275 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8276 t.Fatalf("seed = %d, err = %v", seed, err)
8277 }
8278 if err := p.VerboseEqual(msg); err != nil {
8279 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8280 }
8281 if !p.Equal(msg) {
8282 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8283 }
8284 }
8285
8286 func TestCustomNameNinEmbeddedStructUnionProtoText(t *testing.T) {
8287 seed := time.Now().UnixNano()
8288 popr := math_rand.New(math_rand.NewSource(seed))
8289 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
8290 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8291 msg := &CustomNameNinEmbeddedStructUnion{}
8292 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8293 t.Fatalf("seed = %d, err = %v", seed, err)
8294 }
8295 if err := p.VerboseEqual(msg); err != nil {
8296 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8297 }
8298 if !p.Equal(msg) {
8299 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8300 }
8301 }
8302
8303 func TestCustomNameNinEmbeddedStructUnionProtoCompactText(t *testing.T) {
8304 seed := time.Now().UnixNano()
8305 popr := math_rand.New(math_rand.NewSource(seed))
8306 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
8307 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8308 msg := &CustomNameNinEmbeddedStructUnion{}
8309 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8310 t.Fatalf("seed = %d, err = %v", seed, err)
8311 }
8312 if err := p.VerboseEqual(msg); err != nil {
8313 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8314 }
8315 if !p.Equal(msg) {
8316 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8317 }
8318 }
8319
8320 func TestCustomNameEnumProtoText(t *testing.T) {
8321 seed := time.Now().UnixNano()
8322 popr := math_rand.New(math_rand.NewSource(seed))
8323 p := NewPopulatedCustomNameEnum(popr, true)
8324 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8325 msg := &CustomNameEnum{}
8326 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8327 t.Fatalf("seed = %d, err = %v", seed, err)
8328 }
8329 if err := p.VerboseEqual(msg); err != nil {
8330 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8331 }
8332 if !p.Equal(msg) {
8333 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8334 }
8335 }
8336
8337 func TestCustomNameEnumProtoCompactText(t *testing.T) {
8338 seed := time.Now().UnixNano()
8339 popr := math_rand.New(math_rand.NewSource(seed))
8340 p := NewPopulatedCustomNameEnum(popr, true)
8341 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8342 msg := &CustomNameEnum{}
8343 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8344 t.Fatalf("seed = %d, err = %v", seed, err)
8345 }
8346 if err := p.VerboseEqual(msg); err != nil {
8347 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8348 }
8349 if !p.Equal(msg) {
8350 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8351 }
8352 }
8353
8354 func TestNoExtensionsMapProtoText(t *testing.T) {
8355 seed := time.Now().UnixNano()
8356 popr := math_rand.New(math_rand.NewSource(seed))
8357 p := NewPopulatedNoExtensionsMap(popr, true)
8358 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8359 msg := &NoExtensionsMap{}
8360 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8361 t.Fatalf("seed = %d, err = %v", seed, err)
8362 }
8363 if err := p.VerboseEqual(msg); err != nil {
8364 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8365 }
8366 if !p.Equal(msg) {
8367 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8368 }
8369 }
8370
8371 func TestNoExtensionsMapProtoCompactText(t *testing.T) {
8372 seed := time.Now().UnixNano()
8373 popr := math_rand.New(math_rand.NewSource(seed))
8374 p := NewPopulatedNoExtensionsMap(popr, true)
8375 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8376 msg := &NoExtensionsMap{}
8377 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8378 t.Fatalf("seed = %d, err = %v", seed, err)
8379 }
8380 if err := p.VerboseEqual(msg); err != nil {
8381 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8382 }
8383 if !p.Equal(msg) {
8384 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8385 }
8386 }
8387
8388 func TestUnrecognizedProtoText(t *testing.T) {
8389 seed := time.Now().UnixNano()
8390 popr := math_rand.New(math_rand.NewSource(seed))
8391 p := NewPopulatedUnrecognized(popr, true)
8392 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8393 msg := &Unrecognized{}
8394 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8395 t.Fatalf("seed = %d, err = %v", seed, err)
8396 }
8397 if err := p.VerboseEqual(msg); err != nil {
8398 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8399 }
8400 if !p.Equal(msg) {
8401 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8402 }
8403 }
8404
8405 func TestUnrecognizedProtoCompactText(t *testing.T) {
8406 seed := time.Now().UnixNano()
8407 popr := math_rand.New(math_rand.NewSource(seed))
8408 p := NewPopulatedUnrecognized(popr, true)
8409 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8410 msg := &Unrecognized{}
8411 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8412 t.Fatalf("seed = %d, err = %v", seed, err)
8413 }
8414 if err := p.VerboseEqual(msg); err != nil {
8415 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8416 }
8417 if !p.Equal(msg) {
8418 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8419 }
8420 }
8421
8422 func TestUnrecognizedWithInnerProtoText(t *testing.T) {
8423 seed := time.Now().UnixNano()
8424 popr := math_rand.New(math_rand.NewSource(seed))
8425 p := NewPopulatedUnrecognizedWithInner(popr, true)
8426 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8427 msg := &UnrecognizedWithInner{}
8428 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8429 t.Fatalf("seed = %d, err = %v", seed, err)
8430 }
8431 if err := p.VerboseEqual(msg); err != nil {
8432 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8433 }
8434 if !p.Equal(msg) {
8435 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8436 }
8437 }
8438
8439 func TestUnrecognizedWithInnerProtoCompactText(t *testing.T) {
8440 seed := time.Now().UnixNano()
8441 popr := math_rand.New(math_rand.NewSource(seed))
8442 p := NewPopulatedUnrecognizedWithInner(popr, true)
8443 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8444 msg := &UnrecognizedWithInner{}
8445 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8446 t.Fatalf("seed = %d, err = %v", seed, err)
8447 }
8448 if err := p.VerboseEqual(msg); err != nil {
8449 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8450 }
8451 if !p.Equal(msg) {
8452 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8453 }
8454 }
8455
8456 func TestUnrecognizedWithInner_InnerProtoText(t *testing.T) {
8457 seed := time.Now().UnixNano()
8458 popr := math_rand.New(math_rand.NewSource(seed))
8459 p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
8460 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8461 msg := &UnrecognizedWithInner_Inner{}
8462 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8463 t.Fatalf("seed = %d, err = %v", seed, err)
8464 }
8465 if err := p.VerboseEqual(msg); err != nil {
8466 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8467 }
8468 if !p.Equal(msg) {
8469 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8470 }
8471 }
8472
8473 func TestUnrecognizedWithInner_InnerProtoCompactText(t *testing.T) {
8474 seed := time.Now().UnixNano()
8475 popr := math_rand.New(math_rand.NewSource(seed))
8476 p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
8477 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8478 msg := &UnrecognizedWithInner_Inner{}
8479 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8480 t.Fatalf("seed = %d, err = %v", seed, err)
8481 }
8482 if err := p.VerboseEqual(msg); err != nil {
8483 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8484 }
8485 if !p.Equal(msg) {
8486 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8487 }
8488 }
8489
8490 func TestUnrecognizedWithEmbedProtoText(t *testing.T) {
8491 seed := time.Now().UnixNano()
8492 popr := math_rand.New(math_rand.NewSource(seed))
8493 p := NewPopulatedUnrecognizedWithEmbed(popr, true)
8494 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8495 msg := &UnrecognizedWithEmbed{}
8496 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8497 t.Fatalf("seed = %d, err = %v", seed, err)
8498 }
8499 if err := p.VerboseEqual(msg); err != nil {
8500 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8501 }
8502 if !p.Equal(msg) {
8503 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8504 }
8505 }
8506
8507 func TestUnrecognizedWithEmbedProtoCompactText(t *testing.T) {
8508 seed := time.Now().UnixNano()
8509 popr := math_rand.New(math_rand.NewSource(seed))
8510 p := NewPopulatedUnrecognizedWithEmbed(popr, true)
8511 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8512 msg := &UnrecognizedWithEmbed{}
8513 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8514 t.Fatalf("seed = %d, err = %v", seed, err)
8515 }
8516 if err := p.VerboseEqual(msg); err != nil {
8517 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8518 }
8519 if !p.Equal(msg) {
8520 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8521 }
8522 }
8523
8524 func TestUnrecognizedWithEmbed_EmbeddedProtoText(t *testing.T) {
8525 seed := time.Now().UnixNano()
8526 popr := math_rand.New(math_rand.NewSource(seed))
8527 p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
8528 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8529 msg := &UnrecognizedWithEmbed_Embedded{}
8530 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8531 t.Fatalf("seed = %d, err = %v", seed, err)
8532 }
8533 if err := p.VerboseEqual(msg); err != nil {
8534 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8535 }
8536 if !p.Equal(msg) {
8537 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8538 }
8539 }
8540
8541 func TestUnrecognizedWithEmbed_EmbeddedProtoCompactText(t *testing.T) {
8542 seed := time.Now().UnixNano()
8543 popr := math_rand.New(math_rand.NewSource(seed))
8544 p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
8545 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8546 msg := &UnrecognizedWithEmbed_Embedded{}
8547 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8548 t.Fatalf("seed = %d, err = %v", seed, err)
8549 }
8550 if err := p.VerboseEqual(msg); err != nil {
8551 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8552 }
8553 if !p.Equal(msg) {
8554 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8555 }
8556 }
8557
8558 func TestNodeProtoText(t *testing.T) {
8559 seed := time.Now().UnixNano()
8560 popr := math_rand.New(math_rand.NewSource(seed))
8561 p := NewPopulatedNode(popr, true)
8562 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8563 msg := &Node{}
8564 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8565 t.Fatalf("seed = %d, err = %v", seed, err)
8566 }
8567 if err := p.VerboseEqual(msg); err != nil {
8568 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8569 }
8570 if !p.Equal(msg) {
8571 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8572 }
8573 }
8574
8575 func TestNodeProtoCompactText(t *testing.T) {
8576 seed := time.Now().UnixNano()
8577 popr := math_rand.New(math_rand.NewSource(seed))
8578 p := NewPopulatedNode(popr, true)
8579 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8580 msg := &Node{}
8581 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8582 t.Fatalf("seed = %d, err = %v", seed, err)
8583 }
8584 if err := p.VerboseEqual(msg); err != nil {
8585 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8586 }
8587 if !p.Equal(msg) {
8588 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8589 }
8590 }
8591
8592 func TestNonByteCustomTypeProtoText(t *testing.T) {
8593 seed := time.Now().UnixNano()
8594 popr := math_rand.New(math_rand.NewSource(seed))
8595 p := NewPopulatedNonByteCustomType(popr, true)
8596 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8597 msg := &NonByteCustomType{}
8598 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8599 t.Fatalf("seed = %d, err = %v", seed, err)
8600 }
8601 if err := p.VerboseEqual(msg); err != nil {
8602 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8603 }
8604 if !p.Equal(msg) {
8605 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8606 }
8607 }
8608
8609 func TestNonByteCustomTypeProtoCompactText(t *testing.T) {
8610 seed := time.Now().UnixNano()
8611 popr := math_rand.New(math_rand.NewSource(seed))
8612 p := NewPopulatedNonByteCustomType(popr, true)
8613 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8614 msg := &NonByteCustomType{}
8615 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8616 t.Fatalf("seed = %d, err = %v", seed, err)
8617 }
8618 if err := p.VerboseEqual(msg); err != nil {
8619 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8620 }
8621 if !p.Equal(msg) {
8622 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8623 }
8624 }
8625
8626 func TestNidOptNonByteCustomTypeProtoText(t *testing.T) {
8627 seed := time.Now().UnixNano()
8628 popr := math_rand.New(math_rand.NewSource(seed))
8629 p := NewPopulatedNidOptNonByteCustomType(popr, true)
8630 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8631 msg := &NidOptNonByteCustomType{}
8632 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8633 t.Fatalf("seed = %d, err = %v", seed, err)
8634 }
8635 if err := p.VerboseEqual(msg); err != nil {
8636 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8637 }
8638 if !p.Equal(msg) {
8639 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8640 }
8641 }
8642
8643 func TestNidOptNonByteCustomTypeProtoCompactText(t *testing.T) {
8644 seed := time.Now().UnixNano()
8645 popr := math_rand.New(math_rand.NewSource(seed))
8646 p := NewPopulatedNidOptNonByteCustomType(popr, true)
8647 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8648 msg := &NidOptNonByteCustomType{}
8649 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8650 t.Fatalf("seed = %d, err = %v", seed, err)
8651 }
8652 if err := p.VerboseEqual(msg); err != nil {
8653 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8654 }
8655 if !p.Equal(msg) {
8656 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8657 }
8658 }
8659
8660 func TestNinOptNonByteCustomTypeProtoText(t *testing.T) {
8661 seed := time.Now().UnixNano()
8662 popr := math_rand.New(math_rand.NewSource(seed))
8663 p := NewPopulatedNinOptNonByteCustomType(popr, true)
8664 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8665 msg := &NinOptNonByteCustomType{}
8666 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8667 t.Fatalf("seed = %d, err = %v", seed, err)
8668 }
8669 if err := p.VerboseEqual(msg); err != nil {
8670 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8671 }
8672 if !p.Equal(msg) {
8673 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8674 }
8675 }
8676
8677 func TestNinOptNonByteCustomTypeProtoCompactText(t *testing.T) {
8678 seed := time.Now().UnixNano()
8679 popr := math_rand.New(math_rand.NewSource(seed))
8680 p := NewPopulatedNinOptNonByteCustomType(popr, true)
8681 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8682 msg := &NinOptNonByteCustomType{}
8683 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8684 t.Fatalf("seed = %d, err = %v", seed, err)
8685 }
8686 if err := p.VerboseEqual(msg); err != nil {
8687 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8688 }
8689 if !p.Equal(msg) {
8690 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8691 }
8692 }
8693
8694 func TestNidRepNonByteCustomTypeProtoText(t *testing.T) {
8695 seed := time.Now().UnixNano()
8696 popr := math_rand.New(math_rand.NewSource(seed))
8697 p := NewPopulatedNidRepNonByteCustomType(popr, true)
8698 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8699 msg := &NidRepNonByteCustomType{}
8700 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8701 t.Fatalf("seed = %d, err = %v", seed, err)
8702 }
8703 if err := p.VerboseEqual(msg); err != nil {
8704 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8705 }
8706 if !p.Equal(msg) {
8707 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8708 }
8709 }
8710
8711 func TestNidRepNonByteCustomTypeProtoCompactText(t *testing.T) {
8712 seed := time.Now().UnixNano()
8713 popr := math_rand.New(math_rand.NewSource(seed))
8714 p := NewPopulatedNidRepNonByteCustomType(popr, true)
8715 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8716 msg := &NidRepNonByteCustomType{}
8717 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8718 t.Fatalf("seed = %d, err = %v", seed, err)
8719 }
8720 if err := p.VerboseEqual(msg); err != nil {
8721 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8722 }
8723 if !p.Equal(msg) {
8724 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8725 }
8726 }
8727
8728 func TestNinRepNonByteCustomTypeProtoText(t *testing.T) {
8729 seed := time.Now().UnixNano()
8730 popr := math_rand.New(math_rand.NewSource(seed))
8731 p := NewPopulatedNinRepNonByteCustomType(popr, true)
8732 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8733 msg := &NinRepNonByteCustomType{}
8734 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8735 t.Fatalf("seed = %d, err = %v", seed, err)
8736 }
8737 if err := p.VerboseEqual(msg); err != nil {
8738 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8739 }
8740 if !p.Equal(msg) {
8741 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8742 }
8743 }
8744
8745 func TestNinRepNonByteCustomTypeProtoCompactText(t *testing.T) {
8746 seed := time.Now().UnixNano()
8747 popr := math_rand.New(math_rand.NewSource(seed))
8748 p := NewPopulatedNinRepNonByteCustomType(popr, true)
8749 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8750 msg := &NinRepNonByteCustomType{}
8751 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8752 t.Fatalf("seed = %d, err = %v", seed, err)
8753 }
8754 if err := p.VerboseEqual(msg); err != nil {
8755 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8756 }
8757 if !p.Equal(msg) {
8758 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8759 }
8760 }
8761
8762 func TestProtoTypeProtoText(t *testing.T) {
8763 seed := time.Now().UnixNano()
8764 popr := math_rand.New(math_rand.NewSource(seed))
8765 p := NewPopulatedProtoType(popr, true)
8766 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
8767 msg := &ProtoType{}
8768 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8769 t.Fatalf("seed = %d, err = %v", seed, err)
8770 }
8771 if err := p.VerboseEqual(msg); err != nil {
8772 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8773 }
8774 if !p.Equal(msg) {
8775 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8776 }
8777 }
8778
8779 func TestProtoTypeProtoCompactText(t *testing.T) {
8780 seed := time.Now().UnixNano()
8781 popr := math_rand.New(math_rand.NewSource(seed))
8782 p := NewPopulatedProtoType(popr, true)
8783 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
8784 msg := &ProtoType{}
8785 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
8786 t.Fatalf("seed = %d, err = %v", seed, err)
8787 }
8788 if err := p.VerboseEqual(msg); err != nil {
8789 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
8790 }
8791 if !p.Equal(msg) {
8792 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
8793 }
8794 }
8795
8796 func TestNidOptNativeCompare(t *testing.T) {
8797 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
8798 p := NewPopulatedNidOptNative(popr, false)
8799 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
8800 if err != nil {
8801 panic(err)
8802 }
8803 msg := &NidOptNative{}
8804 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
8805 panic(err)
8806 }
8807 if c := p.Compare(msg); c != 0 {
8808 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
8809 }
8810 p2 := NewPopulatedNidOptNative(popr, false)
8811 c := p.Compare(p2)
8812 c2 := p2.Compare(p)
8813 if c != (-1 * c2) {
8814 t.Errorf("p.Compare(p2) = %d", c)
8815 t.Errorf("p2.Compare(p) = %d", c2)
8816 t.Errorf("p = %#v", p)
8817 t.Errorf("p2 = %#v", p2)
8818 }
8819 }
8820 func TestNinOptNativeCompare(t *testing.T) {
8821 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
8822 p := NewPopulatedNinOptNative(popr, false)
8823 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
8824 if err != nil {
8825 panic(err)
8826 }
8827 msg := &NinOptNative{}
8828 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
8829 panic(err)
8830 }
8831 if c := p.Compare(msg); c != 0 {
8832 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
8833 }
8834 p2 := NewPopulatedNinOptNative(popr, false)
8835 c := p.Compare(p2)
8836 c2 := p2.Compare(p)
8837 if c != (-1 * c2) {
8838 t.Errorf("p.Compare(p2) = %d", c)
8839 t.Errorf("p2.Compare(p) = %d", c2)
8840 t.Errorf("p = %#v", p)
8841 t.Errorf("p2 = %#v", p2)
8842 }
8843 }
8844 func TestNidRepNativeCompare(t *testing.T) {
8845 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
8846 p := NewPopulatedNidRepNative(popr, false)
8847 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
8848 if err != nil {
8849 panic(err)
8850 }
8851 msg := &NidRepNative{}
8852 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
8853 panic(err)
8854 }
8855 if c := p.Compare(msg); c != 0 {
8856 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
8857 }
8858 p2 := NewPopulatedNidRepNative(popr, false)
8859 c := p.Compare(p2)
8860 c2 := p2.Compare(p)
8861 if c != (-1 * c2) {
8862 t.Errorf("p.Compare(p2) = %d", c)
8863 t.Errorf("p2.Compare(p) = %d", c2)
8864 t.Errorf("p = %#v", p)
8865 t.Errorf("p2 = %#v", p2)
8866 }
8867 }
8868 func TestNinRepNativeCompare(t *testing.T) {
8869 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
8870 p := NewPopulatedNinRepNative(popr, false)
8871 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
8872 if err != nil {
8873 panic(err)
8874 }
8875 msg := &NinRepNative{}
8876 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
8877 panic(err)
8878 }
8879 if c := p.Compare(msg); c != 0 {
8880 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
8881 }
8882 p2 := NewPopulatedNinRepNative(popr, false)
8883 c := p.Compare(p2)
8884 c2 := p2.Compare(p)
8885 if c != (-1 * c2) {
8886 t.Errorf("p.Compare(p2) = %d", c)
8887 t.Errorf("p2.Compare(p) = %d", c2)
8888 t.Errorf("p = %#v", p)
8889 t.Errorf("p2 = %#v", p2)
8890 }
8891 }
8892 func TestNidRepPackedNativeCompare(t *testing.T) {
8893 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
8894 p := NewPopulatedNidRepPackedNative(popr, false)
8895 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
8896 if err != nil {
8897 panic(err)
8898 }
8899 msg := &NidRepPackedNative{}
8900 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
8901 panic(err)
8902 }
8903 if c := p.Compare(msg); c != 0 {
8904 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
8905 }
8906 p2 := NewPopulatedNidRepPackedNative(popr, false)
8907 c := p.Compare(p2)
8908 c2 := p2.Compare(p)
8909 if c != (-1 * c2) {
8910 t.Errorf("p.Compare(p2) = %d", c)
8911 t.Errorf("p2.Compare(p) = %d", c2)
8912 t.Errorf("p = %#v", p)
8913 t.Errorf("p2 = %#v", p2)
8914 }
8915 }
8916 func TestNinRepPackedNativeCompare(t *testing.T) {
8917 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
8918 p := NewPopulatedNinRepPackedNative(popr, false)
8919 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
8920 if err != nil {
8921 panic(err)
8922 }
8923 msg := &NinRepPackedNative{}
8924 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
8925 panic(err)
8926 }
8927 if c := p.Compare(msg); c != 0 {
8928 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
8929 }
8930 p2 := NewPopulatedNinRepPackedNative(popr, false)
8931 c := p.Compare(p2)
8932 c2 := p2.Compare(p)
8933 if c != (-1 * c2) {
8934 t.Errorf("p.Compare(p2) = %d", c)
8935 t.Errorf("p2.Compare(p) = %d", c2)
8936 t.Errorf("p = %#v", p)
8937 t.Errorf("p2 = %#v", p2)
8938 }
8939 }
8940 func TestNidOptStructCompare(t *testing.T) {
8941 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
8942 p := NewPopulatedNidOptStruct(popr, false)
8943 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
8944 if err != nil {
8945 panic(err)
8946 }
8947 msg := &NidOptStruct{}
8948 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
8949 panic(err)
8950 }
8951 if c := p.Compare(msg); c != 0 {
8952 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
8953 }
8954 p2 := NewPopulatedNidOptStruct(popr, false)
8955 c := p.Compare(p2)
8956 c2 := p2.Compare(p)
8957 if c != (-1 * c2) {
8958 t.Errorf("p.Compare(p2) = %d", c)
8959 t.Errorf("p2.Compare(p) = %d", c2)
8960 t.Errorf("p = %#v", p)
8961 t.Errorf("p2 = %#v", p2)
8962 }
8963 }
8964 func TestNinOptStructCompare(t *testing.T) {
8965 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
8966 p := NewPopulatedNinOptStruct(popr, false)
8967 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
8968 if err != nil {
8969 panic(err)
8970 }
8971 msg := &NinOptStruct{}
8972 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
8973 panic(err)
8974 }
8975 if c := p.Compare(msg); c != 0 {
8976 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
8977 }
8978 p2 := NewPopulatedNinOptStruct(popr, false)
8979 c := p.Compare(p2)
8980 c2 := p2.Compare(p)
8981 if c != (-1 * c2) {
8982 t.Errorf("p.Compare(p2) = %d", c)
8983 t.Errorf("p2.Compare(p) = %d", c2)
8984 t.Errorf("p = %#v", p)
8985 t.Errorf("p2 = %#v", p2)
8986 }
8987 }
8988 func TestNidRepStructCompare(t *testing.T) {
8989 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
8990 p := NewPopulatedNidRepStruct(popr, false)
8991 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
8992 if err != nil {
8993 panic(err)
8994 }
8995 msg := &NidRepStruct{}
8996 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
8997 panic(err)
8998 }
8999 if c := p.Compare(msg); c != 0 {
9000 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9001 }
9002 p2 := NewPopulatedNidRepStruct(popr, false)
9003 c := p.Compare(p2)
9004 c2 := p2.Compare(p)
9005 if c != (-1 * c2) {
9006 t.Errorf("p.Compare(p2) = %d", c)
9007 t.Errorf("p2.Compare(p) = %d", c2)
9008 t.Errorf("p = %#v", p)
9009 t.Errorf("p2 = %#v", p2)
9010 }
9011 }
9012 func TestNinRepStructCompare(t *testing.T) {
9013 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9014 p := NewPopulatedNinRepStruct(popr, false)
9015 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9016 if err != nil {
9017 panic(err)
9018 }
9019 msg := &NinRepStruct{}
9020 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9021 panic(err)
9022 }
9023 if c := p.Compare(msg); c != 0 {
9024 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9025 }
9026 p2 := NewPopulatedNinRepStruct(popr, false)
9027 c := p.Compare(p2)
9028 c2 := p2.Compare(p)
9029 if c != (-1 * c2) {
9030 t.Errorf("p.Compare(p2) = %d", c)
9031 t.Errorf("p2.Compare(p) = %d", c2)
9032 t.Errorf("p = %#v", p)
9033 t.Errorf("p2 = %#v", p2)
9034 }
9035 }
9036 func TestNidEmbeddedStructCompare(t *testing.T) {
9037 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9038 p := NewPopulatedNidEmbeddedStruct(popr, false)
9039 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9040 if err != nil {
9041 panic(err)
9042 }
9043 msg := &NidEmbeddedStruct{}
9044 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9045 panic(err)
9046 }
9047 if c := p.Compare(msg); c != 0 {
9048 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9049 }
9050 p2 := NewPopulatedNidEmbeddedStruct(popr, false)
9051 c := p.Compare(p2)
9052 c2 := p2.Compare(p)
9053 if c != (-1 * c2) {
9054 t.Errorf("p.Compare(p2) = %d", c)
9055 t.Errorf("p2.Compare(p) = %d", c2)
9056 t.Errorf("p = %#v", p)
9057 t.Errorf("p2 = %#v", p2)
9058 }
9059 }
9060 func TestNinEmbeddedStructCompare(t *testing.T) {
9061 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9062 p := NewPopulatedNinEmbeddedStruct(popr, false)
9063 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9064 if err != nil {
9065 panic(err)
9066 }
9067 msg := &NinEmbeddedStruct{}
9068 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9069 panic(err)
9070 }
9071 if c := p.Compare(msg); c != 0 {
9072 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9073 }
9074 p2 := NewPopulatedNinEmbeddedStruct(popr, false)
9075 c := p.Compare(p2)
9076 c2 := p2.Compare(p)
9077 if c != (-1 * c2) {
9078 t.Errorf("p.Compare(p2) = %d", c)
9079 t.Errorf("p2.Compare(p) = %d", c2)
9080 t.Errorf("p = %#v", p)
9081 t.Errorf("p2 = %#v", p2)
9082 }
9083 }
9084 func TestNidNestedStructCompare(t *testing.T) {
9085 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9086 p := NewPopulatedNidNestedStruct(popr, false)
9087 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9088 if err != nil {
9089 panic(err)
9090 }
9091 msg := &NidNestedStruct{}
9092 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9093 panic(err)
9094 }
9095 if c := p.Compare(msg); c != 0 {
9096 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9097 }
9098 p2 := NewPopulatedNidNestedStruct(popr, false)
9099 c := p.Compare(p2)
9100 c2 := p2.Compare(p)
9101 if c != (-1 * c2) {
9102 t.Errorf("p.Compare(p2) = %d", c)
9103 t.Errorf("p2.Compare(p) = %d", c2)
9104 t.Errorf("p = %#v", p)
9105 t.Errorf("p2 = %#v", p2)
9106 }
9107 }
9108 func TestNinNestedStructCompare(t *testing.T) {
9109 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9110 p := NewPopulatedNinNestedStruct(popr, false)
9111 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9112 if err != nil {
9113 panic(err)
9114 }
9115 msg := &NinNestedStruct{}
9116 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9117 panic(err)
9118 }
9119 if c := p.Compare(msg); c != 0 {
9120 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9121 }
9122 p2 := NewPopulatedNinNestedStruct(popr, false)
9123 c := p.Compare(p2)
9124 c2 := p2.Compare(p)
9125 if c != (-1 * c2) {
9126 t.Errorf("p.Compare(p2) = %d", c)
9127 t.Errorf("p2.Compare(p) = %d", c2)
9128 t.Errorf("p = %#v", p)
9129 t.Errorf("p2 = %#v", p2)
9130 }
9131 }
9132 func TestNidOptCustomCompare(t *testing.T) {
9133 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9134 p := NewPopulatedNidOptCustom(popr, false)
9135 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9136 if err != nil {
9137 panic(err)
9138 }
9139 msg := &NidOptCustom{}
9140 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9141 panic(err)
9142 }
9143 if c := p.Compare(msg); c != 0 {
9144 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9145 }
9146 p2 := NewPopulatedNidOptCustom(popr, false)
9147 c := p.Compare(p2)
9148 c2 := p2.Compare(p)
9149 if c != (-1 * c2) {
9150 t.Errorf("p.Compare(p2) = %d", c)
9151 t.Errorf("p2.Compare(p) = %d", c2)
9152 t.Errorf("p = %#v", p)
9153 t.Errorf("p2 = %#v", p2)
9154 }
9155 }
9156 func TestCustomDashCompare(t *testing.T) {
9157 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9158 p := NewPopulatedCustomDash(popr, false)
9159 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9160 if err != nil {
9161 panic(err)
9162 }
9163 msg := &CustomDash{}
9164 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9165 panic(err)
9166 }
9167 if c := p.Compare(msg); c != 0 {
9168 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9169 }
9170 p2 := NewPopulatedCustomDash(popr, false)
9171 c := p.Compare(p2)
9172 c2 := p2.Compare(p)
9173 if c != (-1 * c2) {
9174 t.Errorf("p.Compare(p2) = %d", c)
9175 t.Errorf("p2.Compare(p) = %d", c2)
9176 t.Errorf("p = %#v", p)
9177 t.Errorf("p2 = %#v", p2)
9178 }
9179 }
9180 func TestNinOptCustomCompare(t *testing.T) {
9181 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9182 p := NewPopulatedNinOptCustom(popr, false)
9183 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9184 if err != nil {
9185 panic(err)
9186 }
9187 msg := &NinOptCustom{}
9188 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9189 panic(err)
9190 }
9191 if c := p.Compare(msg); c != 0 {
9192 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9193 }
9194 p2 := NewPopulatedNinOptCustom(popr, false)
9195 c := p.Compare(p2)
9196 c2 := p2.Compare(p)
9197 if c != (-1 * c2) {
9198 t.Errorf("p.Compare(p2) = %d", c)
9199 t.Errorf("p2.Compare(p) = %d", c2)
9200 t.Errorf("p = %#v", p)
9201 t.Errorf("p2 = %#v", p2)
9202 }
9203 }
9204 func TestNidRepCustomCompare(t *testing.T) {
9205 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9206 p := NewPopulatedNidRepCustom(popr, false)
9207 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9208 if err != nil {
9209 panic(err)
9210 }
9211 msg := &NidRepCustom{}
9212 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9213 panic(err)
9214 }
9215 if c := p.Compare(msg); c != 0 {
9216 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9217 }
9218 p2 := NewPopulatedNidRepCustom(popr, false)
9219 c := p.Compare(p2)
9220 c2 := p2.Compare(p)
9221 if c != (-1 * c2) {
9222 t.Errorf("p.Compare(p2) = %d", c)
9223 t.Errorf("p2.Compare(p) = %d", c2)
9224 t.Errorf("p = %#v", p)
9225 t.Errorf("p2 = %#v", p2)
9226 }
9227 }
9228 func TestNinRepCustomCompare(t *testing.T) {
9229 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9230 p := NewPopulatedNinRepCustom(popr, false)
9231 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9232 if err != nil {
9233 panic(err)
9234 }
9235 msg := &NinRepCustom{}
9236 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9237 panic(err)
9238 }
9239 if c := p.Compare(msg); c != 0 {
9240 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9241 }
9242 p2 := NewPopulatedNinRepCustom(popr, false)
9243 c := p.Compare(p2)
9244 c2 := p2.Compare(p)
9245 if c != (-1 * c2) {
9246 t.Errorf("p.Compare(p2) = %d", c)
9247 t.Errorf("p2.Compare(p) = %d", c2)
9248 t.Errorf("p = %#v", p)
9249 t.Errorf("p2 = %#v", p2)
9250 }
9251 }
9252 func TestNinOptNativeUnionCompare(t *testing.T) {
9253 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9254 p := NewPopulatedNinOptNativeUnion(popr, false)
9255 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9256 if err != nil {
9257 panic(err)
9258 }
9259 msg := &NinOptNativeUnion{}
9260 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9261 panic(err)
9262 }
9263 if c := p.Compare(msg); c != 0 {
9264 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9265 }
9266 p2 := NewPopulatedNinOptNativeUnion(popr, false)
9267 c := p.Compare(p2)
9268 c2 := p2.Compare(p)
9269 if c != (-1 * c2) {
9270 t.Errorf("p.Compare(p2) = %d", c)
9271 t.Errorf("p2.Compare(p) = %d", c2)
9272 t.Errorf("p = %#v", p)
9273 t.Errorf("p2 = %#v", p2)
9274 }
9275 }
9276 func TestNinOptStructUnionCompare(t *testing.T) {
9277 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9278 p := NewPopulatedNinOptStructUnion(popr, false)
9279 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9280 if err != nil {
9281 panic(err)
9282 }
9283 msg := &NinOptStructUnion{}
9284 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9285 panic(err)
9286 }
9287 if c := p.Compare(msg); c != 0 {
9288 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9289 }
9290 p2 := NewPopulatedNinOptStructUnion(popr, false)
9291 c := p.Compare(p2)
9292 c2 := p2.Compare(p)
9293 if c != (-1 * c2) {
9294 t.Errorf("p.Compare(p2) = %d", c)
9295 t.Errorf("p2.Compare(p) = %d", c2)
9296 t.Errorf("p = %#v", p)
9297 t.Errorf("p2 = %#v", p2)
9298 }
9299 }
9300 func TestNinEmbeddedStructUnionCompare(t *testing.T) {
9301 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9302 p := NewPopulatedNinEmbeddedStructUnion(popr, false)
9303 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9304 if err != nil {
9305 panic(err)
9306 }
9307 msg := &NinEmbeddedStructUnion{}
9308 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9309 panic(err)
9310 }
9311 if c := p.Compare(msg); c != 0 {
9312 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9313 }
9314 p2 := NewPopulatedNinEmbeddedStructUnion(popr, false)
9315 c := p.Compare(p2)
9316 c2 := p2.Compare(p)
9317 if c != (-1 * c2) {
9318 t.Errorf("p.Compare(p2) = %d", c)
9319 t.Errorf("p2.Compare(p) = %d", c2)
9320 t.Errorf("p = %#v", p)
9321 t.Errorf("p2 = %#v", p2)
9322 }
9323 }
9324 func TestNinNestedStructUnionCompare(t *testing.T) {
9325 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9326 p := NewPopulatedNinNestedStructUnion(popr, false)
9327 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9328 if err != nil {
9329 panic(err)
9330 }
9331 msg := &NinNestedStructUnion{}
9332 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9333 panic(err)
9334 }
9335 if c := p.Compare(msg); c != 0 {
9336 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9337 }
9338 p2 := NewPopulatedNinNestedStructUnion(popr, false)
9339 c := p.Compare(p2)
9340 c2 := p2.Compare(p)
9341 if c != (-1 * c2) {
9342 t.Errorf("p.Compare(p2) = %d", c)
9343 t.Errorf("p2.Compare(p) = %d", c2)
9344 t.Errorf("p = %#v", p)
9345 t.Errorf("p2 = %#v", p2)
9346 }
9347 }
9348 func TestTreeCompare(t *testing.T) {
9349 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9350 p := NewPopulatedTree(popr, false)
9351 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9352 if err != nil {
9353 panic(err)
9354 }
9355 msg := &Tree{}
9356 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9357 panic(err)
9358 }
9359 if c := p.Compare(msg); c != 0 {
9360 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9361 }
9362 p2 := NewPopulatedTree(popr, false)
9363 c := p.Compare(p2)
9364 c2 := p2.Compare(p)
9365 if c != (-1 * c2) {
9366 t.Errorf("p.Compare(p2) = %d", c)
9367 t.Errorf("p2.Compare(p) = %d", c2)
9368 t.Errorf("p = %#v", p)
9369 t.Errorf("p2 = %#v", p2)
9370 }
9371 }
9372 func TestOrBranchCompare(t *testing.T) {
9373 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9374 p := NewPopulatedOrBranch(popr, false)
9375 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9376 if err != nil {
9377 panic(err)
9378 }
9379 msg := &OrBranch{}
9380 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9381 panic(err)
9382 }
9383 if c := p.Compare(msg); c != 0 {
9384 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9385 }
9386 p2 := NewPopulatedOrBranch(popr, false)
9387 c := p.Compare(p2)
9388 c2 := p2.Compare(p)
9389 if c != (-1 * c2) {
9390 t.Errorf("p.Compare(p2) = %d", c)
9391 t.Errorf("p2.Compare(p) = %d", c2)
9392 t.Errorf("p = %#v", p)
9393 t.Errorf("p2 = %#v", p2)
9394 }
9395 }
9396 func TestAndBranchCompare(t *testing.T) {
9397 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9398 p := NewPopulatedAndBranch(popr, false)
9399 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9400 if err != nil {
9401 panic(err)
9402 }
9403 msg := &AndBranch{}
9404 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9405 panic(err)
9406 }
9407 if c := p.Compare(msg); c != 0 {
9408 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9409 }
9410 p2 := NewPopulatedAndBranch(popr, false)
9411 c := p.Compare(p2)
9412 c2 := p2.Compare(p)
9413 if c != (-1 * c2) {
9414 t.Errorf("p.Compare(p2) = %d", c)
9415 t.Errorf("p2.Compare(p) = %d", c2)
9416 t.Errorf("p = %#v", p)
9417 t.Errorf("p2 = %#v", p2)
9418 }
9419 }
9420 func TestLeafCompare(t *testing.T) {
9421 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9422 p := NewPopulatedLeaf(popr, false)
9423 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9424 if err != nil {
9425 panic(err)
9426 }
9427 msg := &Leaf{}
9428 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9429 panic(err)
9430 }
9431 if c := p.Compare(msg); c != 0 {
9432 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9433 }
9434 p2 := NewPopulatedLeaf(popr, false)
9435 c := p.Compare(p2)
9436 c2 := p2.Compare(p)
9437 if c != (-1 * c2) {
9438 t.Errorf("p.Compare(p2) = %d", c)
9439 t.Errorf("p2.Compare(p) = %d", c2)
9440 t.Errorf("p = %#v", p)
9441 t.Errorf("p2 = %#v", p2)
9442 }
9443 }
9444 func TestDeepTreeCompare(t *testing.T) {
9445 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9446 p := NewPopulatedDeepTree(popr, false)
9447 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9448 if err != nil {
9449 panic(err)
9450 }
9451 msg := &DeepTree{}
9452 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9453 panic(err)
9454 }
9455 if c := p.Compare(msg); c != 0 {
9456 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9457 }
9458 p2 := NewPopulatedDeepTree(popr, false)
9459 c := p.Compare(p2)
9460 c2 := p2.Compare(p)
9461 if c != (-1 * c2) {
9462 t.Errorf("p.Compare(p2) = %d", c)
9463 t.Errorf("p2.Compare(p) = %d", c2)
9464 t.Errorf("p = %#v", p)
9465 t.Errorf("p2 = %#v", p2)
9466 }
9467 }
9468 func TestADeepBranchCompare(t *testing.T) {
9469 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9470 p := NewPopulatedADeepBranch(popr, false)
9471 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9472 if err != nil {
9473 panic(err)
9474 }
9475 msg := &ADeepBranch{}
9476 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9477 panic(err)
9478 }
9479 if c := p.Compare(msg); c != 0 {
9480 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9481 }
9482 p2 := NewPopulatedADeepBranch(popr, false)
9483 c := p.Compare(p2)
9484 c2 := p2.Compare(p)
9485 if c != (-1 * c2) {
9486 t.Errorf("p.Compare(p2) = %d", c)
9487 t.Errorf("p2.Compare(p) = %d", c2)
9488 t.Errorf("p = %#v", p)
9489 t.Errorf("p2 = %#v", p2)
9490 }
9491 }
9492 func TestAndDeepBranchCompare(t *testing.T) {
9493 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9494 p := NewPopulatedAndDeepBranch(popr, false)
9495 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9496 if err != nil {
9497 panic(err)
9498 }
9499 msg := &AndDeepBranch{}
9500 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9501 panic(err)
9502 }
9503 if c := p.Compare(msg); c != 0 {
9504 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9505 }
9506 p2 := NewPopulatedAndDeepBranch(popr, false)
9507 c := p.Compare(p2)
9508 c2 := p2.Compare(p)
9509 if c != (-1 * c2) {
9510 t.Errorf("p.Compare(p2) = %d", c)
9511 t.Errorf("p2.Compare(p) = %d", c2)
9512 t.Errorf("p = %#v", p)
9513 t.Errorf("p2 = %#v", p2)
9514 }
9515 }
9516 func TestDeepLeafCompare(t *testing.T) {
9517 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9518 p := NewPopulatedDeepLeaf(popr, false)
9519 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9520 if err != nil {
9521 panic(err)
9522 }
9523 msg := &DeepLeaf{}
9524 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9525 panic(err)
9526 }
9527 if c := p.Compare(msg); c != 0 {
9528 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9529 }
9530 p2 := NewPopulatedDeepLeaf(popr, false)
9531 c := p.Compare(p2)
9532 c2 := p2.Compare(p)
9533 if c != (-1 * c2) {
9534 t.Errorf("p.Compare(p2) = %d", c)
9535 t.Errorf("p2.Compare(p) = %d", c2)
9536 t.Errorf("p = %#v", p)
9537 t.Errorf("p2 = %#v", p2)
9538 }
9539 }
9540 func TestNilCompare(t *testing.T) {
9541 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9542 p := NewPopulatedNil(popr, false)
9543 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9544 if err != nil {
9545 panic(err)
9546 }
9547 msg := &Nil{}
9548 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9549 panic(err)
9550 }
9551 if c := p.Compare(msg); c != 0 {
9552 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9553 }
9554 p2 := NewPopulatedNil(popr, false)
9555 c := p.Compare(p2)
9556 c2 := p2.Compare(p)
9557 if c != (-1 * c2) {
9558 t.Errorf("p.Compare(p2) = %d", c)
9559 t.Errorf("p2.Compare(p) = %d", c2)
9560 t.Errorf("p = %#v", p)
9561 t.Errorf("p2 = %#v", p2)
9562 }
9563 }
9564 func TestNidOptEnumCompare(t *testing.T) {
9565 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9566 p := NewPopulatedNidOptEnum(popr, false)
9567 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9568 if err != nil {
9569 panic(err)
9570 }
9571 msg := &NidOptEnum{}
9572 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9573 panic(err)
9574 }
9575 if c := p.Compare(msg); c != 0 {
9576 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9577 }
9578 p2 := NewPopulatedNidOptEnum(popr, false)
9579 c := p.Compare(p2)
9580 c2 := p2.Compare(p)
9581 if c != (-1 * c2) {
9582 t.Errorf("p.Compare(p2) = %d", c)
9583 t.Errorf("p2.Compare(p) = %d", c2)
9584 t.Errorf("p = %#v", p)
9585 t.Errorf("p2 = %#v", p2)
9586 }
9587 }
9588 func TestNinOptEnumCompare(t *testing.T) {
9589 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9590 p := NewPopulatedNinOptEnum(popr, false)
9591 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9592 if err != nil {
9593 panic(err)
9594 }
9595 msg := &NinOptEnum{}
9596 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9597 panic(err)
9598 }
9599 if c := p.Compare(msg); c != 0 {
9600 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9601 }
9602 p2 := NewPopulatedNinOptEnum(popr, false)
9603 c := p.Compare(p2)
9604 c2 := p2.Compare(p)
9605 if c != (-1 * c2) {
9606 t.Errorf("p.Compare(p2) = %d", c)
9607 t.Errorf("p2.Compare(p) = %d", c2)
9608 t.Errorf("p = %#v", p)
9609 t.Errorf("p2 = %#v", p2)
9610 }
9611 }
9612 func TestNidRepEnumCompare(t *testing.T) {
9613 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9614 p := NewPopulatedNidRepEnum(popr, false)
9615 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9616 if err != nil {
9617 panic(err)
9618 }
9619 msg := &NidRepEnum{}
9620 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9621 panic(err)
9622 }
9623 if c := p.Compare(msg); c != 0 {
9624 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9625 }
9626 p2 := NewPopulatedNidRepEnum(popr, false)
9627 c := p.Compare(p2)
9628 c2 := p2.Compare(p)
9629 if c != (-1 * c2) {
9630 t.Errorf("p.Compare(p2) = %d", c)
9631 t.Errorf("p2.Compare(p) = %d", c2)
9632 t.Errorf("p = %#v", p)
9633 t.Errorf("p2 = %#v", p2)
9634 }
9635 }
9636 func TestNinRepEnumCompare(t *testing.T) {
9637 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9638 p := NewPopulatedNinRepEnum(popr, false)
9639 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9640 if err != nil {
9641 panic(err)
9642 }
9643 msg := &NinRepEnum{}
9644 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9645 panic(err)
9646 }
9647 if c := p.Compare(msg); c != 0 {
9648 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9649 }
9650 p2 := NewPopulatedNinRepEnum(popr, false)
9651 c := p.Compare(p2)
9652 c2 := p2.Compare(p)
9653 if c != (-1 * c2) {
9654 t.Errorf("p.Compare(p2) = %d", c)
9655 t.Errorf("p2.Compare(p) = %d", c2)
9656 t.Errorf("p = %#v", p)
9657 t.Errorf("p2 = %#v", p2)
9658 }
9659 }
9660 func TestNinOptEnumDefaultCompare(t *testing.T) {
9661 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9662 p := NewPopulatedNinOptEnumDefault(popr, false)
9663 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9664 if err != nil {
9665 panic(err)
9666 }
9667 msg := &NinOptEnumDefault{}
9668 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9669 panic(err)
9670 }
9671 if c := p.Compare(msg); c != 0 {
9672 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9673 }
9674 p2 := NewPopulatedNinOptEnumDefault(popr, false)
9675 c := p.Compare(p2)
9676 c2 := p2.Compare(p)
9677 if c != (-1 * c2) {
9678 t.Errorf("p.Compare(p2) = %d", c)
9679 t.Errorf("p2.Compare(p) = %d", c2)
9680 t.Errorf("p = %#v", p)
9681 t.Errorf("p2 = %#v", p2)
9682 }
9683 }
9684 func TestAnotherNinOptEnumCompare(t *testing.T) {
9685 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9686 p := NewPopulatedAnotherNinOptEnum(popr, false)
9687 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9688 if err != nil {
9689 panic(err)
9690 }
9691 msg := &AnotherNinOptEnum{}
9692 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9693 panic(err)
9694 }
9695 if c := p.Compare(msg); c != 0 {
9696 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9697 }
9698 p2 := NewPopulatedAnotherNinOptEnum(popr, false)
9699 c := p.Compare(p2)
9700 c2 := p2.Compare(p)
9701 if c != (-1 * c2) {
9702 t.Errorf("p.Compare(p2) = %d", c)
9703 t.Errorf("p2.Compare(p) = %d", c2)
9704 t.Errorf("p = %#v", p)
9705 t.Errorf("p2 = %#v", p2)
9706 }
9707 }
9708 func TestAnotherNinOptEnumDefaultCompare(t *testing.T) {
9709 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9710 p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
9711 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9712 if err != nil {
9713 panic(err)
9714 }
9715 msg := &AnotherNinOptEnumDefault{}
9716 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9717 panic(err)
9718 }
9719 if c := p.Compare(msg); c != 0 {
9720 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9721 }
9722 p2 := NewPopulatedAnotherNinOptEnumDefault(popr, false)
9723 c := p.Compare(p2)
9724 c2 := p2.Compare(p)
9725 if c != (-1 * c2) {
9726 t.Errorf("p.Compare(p2) = %d", c)
9727 t.Errorf("p2.Compare(p) = %d", c2)
9728 t.Errorf("p = %#v", p)
9729 t.Errorf("p2 = %#v", p2)
9730 }
9731 }
9732 func TestTimerCompare(t *testing.T) {
9733 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9734 p := NewPopulatedTimer(popr, false)
9735 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9736 if err != nil {
9737 panic(err)
9738 }
9739 msg := &Timer{}
9740 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9741 panic(err)
9742 }
9743 if c := p.Compare(msg); c != 0 {
9744 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9745 }
9746 p2 := NewPopulatedTimer(popr, false)
9747 c := p.Compare(p2)
9748 c2 := p2.Compare(p)
9749 if c != (-1 * c2) {
9750 t.Errorf("p.Compare(p2) = %d", c)
9751 t.Errorf("p2.Compare(p) = %d", c2)
9752 t.Errorf("p = %#v", p)
9753 t.Errorf("p2 = %#v", p2)
9754 }
9755 }
9756 func TestMyExtendableCompare(t *testing.T) {
9757 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9758 p := NewPopulatedMyExtendable(popr, false)
9759 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9760 if err != nil {
9761 panic(err)
9762 }
9763 msg := &MyExtendable{}
9764 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9765 panic(err)
9766 }
9767 if c := p.Compare(msg); c != 0 {
9768 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9769 }
9770 p2 := NewPopulatedMyExtendable(popr, false)
9771 c := p.Compare(p2)
9772 c2 := p2.Compare(p)
9773 if c != (-1 * c2) {
9774 t.Errorf("p.Compare(p2) = %d", c)
9775 t.Errorf("p2.Compare(p) = %d", c2)
9776 t.Errorf("p = %#v", p)
9777 t.Errorf("p2 = %#v", p2)
9778 }
9779 }
9780 func TestOtherExtenableCompare(t *testing.T) {
9781 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9782 p := NewPopulatedOtherExtenable(popr, false)
9783 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9784 if err != nil {
9785 panic(err)
9786 }
9787 msg := &OtherExtenable{}
9788 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9789 panic(err)
9790 }
9791 if c := p.Compare(msg); c != 0 {
9792 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9793 }
9794 p2 := NewPopulatedOtherExtenable(popr, false)
9795 c := p.Compare(p2)
9796 c2 := p2.Compare(p)
9797 if c != (-1 * c2) {
9798 t.Errorf("p.Compare(p2) = %d", c)
9799 t.Errorf("p2.Compare(p) = %d", c2)
9800 t.Errorf("p = %#v", p)
9801 t.Errorf("p2 = %#v", p2)
9802 }
9803 }
9804 func TestNestedDefinitionCompare(t *testing.T) {
9805 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9806 p := NewPopulatedNestedDefinition(popr, false)
9807 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9808 if err != nil {
9809 panic(err)
9810 }
9811 msg := &NestedDefinition{}
9812 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9813 panic(err)
9814 }
9815 if c := p.Compare(msg); c != 0 {
9816 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9817 }
9818 p2 := NewPopulatedNestedDefinition(popr, false)
9819 c := p.Compare(p2)
9820 c2 := p2.Compare(p)
9821 if c != (-1 * c2) {
9822 t.Errorf("p.Compare(p2) = %d", c)
9823 t.Errorf("p2.Compare(p) = %d", c2)
9824 t.Errorf("p = %#v", p)
9825 t.Errorf("p2 = %#v", p2)
9826 }
9827 }
9828 func TestNestedDefinition_NestedMessageCompare(t *testing.T) {
9829 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9830 p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
9831 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9832 if err != nil {
9833 panic(err)
9834 }
9835 msg := &NestedDefinition_NestedMessage{}
9836 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9837 panic(err)
9838 }
9839 if c := p.Compare(msg); c != 0 {
9840 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9841 }
9842 p2 := NewPopulatedNestedDefinition_NestedMessage(popr, false)
9843 c := p.Compare(p2)
9844 c2 := p2.Compare(p)
9845 if c != (-1 * c2) {
9846 t.Errorf("p.Compare(p2) = %d", c)
9847 t.Errorf("p2.Compare(p) = %d", c2)
9848 t.Errorf("p = %#v", p)
9849 t.Errorf("p2 = %#v", p2)
9850 }
9851 }
9852 func TestNestedDefinition_NestedMessage_NestedNestedMsgCompare(t *testing.T) {
9853 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9854 p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
9855 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9856 if err != nil {
9857 panic(err)
9858 }
9859 msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
9860 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9861 panic(err)
9862 }
9863 if c := p.Compare(msg); c != 0 {
9864 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9865 }
9866 p2 := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
9867 c := p.Compare(p2)
9868 c2 := p2.Compare(p)
9869 if c != (-1 * c2) {
9870 t.Errorf("p.Compare(p2) = %d", c)
9871 t.Errorf("p2.Compare(p) = %d", c2)
9872 t.Errorf("p = %#v", p)
9873 t.Errorf("p2 = %#v", p2)
9874 }
9875 }
9876 func TestNestedScopeCompare(t *testing.T) {
9877 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9878 p := NewPopulatedNestedScope(popr, false)
9879 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9880 if err != nil {
9881 panic(err)
9882 }
9883 msg := &NestedScope{}
9884 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9885 panic(err)
9886 }
9887 if c := p.Compare(msg); c != 0 {
9888 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9889 }
9890 p2 := NewPopulatedNestedScope(popr, false)
9891 c := p.Compare(p2)
9892 c2 := p2.Compare(p)
9893 if c != (-1 * c2) {
9894 t.Errorf("p.Compare(p2) = %d", c)
9895 t.Errorf("p2.Compare(p) = %d", c2)
9896 t.Errorf("p = %#v", p)
9897 t.Errorf("p2 = %#v", p2)
9898 }
9899 }
9900 func TestNinOptNativeDefaultCompare(t *testing.T) {
9901 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9902 p := NewPopulatedNinOptNativeDefault(popr, false)
9903 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9904 if err != nil {
9905 panic(err)
9906 }
9907 msg := &NinOptNativeDefault{}
9908 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9909 panic(err)
9910 }
9911 if c := p.Compare(msg); c != 0 {
9912 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9913 }
9914 p2 := NewPopulatedNinOptNativeDefault(popr, false)
9915 c := p.Compare(p2)
9916 c2 := p2.Compare(p)
9917 if c != (-1 * c2) {
9918 t.Errorf("p.Compare(p2) = %d", c)
9919 t.Errorf("p2.Compare(p) = %d", c2)
9920 t.Errorf("p = %#v", p)
9921 t.Errorf("p2 = %#v", p2)
9922 }
9923 }
9924 func TestCustomContainerCompare(t *testing.T) {
9925 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9926 p := NewPopulatedCustomContainer(popr, false)
9927 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9928 if err != nil {
9929 panic(err)
9930 }
9931 msg := &CustomContainer{}
9932 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9933 panic(err)
9934 }
9935 if c := p.Compare(msg); c != 0 {
9936 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9937 }
9938 p2 := NewPopulatedCustomContainer(popr, false)
9939 c := p.Compare(p2)
9940 c2 := p2.Compare(p)
9941 if c != (-1 * c2) {
9942 t.Errorf("p.Compare(p2) = %d", c)
9943 t.Errorf("p2.Compare(p) = %d", c2)
9944 t.Errorf("p = %#v", p)
9945 t.Errorf("p2 = %#v", p2)
9946 }
9947 }
9948 func TestCustomNameNidOptNativeCompare(t *testing.T) {
9949 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9950 p := NewPopulatedCustomNameNidOptNative(popr, false)
9951 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9952 if err != nil {
9953 panic(err)
9954 }
9955 msg := &CustomNameNidOptNative{}
9956 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9957 panic(err)
9958 }
9959 if c := p.Compare(msg); c != 0 {
9960 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9961 }
9962 p2 := NewPopulatedCustomNameNidOptNative(popr, false)
9963 c := p.Compare(p2)
9964 c2 := p2.Compare(p)
9965 if c != (-1 * c2) {
9966 t.Errorf("p.Compare(p2) = %d", c)
9967 t.Errorf("p2.Compare(p) = %d", c2)
9968 t.Errorf("p = %#v", p)
9969 t.Errorf("p2 = %#v", p2)
9970 }
9971 }
9972 func TestCustomNameNinOptNativeCompare(t *testing.T) {
9973 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9974 p := NewPopulatedCustomNameNinOptNative(popr, false)
9975 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
9976 if err != nil {
9977 panic(err)
9978 }
9979 msg := &CustomNameNinOptNative{}
9980 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
9981 panic(err)
9982 }
9983 if c := p.Compare(msg); c != 0 {
9984 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
9985 }
9986 p2 := NewPopulatedCustomNameNinOptNative(popr, false)
9987 c := p.Compare(p2)
9988 c2 := p2.Compare(p)
9989 if c != (-1 * c2) {
9990 t.Errorf("p.Compare(p2) = %d", c)
9991 t.Errorf("p2.Compare(p) = %d", c2)
9992 t.Errorf("p = %#v", p)
9993 t.Errorf("p2 = %#v", p2)
9994 }
9995 }
9996 func TestCustomNameNinRepNativeCompare(t *testing.T) {
9997 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
9998 p := NewPopulatedCustomNameNinRepNative(popr, false)
9999 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10000 if err != nil {
10001 panic(err)
10002 }
10003 msg := &CustomNameNinRepNative{}
10004 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10005 panic(err)
10006 }
10007 if c := p.Compare(msg); c != 0 {
10008 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10009 }
10010 p2 := NewPopulatedCustomNameNinRepNative(popr, false)
10011 c := p.Compare(p2)
10012 c2 := p2.Compare(p)
10013 if c != (-1 * c2) {
10014 t.Errorf("p.Compare(p2) = %d", c)
10015 t.Errorf("p2.Compare(p) = %d", c2)
10016 t.Errorf("p = %#v", p)
10017 t.Errorf("p2 = %#v", p2)
10018 }
10019 }
10020 func TestCustomNameNinStructCompare(t *testing.T) {
10021 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10022 p := NewPopulatedCustomNameNinStruct(popr, false)
10023 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10024 if err != nil {
10025 panic(err)
10026 }
10027 msg := &CustomNameNinStruct{}
10028 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10029 panic(err)
10030 }
10031 if c := p.Compare(msg); c != 0 {
10032 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10033 }
10034 p2 := NewPopulatedCustomNameNinStruct(popr, false)
10035 c := p.Compare(p2)
10036 c2 := p2.Compare(p)
10037 if c != (-1 * c2) {
10038 t.Errorf("p.Compare(p2) = %d", c)
10039 t.Errorf("p2.Compare(p) = %d", c2)
10040 t.Errorf("p = %#v", p)
10041 t.Errorf("p2 = %#v", p2)
10042 }
10043 }
10044 func TestCustomNameCustomTypeCompare(t *testing.T) {
10045 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10046 p := NewPopulatedCustomNameCustomType(popr, false)
10047 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10048 if err != nil {
10049 panic(err)
10050 }
10051 msg := &CustomNameCustomType{}
10052 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10053 panic(err)
10054 }
10055 if c := p.Compare(msg); c != 0 {
10056 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10057 }
10058 p2 := NewPopulatedCustomNameCustomType(popr, false)
10059 c := p.Compare(p2)
10060 c2 := p2.Compare(p)
10061 if c != (-1 * c2) {
10062 t.Errorf("p.Compare(p2) = %d", c)
10063 t.Errorf("p2.Compare(p) = %d", c2)
10064 t.Errorf("p = %#v", p)
10065 t.Errorf("p2 = %#v", p2)
10066 }
10067 }
10068 func TestCustomNameNinEmbeddedStructUnionCompare(t *testing.T) {
10069 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10070 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
10071 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10072 if err != nil {
10073 panic(err)
10074 }
10075 msg := &CustomNameNinEmbeddedStructUnion{}
10076 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10077 panic(err)
10078 }
10079 if c := p.Compare(msg); c != 0 {
10080 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10081 }
10082 p2 := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
10083 c := p.Compare(p2)
10084 c2 := p2.Compare(p)
10085 if c != (-1 * c2) {
10086 t.Errorf("p.Compare(p2) = %d", c)
10087 t.Errorf("p2.Compare(p) = %d", c2)
10088 t.Errorf("p = %#v", p)
10089 t.Errorf("p2 = %#v", p2)
10090 }
10091 }
10092 func TestCustomNameEnumCompare(t *testing.T) {
10093 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10094 p := NewPopulatedCustomNameEnum(popr, false)
10095 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10096 if err != nil {
10097 panic(err)
10098 }
10099 msg := &CustomNameEnum{}
10100 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10101 panic(err)
10102 }
10103 if c := p.Compare(msg); c != 0 {
10104 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10105 }
10106 p2 := NewPopulatedCustomNameEnum(popr, false)
10107 c := p.Compare(p2)
10108 c2 := p2.Compare(p)
10109 if c != (-1 * c2) {
10110 t.Errorf("p.Compare(p2) = %d", c)
10111 t.Errorf("p2.Compare(p) = %d", c2)
10112 t.Errorf("p = %#v", p)
10113 t.Errorf("p2 = %#v", p2)
10114 }
10115 }
10116 func TestNoExtensionsMapCompare(t *testing.T) {
10117 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10118 p := NewPopulatedNoExtensionsMap(popr, false)
10119 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10120 if err != nil {
10121 panic(err)
10122 }
10123 msg := &NoExtensionsMap{}
10124 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10125 panic(err)
10126 }
10127 if c := p.Compare(msg); c != 0 {
10128 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10129 }
10130 p2 := NewPopulatedNoExtensionsMap(popr, false)
10131 c := p.Compare(p2)
10132 c2 := p2.Compare(p)
10133 if c != (-1 * c2) {
10134 t.Errorf("p.Compare(p2) = %d", c)
10135 t.Errorf("p2.Compare(p) = %d", c2)
10136 t.Errorf("p = %#v", p)
10137 t.Errorf("p2 = %#v", p2)
10138 }
10139 }
10140 func TestUnrecognizedCompare(t *testing.T) {
10141 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10142 p := NewPopulatedUnrecognized(popr, false)
10143 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10144 if err != nil {
10145 panic(err)
10146 }
10147 msg := &Unrecognized{}
10148 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10149 panic(err)
10150 }
10151 if c := p.Compare(msg); c != 0 {
10152 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10153 }
10154 p2 := NewPopulatedUnrecognized(popr, false)
10155 c := p.Compare(p2)
10156 c2 := p2.Compare(p)
10157 if c != (-1 * c2) {
10158 t.Errorf("p.Compare(p2) = %d", c)
10159 t.Errorf("p2.Compare(p) = %d", c2)
10160 t.Errorf("p = %#v", p)
10161 t.Errorf("p2 = %#v", p2)
10162 }
10163 }
10164 func TestUnrecognizedWithInnerCompare(t *testing.T) {
10165 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10166 p := NewPopulatedUnrecognizedWithInner(popr, false)
10167 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10168 if err != nil {
10169 panic(err)
10170 }
10171 msg := &UnrecognizedWithInner{}
10172 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10173 panic(err)
10174 }
10175 if c := p.Compare(msg); c != 0 {
10176 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10177 }
10178 p2 := NewPopulatedUnrecognizedWithInner(popr, false)
10179 c := p.Compare(p2)
10180 c2 := p2.Compare(p)
10181 if c != (-1 * c2) {
10182 t.Errorf("p.Compare(p2) = %d", c)
10183 t.Errorf("p2.Compare(p) = %d", c2)
10184 t.Errorf("p = %#v", p)
10185 t.Errorf("p2 = %#v", p2)
10186 }
10187 }
10188 func TestUnrecognizedWithInner_InnerCompare(t *testing.T) {
10189 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10190 p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
10191 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10192 if err != nil {
10193 panic(err)
10194 }
10195 msg := &UnrecognizedWithInner_Inner{}
10196 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10197 panic(err)
10198 }
10199 if c := p.Compare(msg); c != 0 {
10200 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10201 }
10202 p2 := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
10203 c := p.Compare(p2)
10204 c2 := p2.Compare(p)
10205 if c != (-1 * c2) {
10206 t.Errorf("p.Compare(p2) = %d", c)
10207 t.Errorf("p2.Compare(p) = %d", c2)
10208 t.Errorf("p = %#v", p)
10209 t.Errorf("p2 = %#v", p2)
10210 }
10211 }
10212 func TestUnrecognizedWithEmbedCompare(t *testing.T) {
10213 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10214 p := NewPopulatedUnrecognizedWithEmbed(popr, false)
10215 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10216 if err != nil {
10217 panic(err)
10218 }
10219 msg := &UnrecognizedWithEmbed{}
10220 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10221 panic(err)
10222 }
10223 if c := p.Compare(msg); c != 0 {
10224 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10225 }
10226 p2 := NewPopulatedUnrecognizedWithEmbed(popr, false)
10227 c := p.Compare(p2)
10228 c2 := p2.Compare(p)
10229 if c != (-1 * c2) {
10230 t.Errorf("p.Compare(p2) = %d", c)
10231 t.Errorf("p2.Compare(p) = %d", c2)
10232 t.Errorf("p = %#v", p)
10233 t.Errorf("p2 = %#v", p2)
10234 }
10235 }
10236 func TestUnrecognizedWithEmbed_EmbeddedCompare(t *testing.T) {
10237 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10238 p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
10239 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10240 if err != nil {
10241 panic(err)
10242 }
10243 msg := &UnrecognizedWithEmbed_Embedded{}
10244 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10245 panic(err)
10246 }
10247 if c := p.Compare(msg); c != 0 {
10248 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10249 }
10250 p2 := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
10251 c := p.Compare(p2)
10252 c2 := p2.Compare(p)
10253 if c != (-1 * c2) {
10254 t.Errorf("p.Compare(p2) = %d", c)
10255 t.Errorf("p2.Compare(p) = %d", c2)
10256 t.Errorf("p = %#v", p)
10257 t.Errorf("p2 = %#v", p2)
10258 }
10259 }
10260 func TestNodeCompare(t *testing.T) {
10261 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10262 p := NewPopulatedNode(popr, false)
10263 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10264 if err != nil {
10265 panic(err)
10266 }
10267 msg := &Node{}
10268 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10269 panic(err)
10270 }
10271 if c := p.Compare(msg); c != 0 {
10272 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10273 }
10274 p2 := NewPopulatedNode(popr, false)
10275 c := p.Compare(p2)
10276 c2 := p2.Compare(p)
10277 if c != (-1 * c2) {
10278 t.Errorf("p.Compare(p2) = %d", c)
10279 t.Errorf("p2.Compare(p) = %d", c2)
10280 t.Errorf("p = %#v", p)
10281 t.Errorf("p2 = %#v", p2)
10282 }
10283 }
10284 func TestNonByteCustomTypeCompare(t *testing.T) {
10285 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10286 p := NewPopulatedNonByteCustomType(popr, false)
10287 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10288 if err != nil {
10289 panic(err)
10290 }
10291 msg := &NonByteCustomType{}
10292 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10293 panic(err)
10294 }
10295 if c := p.Compare(msg); c != 0 {
10296 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10297 }
10298 p2 := NewPopulatedNonByteCustomType(popr, false)
10299 c := p.Compare(p2)
10300 c2 := p2.Compare(p)
10301 if c != (-1 * c2) {
10302 t.Errorf("p.Compare(p2) = %d", c)
10303 t.Errorf("p2.Compare(p) = %d", c2)
10304 t.Errorf("p = %#v", p)
10305 t.Errorf("p2 = %#v", p2)
10306 }
10307 }
10308 func TestNidOptNonByteCustomTypeCompare(t *testing.T) {
10309 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10310 p := NewPopulatedNidOptNonByteCustomType(popr, false)
10311 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10312 if err != nil {
10313 panic(err)
10314 }
10315 msg := &NidOptNonByteCustomType{}
10316 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10317 panic(err)
10318 }
10319 if c := p.Compare(msg); c != 0 {
10320 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10321 }
10322 p2 := NewPopulatedNidOptNonByteCustomType(popr, false)
10323 c := p.Compare(p2)
10324 c2 := p2.Compare(p)
10325 if c != (-1 * c2) {
10326 t.Errorf("p.Compare(p2) = %d", c)
10327 t.Errorf("p2.Compare(p) = %d", c2)
10328 t.Errorf("p = %#v", p)
10329 t.Errorf("p2 = %#v", p2)
10330 }
10331 }
10332 func TestNinOptNonByteCustomTypeCompare(t *testing.T) {
10333 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10334 p := NewPopulatedNinOptNonByteCustomType(popr, false)
10335 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10336 if err != nil {
10337 panic(err)
10338 }
10339 msg := &NinOptNonByteCustomType{}
10340 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10341 panic(err)
10342 }
10343 if c := p.Compare(msg); c != 0 {
10344 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10345 }
10346 p2 := NewPopulatedNinOptNonByteCustomType(popr, false)
10347 c := p.Compare(p2)
10348 c2 := p2.Compare(p)
10349 if c != (-1 * c2) {
10350 t.Errorf("p.Compare(p2) = %d", c)
10351 t.Errorf("p2.Compare(p) = %d", c2)
10352 t.Errorf("p = %#v", p)
10353 t.Errorf("p2 = %#v", p2)
10354 }
10355 }
10356 func TestNidRepNonByteCustomTypeCompare(t *testing.T) {
10357 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10358 p := NewPopulatedNidRepNonByteCustomType(popr, false)
10359 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10360 if err != nil {
10361 panic(err)
10362 }
10363 msg := &NidRepNonByteCustomType{}
10364 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10365 panic(err)
10366 }
10367 if c := p.Compare(msg); c != 0 {
10368 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10369 }
10370 p2 := NewPopulatedNidRepNonByteCustomType(popr, false)
10371 c := p.Compare(p2)
10372 c2 := p2.Compare(p)
10373 if c != (-1 * c2) {
10374 t.Errorf("p.Compare(p2) = %d", c)
10375 t.Errorf("p2.Compare(p) = %d", c2)
10376 t.Errorf("p = %#v", p)
10377 t.Errorf("p2 = %#v", p2)
10378 }
10379 }
10380 func TestNinRepNonByteCustomTypeCompare(t *testing.T) {
10381 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10382 p := NewPopulatedNinRepNonByteCustomType(popr, false)
10383 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10384 if err != nil {
10385 panic(err)
10386 }
10387 msg := &NinRepNonByteCustomType{}
10388 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10389 panic(err)
10390 }
10391 if c := p.Compare(msg); c != 0 {
10392 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10393 }
10394 p2 := NewPopulatedNinRepNonByteCustomType(popr, false)
10395 c := p.Compare(p2)
10396 c2 := p2.Compare(p)
10397 if c != (-1 * c2) {
10398 t.Errorf("p.Compare(p2) = %d", c)
10399 t.Errorf("p2.Compare(p) = %d", c2)
10400 t.Errorf("p = %#v", p)
10401 t.Errorf("p2 = %#v", p2)
10402 }
10403 }
10404 func TestProtoTypeCompare(t *testing.T) {
10405 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10406 p := NewPopulatedProtoType(popr, false)
10407 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10408 if err != nil {
10409 panic(err)
10410 }
10411 msg := &ProtoType{}
10412 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10413 panic(err)
10414 }
10415 if c := p.Compare(msg); c != 0 {
10416 t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
10417 }
10418 p2 := NewPopulatedProtoType(popr, false)
10419 c := p.Compare(p2)
10420 c2 := p2.Compare(p)
10421 if c != (-1 * c2) {
10422 t.Errorf("p.Compare(p2) = %d", c)
10423 t.Errorf("p2.Compare(p) = %d", c2)
10424 t.Errorf("p = %#v", p)
10425 t.Errorf("p2 = %#v", p2)
10426 }
10427 }
10428 func TestThetestDescription(t *testing.T) {
10429 ThetestDescription()
10430 }
10431 func TestNidOptNativeVerboseEqual(t *testing.T) {
10432 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10433 p := NewPopulatedNidOptNative(popr, false)
10434 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10435 if err != nil {
10436 panic(err)
10437 }
10438 msg := &NidOptNative{}
10439 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10440 panic(err)
10441 }
10442 if err := p.VerboseEqual(msg); err != nil {
10443 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10444 }
10445 }
10446 func TestNinOptNativeVerboseEqual(t *testing.T) {
10447 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10448 p := NewPopulatedNinOptNative(popr, false)
10449 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10450 if err != nil {
10451 panic(err)
10452 }
10453 msg := &NinOptNative{}
10454 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10455 panic(err)
10456 }
10457 if err := p.VerboseEqual(msg); err != nil {
10458 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10459 }
10460 }
10461 func TestNidRepNativeVerboseEqual(t *testing.T) {
10462 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10463 p := NewPopulatedNidRepNative(popr, false)
10464 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10465 if err != nil {
10466 panic(err)
10467 }
10468 msg := &NidRepNative{}
10469 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10470 panic(err)
10471 }
10472 if err := p.VerboseEqual(msg); err != nil {
10473 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10474 }
10475 }
10476 func TestNinRepNativeVerboseEqual(t *testing.T) {
10477 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10478 p := NewPopulatedNinRepNative(popr, false)
10479 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10480 if err != nil {
10481 panic(err)
10482 }
10483 msg := &NinRepNative{}
10484 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10485 panic(err)
10486 }
10487 if err := p.VerboseEqual(msg); err != nil {
10488 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10489 }
10490 }
10491 func TestNidRepPackedNativeVerboseEqual(t *testing.T) {
10492 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10493 p := NewPopulatedNidRepPackedNative(popr, false)
10494 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10495 if err != nil {
10496 panic(err)
10497 }
10498 msg := &NidRepPackedNative{}
10499 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10500 panic(err)
10501 }
10502 if err := p.VerboseEqual(msg); err != nil {
10503 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10504 }
10505 }
10506 func TestNinRepPackedNativeVerboseEqual(t *testing.T) {
10507 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10508 p := NewPopulatedNinRepPackedNative(popr, false)
10509 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10510 if err != nil {
10511 panic(err)
10512 }
10513 msg := &NinRepPackedNative{}
10514 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10515 panic(err)
10516 }
10517 if err := p.VerboseEqual(msg); err != nil {
10518 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10519 }
10520 }
10521 func TestNidOptStructVerboseEqual(t *testing.T) {
10522 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10523 p := NewPopulatedNidOptStruct(popr, false)
10524 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10525 if err != nil {
10526 panic(err)
10527 }
10528 msg := &NidOptStruct{}
10529 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10530 panic(err)
10531 }
10532 if err := p.VerboseEqual(msg); err != nil {
10533 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10534 }
10535 }
10536 func TestNinOptStructVerboseEqual(t *testing.T) {
10537 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10538 p := NewPopulatedNinOptStruct(popr, false)
10539 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10540 if err != nil {
10541 panic(err)
10542 }
10543 msg := &NinOptStruct{}
10544 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10545 panic(err)
10546 }
10547 if err := p.VerboseEqual(msg); err != nil {
10548 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10549 }
10550 }
10551 func TestNidRepStructVerboseEqual(t *testing.T) {
10552 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10553 p := NewPopulatedNidRepStruct(popr, false)
10554 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10555 if err != nil {
10556 panic(err)
10557 }
10558 msg := &NidRepStruct{}
10559 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10560 panic(err)
10561 }
10562 if err := p.VerboseEqual(msg); err != nil {
10563 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10564 }
10565 }
10566 func TestNinRepStructVerboseEqual(t *testing.T) {
10567 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10568 p := NewPopulatedNinRepStruct(popr, false)
10569 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10570 if err != nil {
10571 panic(err)
10572 }
10573 msg := &NinRepStruct{}
10574 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10575 panic(err)
10576 }
10577 if err := p.VerboseEqual(msg); err != nil {
10578 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10579 }
10580 }
10581 func TestNidEmbeddedStructVerboseEqual(t *testing.T) {
10582 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10583 p := NewPopulatedNidEmbeddedStruct(popr, false)
10584 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10585 if err != nil {
10586 panic(err)
10587 }
10588 msg := &NidEmbeddedStruct{}
10589 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10590 panic(err)
10591 }
10592 if err := p.VerboseEqual(msg); err != nil {
10593 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10594 }
10595 }
10596 func TestNinEmbeddedStructVerboseEqual(t *testing.T) {
10597 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10598 p := NewPopulatedNinEmbeddedStruct(popr, false)
10599 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10600 if err != nil {
10601 panic(err)
10602 }
10603 msg := &NinEmbeddedStruct{}
10604 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10605 panic(err)
10606 }
10607 if err := p.VerboseEqual(msg); err != nil {
10608 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10609 }
10610 }
10611 func TestNidNestedStructVerboseEqual(t *testing.T) {
10612 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10613 p := NewPopulatedNidNestedStruct(popr, false)
10614 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10615 if err != nil {
10616 panic(err)
10617 }
10618 msg := &NidNestedStruct{}
10619 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10620 panic(err)
10621 }
10622 if err := p.VerboseEqual(msg); err != nil {
10623 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10624 }
10625 }
10626 func TestNinNestedStructVerboseEqual(t *testing.T) {
10627 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10628 p := NewPopulatedNinNestedStruct(popr, false)
10629 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10630 if err != nil {
10631 panic(err)
10632 }
10633 msg := &NinNestedStruct{}
10634 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10635 panic(err)
10636 }
10637 if err := p.VerboseEqual(msg); err != nil {
10638 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10639 }
10640 }
10641 func TestNidOptCustomVerboseEqual(t *testing.T) {
10642 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10643 p := NewPopulatedNidOptCustom(popr, false)
10644 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10645 if err != nil {
10646 panic(err)
10647 }
10648 msg := &NidOptCustom{}
10649 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10650 panic(err)
10651 }
10652 if err := p.VerboseEqual(msg); err != nil {
10653 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10654 }
10655 }
10656 func TestCustomDashVerboseEqual(t *testing.T) {
10657 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10658 p := NewPopulatedCustomDash(popr, false)
10659 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10660 if err != nil {
10661 panic(err)
10662 }
10663 msg := &CustomDash{}
10664 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10665 panic(err)
10666 }
10667 if err := p.VerboseEqual(msg); err != nil {
10668 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10669 }
10670 }
10671 func TestNinOptCustomVerboseEqual(t *testing.T) {
10672 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10673 p := NewPopulatedNinOptCustom(popr, false)
10674 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10675 if err != nil {
10676 panic(err)
10677 }
10678 msg := &NinOptCustom{}
10679 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10680 panic(err)
10681 }
10682 if err := p.VerboseEqual(msg); err != nil {
10683 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10684 }
10685 }
10686 func TestNidRepCustomVerboseEqual(t *testing.T) {
10687 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10688 p := NewPopulatedNidRepCustom(popr, false)
10689 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10690 if err != nil {
10691 panic(err)
10692 }
10693 msg := &NidRepCustom{}
10694 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10695 panic(err)
10696 }
10697 if err := p.VerboseEqual(msg); err != nil {
10698 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10699 }
10700 }
10701 func TestNinRepCustomVerboseEqual(t *testing.T) {
10702 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10703 p := NewPopulatedNinRepCustom(popr, false)
10704 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10705 if err != nil {
10706 panic(err)
10707 }
10708 msg := &NinRepCustom{}
10709 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10710 panic(err)
10711 }
10712 if err := p.VerboseEqual(msg); err != nil {
10713 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10714 }
10715 }
10716 func TestNinOptNativeUnionVerboseEqual(t *testing.T) {
10717 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10718 p := NewPopulatedNinOptNativeUnion(popr, false)
10719 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10720 if err != nil {
10721 panic(err)
10722 }
10723 msg := &NinOptNativeUnion{}
10724 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10725 panic(err)
10726 }
10727 if err := p.VerboseEqual(msg); err != nil {
10728 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10729 }
10730 }
10731 func TestNinOptStructUnionVerboseEqual(t *testing.T) {
10732 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10733 p := NewPopulatedNinOptStructUnion(popr, false)
10734 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10735 if err != nil {
10736 panic(err)
10737 }
10738 msg := &NinOptStructUnion{}
10739 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10740 panic(err)
10741 }
10742 if err := p.VerboseEqual(msg); err != nil {
10743 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10744 }
10745 }
10746 func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) {
10747 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10748 p := NewPopulatedNinEmbeddedStructUnion(popr, false)
10749 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10750 if err != nil {
10751 panic(err)
10752 }
10753 msg := &NinEmbeddedStructUnion{}
10754 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10755 panic(err)
10756 }
10757 if err := p.VerboseEqual(msg); err != nil {
10758 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10759 }
10760 }
10761 func TestNinNestedStructUnionVerboseEqual(t *testing.T) {
10762 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10763 p := NewPopulatedNinNestedStructUnion(popr, false)
10764 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10765 if err != nil {
10766 panic(err)
10767 }
10768 msg := &NinNestedStructUnion{}
10769 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10770 panic(err)
10771 }
10772 if err := p.VerboseEqual(msg); err != nil {
10773 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10774 }
10775 }
10776 func TestTreeVerboseEqual(t *testing.T) {
10777 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10778 p := NewPopulatedTree(popr, false)
10779 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10780 if err != nil {
10781 panic(err)
10782 }
10783 msg := &Tree{}
10784 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10785 panic(err)
10786 }
10787 if err := p.VerboseEqual(msg); err != nil {
10788 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10789 }
10790 }
10791 func TestOrBranchVerboseEqual(t *testing.T) {
10792 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10793 p := NewPopulatedOrBranch(popr, false)
10794 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10795 if err != nil {
10796 panic(err)
10797 }
10798 msg := &OrBranch{}
10799 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10800 panic(err)
10801 }
10802 if err := p.VerboseEqual(msg); err != nil {
10803 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10804 }
10805 }
10806 func TestAndBranchVerboseEqual(t *testing.T) {
10807 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10808 p := NewPopulatedAndBranch(popr, false)
10809 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10810 if err != nil {
10811 panic(err)
10812 }
10813 msg := &AndBranch{}
10814 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10815 panic(err)
10816 }
10817 if err := p.VerboseEqual(msg); err != nil {
10818 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10819 }
10820 }
10821 func TestLeafVerboseEqual(t *testing.T) {
10822 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10823 p := NewPopulatedLeaf(popr, false)
10824 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10825 if err != nil {
10826 panic(err)
10827 }
10828 msg := &Leaf{}
10829 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10830 panic(err)
10831 }
10832 if err := p.VerboseEqual(msg); err != nil {
10833 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10834 }
10835 }
10836 func TestDeepTreeVerboseEqual(t *testing.T) {
10837 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10838 p := NewPopulatedDeepTree(popr, false)
10839 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10840 if err != nil {
10841 panic(err)
10842 }
10843 msg := &DeepTree{}
10844 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10845 panic(err)
10846 }
10847 if err := p.VerboseEqual(msg); err != nil {
10848 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10849 }
10850 }
10851 func TestADeepBranchVerboseEqual(t *testing.T) {
10852 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10853 p := NewPopulatedADeepBranch(popr, false)
10854 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10855 if err != nil {
10856 panic(err)
10857 }
10858 msg := &ADeepBranch{}
10859 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10860 panic(err)
10861 }
10862 if err := p.VerboseEqual(msg); err != nil {
10863 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10864 }
10865 }
10866 func TestAndDeepBranchVerboseEqual(t *testing.T) {
10867 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10868 p := NewPopulatedAndDeepBranch(popr, false)
10869 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10870 if err != nil {
10871 panic(err)
10872 }
10873 msg := &AndDeepBranch{}
10874 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10875 panic(err)
10876 }
10877 if err := p.VerboseEqual(msg); err != nil {
10878 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10879 }
10880 }
10881 func TestDeepLeafVerboseEqual(t *testing.T) {
10882 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10883 p := NewPopulatedDeepLeaf(popr, false)
10884 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10885 if err != nil {
10886 panic(err)
10887 }
10888 msg := &DeepLeaf{}
10889 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10890 panic(err)
10891 }
10892 if err := p.VerboseEqual(msg); err != nil {
10893 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10894 }
10895 }
10896 func TestNilVerboseEqual(t *testing.T) {
10897 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10898 p := NewPopulatedNil(popr, false)
10899 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10900 if err != nil {
10901 panic(err)
10902 }
10903 msg := &Nil{}
10904 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10905 panic(err)
10906 }
10907 if err := p.VerboseEqual(msg); err != nil {
10908 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10909 }
10910 }
10911 func TestNidOptEnumVerboseEqual(t *testing.T) {
10912 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10913 p := NewPopulatedNidOptEnum(popr, false)
10914 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10915 if err != nil {
10916 panic(err)
10917 }
10918 msg := &NidOptEnum{}
10919 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10920 panic(err)
10921 }
10922 if err := p.VerboseEqual(msg); err != nil {
10923 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10924 }
10925 }
10926 func TestNinOptEnumVerboseEqual(t *testing.T) {
10927 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10928 p := NewPopulatedNinOptEnum(popr, false)
10929 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10930 if err != nil {
10931 panic(err)
10932 }
10933 msg := &NinOptEnum{}
10934 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10935 panic(err)
10936 }
10937 if err := p.VerboseEqual(msg); err != nil {
10938 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10939 }
10940 }
10941 func TestNidRepEnumVerboseEqual(t *testing.T) {
10942 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10943 p := NewPopulatedNidRepEnum(popr, false)
10944 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10945 if err != nil {
10946 panic(err)
10947 }
10948 msg := &NidRepEnum{}
10949 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10950 panic(err)
10951 }
10952 if err := p.VerboseEqual(msg); err != nil {
10953 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10954 }
10955 }
10956 func TestNinRepEnumVerboseEqual(t *testing.T) {
10957 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10958 p := NewPopulatedNinRepEnum(popr, false)
10959 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10960 if err != nil {
10961 panic(err)
10962 }
10963 msg := &NinRepEnum{}
10964 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10965 panic(err)
10966 }
10967 if err := p.VerboseEqual(msg); err != nil {
10968 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10969 }
10970 }
10971 func TestNinOptEnumDefaultVerboseEqual(t *testing.T) {
10972 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10973 p := NewPopulatedNinOptEnumDefault(popr, false)
10974 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10975 if err != nil {
10976 panic(err)
10977 }
10978 msg := &NinOptEnumDefault{}
10979 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10980 panic(err)
10981 }
10982 if err := p.VerboseEqual(msg); err != nil {
10983 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10984 }
10985 }
10986 func TestAnotherNinOptEnumVerboseEqual(t *testing.T) {
10987 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
10988 p := NewPopulatedAnotherNinOptEnum(popr, false)
10989 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
10990 if err != nil {
10991 panic(err)
10992 }
10993 msg := &AnotherNinOptEnum{}
10994 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
10995 panic(err)
10996 }
10997 if err := p.VerboseEqual(msg); err != nil {
10998 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
10999 }
11000 }
11001 func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) {
11002 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11003 p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
11004 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11005 if err != nil {
11006 panic(err)
11007 }
11008 msg := &AnotherNinOptEnumDefault{}
11009 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11010 panic(err)
11011 }
11012 if err := p.VerboseEqual(msg); err != nil {
11013 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11014 }
11015 }
11016 func TestTimerVerboseEqual(t *testing.T) {
11017 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11018 p := NewPopulatedTimer(popr, false)
11019 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11020 if err != nil {
11021 panic(err)
11022 }
11023 msg := &Timer{}
11024 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11025 panic(err)
11026 }
11027 if err := p.VerboseEqual(msg); err != nil {
11028 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11029 }
11030 }
11031 func TestMyExtendableVerboseEqual(t *testing.T) {
11032 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11033 p := NewPopulatedMyExtendable(popr, false)
11034 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11035 if err != nil {
11036 panic(err)
11037 }
11038 msg := &MyExtendable{}
11039 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11040 panic(err)
11041 }
11042 if err := p.VerboseEqual(msg); err != nil {
11043 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11044 }
11045 }
11046 func TestOtherExtenableVerboseEqual(t *testing.T) {
11047 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11048 p := NewPopulatedOtherExtenable(popr, false)
11049 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11050 if err != nil {
11051 panic(err)
11052 }
11053 msg := &OtherExtenable{}
11054 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11055 panic(err)
11056 }
11057 if err := p.VerboseEqual(msg); err != nil {
11058 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11059 }
11060 }
11061 func TestNestedDefinitionVerboseEqual(t *testing.T) {
11062 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11063 p := NewPopulatedNestedDefinition(popr, false)
11064 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11065 if err != nil {
11066 panic(err)
11067 }
11068 msg := &NestedDefinition{}
11069 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11070 panic(err)
11071 }
11072 if err := p.VerboseEqual(msg); err != nil {
11073 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11074 }
11075 }
11076 func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) {
11077 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11078 p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
11079 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11080 if err != nil {
11081 panic(err)
11082 }
11083 msg := &NestedDefinition_NestedMessage{}
11084 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11085 panic(err)
11086 }
11087 if err := p.VerboseEqual(msg); err != nil {
11088 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11089 }
11090 }
11091 func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) {
11092 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11093 p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
11094 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11095 if err != nil {
11096 panic(err)
11097 }
11098 msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
11099 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11100 panic(err)
11101 }
11102 if err := p.VerboseEqual(msg); err != nil {
11103 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11104 }
11105 }
11106 func TestNestedScopeVerboseEqual(t *testing.T) {
11107 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11108 p := NewPopulatedNestedScope(popr, false)
11109 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11110 if err != nil {
11111 panic(err)
11112 }
11113 msg := &NestedScope{}
11114 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11115 panic(err)
11116 }
11117 if err := p.VerboseEqual(msg); err != nil {
11118 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11119 }
11120 }
11121 func TestNinOptNativeDefaultVerboseEqual(t *testing.T) {
11122 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11123 p := NewPopulatedNinOptNativeDefault(popr, false)
11124 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11125 if err != nil {
11126 panic(err)
11127 }
11128 msg := &NinOptNativeDefault{}
11129 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11130 panic(err)
11131 }
11132 if err := p.VerboseEqual(msg); err != nil {
11133 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11134 }
11135 }
11136 func TestCustomContainerVerboseEqual(t *testing.T) {
11137 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11138 p := NewPopulatedCustomContainer(popr, false)
11139 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11140 if err != nil {
11141 panic(err)
11142 }
11143 msg := &CustomContainer{}
11144 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11145 panic(err)
11146 }
11147 if err := p.VerboseEqual(msg); err != nil {
11148 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11149 }
11150 }
11151 func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) {
11152 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11153 p := NewPopulatedCustomNameNidOptNative(popr, false)
11154 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11155 if err != nil {
11156 panic(err)
11157 }
11158 msg := &CustomNameNidOptNative{}
11159 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11160 panic(err)
11161 }
11162 if err := p.VerboseEqual(msg); err != nil {
11163 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11164 }
11165 }
11166 func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) {
11167 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11168 p := NewPopulatedCustomNameNinOptNative(popr, false)
11169 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11170 if err != nil {
11171 panic(err)
11172 }
11173 msg := &CustomNameNinOptNative{}
11174 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11175 panic(err)
11176 }
11177 if err := p.VerboseEqual(msg); err != nil {
11178 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11179 }
11180 }
11181 func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) {
11182 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11183 p := NewPopulatedCustomNameNinRepNative(popr, false)
11184 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11185 if err != nil {
11186 panic(err)
11187 }
11188 msg := &CustomNameNinRepNative{}
11189 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11190 panic(err)
11191 }
11192 if err := p.VerboseEqual(msg); err != nil {
11193 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11194 }
11195 }
11196 func TestCustomNameNinStructVerboseEqual(t *testing.T) {
11197 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11198 p := NewPopulatedCustomNameNinStruct(popr, false)
11199 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11200 if err != nil {
11201 panic(err)
11202 }
11203 msg := &CustomNameNinStruct{}
11204 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11205 panic(err)
11206 }
11207 if err := p.VerboseEqual(msg); err != nil {
11208 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11209 }
11210 }
11211 func TestCustomNameCustomTypeVerboseEqual(t *testing.T) {
11212 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11213 p := NewPopulatedCustomNameCustomType(popr, false)
11214 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11215 if err != nil {
11216 panic(err)
11217 }
11218 msg := &CustomNameCustomType{}
11219 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11220 panic(err)
11221 }
11222 if err := p.VerboseEqual(msg); err != nil {
11223 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11224 }
11225 }
11226 func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) {
11227 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11228 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
11229 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11230 if err != nil {
11231 panic(err)
11232 }
11233 msg := &CustomNameNinEmbeddedStructUnion{}
11234 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11235 panic(err)
11236 }
11237 if err := p.VerboseEqual(msg); err != nil {
11238 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11239 }
11240 }
11241 func TestCustomNameEnumVerboseEqual(t *testing.T) {
11242 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11243 p := NewPopulatedCustomNameEnum(popr, false)
11244 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11245 if err != nil {
11246 panic(err)
11247 }
11248 msg := &CustomNameEnum{}
11249 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11250 panic(err)
11251 }
11252 if err := p.VerboseEqual(msg); err != nil {
11253 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11254 }
11255 }
11256 func TestNoExtensionsMapVerboseEqual(t *testing.T) {
11257 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11258 p := NewPopulatedNoExtensionsMap(popr, false)
11259 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11260 if err != nil {
11261 panic(err)
11262 }
11263 msg := &NoExtensionsMap{}
11264 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11265 panic(err)
11266 }
11267 if err := p.VerboseEqual(msg); err != nil {
11268 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11269 }
11270 }
11271 func TestUnrecognizedVerboseEqual(t *testing.T) {
11272 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11273 p := NewPopulatedUnrecognized(popr, false)
11274 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11275 if err != nil {
11276 panic(err)
11277 }
11278 msg := &Unrecognized{}
11279 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11280 panic(err)
11281 }
11282 if err := p.VerboseEqual(msg); err != nil {
11283 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11284 }
11285 }
11286 func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) {
11287 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11288 p := NewPopulatedUnrecognizedWithInner(popr, false)
11289 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11290 if err != nil {
11291 panic(err)
11292 }
11293 msg := &UnrecognizedWithInner{}
11294 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11295 panic(err)
11296 }
11297 if err := p.VerboseEqual(msg); err != nil {
11298 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11299 }
11300 }
11301 func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) {
11302 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11303 p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
11304 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11305 if err != nil {
11306 panic(err)
11307 }
11308 msg := &UnrecognizedWithInner_Inner{}
11309 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11310 panic(err)
11311 }
11312 if err := p.VerboseEqual(msg); err != nil {
11313 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11314 }
11315 }
11316 func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) {
11317 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11318 p := NewPopulatedUnrecognizedWithEmbed(popr, false)
11319 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11320 if err != nil {
11321 panic(err)
11322 }
11323 msg := &UnrecognizedWithEmbed{}
11324 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11325 panic(err)
11326 }
11327 if err := p.VerboseEqual(msg); err != nil {
11328 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11329 }
11330 }
11331 func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) {
11332 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11333 p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
11334 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11335 if err != nil {
11336 panic(err)
11337 }
11338 msg := &UnrecognizedWithEmbed_Embedded{}
11339 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11340 panic(err)
11341 }
11342 if err := p.VerboseEqual(msg); err != nil {
11343 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11344 }
11345 }
11346 func TestNodeVerboseEqual(t *testing.T) {
11347 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11348 p := NewPopulatedNode(popr, false)
11349 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11350 if err != nil {
11351 panic(err)
11352 }
11353 msg := &Node{}
11354 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11355 panic(err)
11356 }
11357 if err := p.VerboseEqual(msg); err != nil {
11358 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11359 }
11360 }
11361 func TestNonByteCustomTypeVerboseEqual(t *testing.T) {
11362 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11363 p := NewPopulatedNonByteCustomType(popr, false)
11364 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11365 if err != nil {
11366 panic(err)
11367 }
11368 msg := &NonByteCustomType{}
11369 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11370 panic(err)
11371 }
11372 if err := p.VerboseEqual(msg); err != nil {
11373 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11374 }
11375 }
11376 func TestNidOptNonByteCustomTypeVerboseEqual(t *testing.T) {
11377 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11378 p := NewPopulatedNidOptNonByteCustomType(popr, false)
11379 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11380 if err != nil {
11381 panic(err)
11382 }
11383 msg := &NidOptNonByteCustomType{}
11384 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11385 panic(err)
11386 }
11387 if err := p.VerboseEqual(msg); err != nil {
11388 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11389 }
11390 }
11391 func TestNinOptNonByteCustomTypeVerboseEqual(t *testing.T) {
11392 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11393 p := NewPopulatedNinOptNonByteCustomType(popr, false)
11394 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11395 if err != nil {
11396 panic(err)
11397 }
11398 msg := &NinOptNonByteCustomType{}
11399 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11400 panic(err)
11401 }
11402 if err := p.VerboseEqual(msg); err != nil {
11403 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11404 }
11405 }
11406 func TestNidRepNonByteCustomTypeVerboseEqual(t *testing.T) {
11407 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11408 p := NewPopulatedNidRepNonByteCustomType(popr, false)
11409 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11410 if err != nil {
11411 panic(err)
11412 }
11413 msg := &NidRepNonByteCustomType{}
11414 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11415 panic(err)
11416 }
11417 if err := p.VerboseEqual(msg); err != nil {
11418 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11419 }
11420 }
11421 func TestNinRepNonByteCustomTypeVerboseEqual(t *testing.T) {
11422 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11423 p := NewPopulatedNinRepNonByteCustomType(popr, false)
11424 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11425 if err != nil {
11426 panic(err)
11427 }
11428 msg := &NinRepNonByteCustomType{}
11429 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11430 panic(err)
11431 }
11432 if err := p.VerboseEqual(msg); err != nil {
11433 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11434 }
11435 }
11436 func TestProtoTypeVerboseEqual(t *testing.T) {
11437 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11438 p := NewPopulatedProtoType(popr, false)
11439 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
11440 if err != nil {
11441 panic(err)
11442 }
11443 msg := &ProtoType{}
11444 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
11445 panic(err)
11446 }
11447 if err := p.VerboseEqual(msg); err != nil {
11448 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
11449 }
11450 }
11451 func TestNidOptNativeFace(t *testing.T) {
11452 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11453 p := NewPopulatedNidOptNative(popr, true)
11454 msg := p.TestProto()
11455 if !p.Equal(msg) {
11456 t.Fatalf("%#v !Face Equal %#v", msg, p)
11457 }
11458 }
11459 func TestNinOptNativeFace(t *testing.T) {
11460 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11461 p := NewPopulatedNinOptNative(popr, true)
11462 msg := p.TestProto()
11463 if !p.Equal(msg) {
11464 t.Fatalf("%#v !Face Equal %#v", msg, p)
11465 }
11466 }
11467 func TestNidRepNativeFace(t *testing.T) {
11468 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11469 p := NewPopulatedNidRepNative(popr, true)
11470 msg := p.TestProto()
11471 if !p.Equal(msg) {
11472 t.Fatalf("%#v !Face Equal %#v", msg, p)
11473 }
11474 }
11475 func TestNinRepNativeFace(t *testing.T) {
11476 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11477 p := NewPopulatedNinRepNative(popr, true)
11478 msg := p.TestProto()
11479 if !p.Equal(msg) {
11480 t.Fatalf("%#v !Face Equal %#v", msg, p)
11481 }
11482 }
11483 func TestNidRepPackedNativeFace(t *testing.T) {
11484 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11485 p := NewPopulatedNidRepPackedNative(popr, true)
11486 msg := p.TestProto()
11487 if !p.Equal(msg) {
11488 t.Fatalf("%#v !Face Equal %#v", msg, p)
11489 }
11490 }
11491 func TestNinRepPackedNativeFace(t *testing.T) {
11492 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11493 p := NewPopulatedNinRepPackedNative(popr, true)
11494 msg := p.TestProto()
11495 if !p.Equal(msg) {
11496 t.Fatalf("%#v !Face Equal %#v", msg, p)
11497 }
11498 }
11499 func TestNidOptStructFace(t *testing.T) {
11500 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11501 p := NewPopulatedNidOptStruct(popr, true)
11502 msg := p.TestProto()
11503 if !p.Equal(msg) {
11504 t.Fatalf("%#v !Face Equal %#v", msg, p)
11505 }
11506 }
11507 func TestNinOptStructFace(t *testing.T) {
11508 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11509 p := NewPopulatedNinOptStruct(popr, true)
11510 msg := p.TestProto()
11511 if !p.Equal(msg) {
11512 t.Fatalf("%#v !Face Equal %#v", msg, p)
11513 }
11514 }
11515 func TestNidRepStructFace(t *testing.T) {
11516 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11517 p := NewPopulatedNidRepStruct(popr, true)
11518 msg := p.TestProto()
11519 if !p.Equal(msg) {
11520 t.Fatalf("%#v !Face Equal %#v", msg, p)
11521 }
11522 }
11523 func TestNinRepStructFace(t *testing.T) {
11524 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11525 p := NewPopulatedNinRepStruct(popr, true)
11526 msg := p.TestProto()
11527 if !p.Equal(msg) {
11528 t.Fatalf("%#v !Face Equal %#v", msg, p)
11529 }
11530 }
11531 func TestNidEmbeddedStructFace(t *testing.T) {
11532 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11533 p := NewPopulatedNidEmbeddedStruct(popr, true)
11534 msg := p.TestProto()
11535 if !p.Equal(msg) {
11536 t.Fatalf("%#v !Face Equal %#v", msg, p)
11537 }
11538 }
11539 func TestNinEmbeddedStructFace(t *testing.T) {
11540 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11541 p := NewPopulatedNinEmbeddedStruct(popr, true)
11542 msg := p.TestProto()
11543 if !p.Equal(msg) {
11544 t.Fatalf("%#v !Face Equal %#v", msg, p)
11545 }
11546 }
11547 func TestNidNestedStructFace(t *testing.T) {
11548 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11549 p := NewPopulatedNidNestedStruct(popr, true)
11550 msg := p.TestProto()
11551 if !p.Equal(msg) {
11552 t.Fatalf("%#v !Face Equal %#v", msg, p)
11553 }
11554 }
11555 func TestNinNestedStructFace(t *testing.T) {
11556 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11557 p := NewPopulatedNinNestedStruct(popr, true)
11558 msg := p.TestProto()
11559 if !p.Equal(msg) {
11560 t.Fatalf("%#v !Face Equal %#v", msg, p)
11561 }
11562 }
11563 func TestNidOptCustomFace(t *testing.T) {
11564 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11565 p := NewPopulatedNidOptCustom(popr, true)
11566 msg := p.TestProto()
11567 if !p.Equal(msg) {
11568 t.Fatalf("%#v !Face Equal %#v", msg, p)
11569 }
11570 }
11571 func TestCustomDashFace(t *testing.T) {
11572 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11573 p := NewPopulatedCustomDash(popr, true)
11574 msg := p.TestProto()
11575 if !p.Equal(msg) {
11576 t.Fatalf("%#v !Face Equal %#v", msg, p)
11577 }
11578 }
11579 func TestNinOptCustomFace(t *testing.T) {
11580 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11581 p := NewPopulatedNinOptCustom(popr, true)
11582 msg := p.TestProto()
11583 if !p.Equal(msg) {
11584 t.Fatalf("%#v !Face Equal %#v", msg, p)
11585 }
11586 }
11587 func TestNidRepCustomFace(t *testing.T) {
11588 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11589 p := NewPopulatedNidRepCustom(popr, true)
11590 msg := p.TestProto()
11591 if !p.Equal(msg) {
11592 t.Fatalf("%#v !Face Equal %#v", msg, p)
11593 }
11594 }
11595 func TestNinRepCustomFace(t *testing.T) {
11596 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11597 p := NewPopulatedNinRepCustom(popr, true)
11598 msg := p.TestProto()
11599 if !p.Equal(msg) {
11600 t.Fatalf("%#v !Face Equal %#v", msg, p)
11601 }
11602 }
11603 func TestNinOptNativeUnionFace(t *testing.T) {
11604 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11605 p := NewPopulatedNinOptNativeUnion(popr, true)
11606 msg := p.TestProto()
11607 if !p.Equal(msg) {
11608 t.Fatalf("%#v !Face Equal %#v", msg, p)
11609 }
11610 }
11611 func TestNinOptStructUnionFace(t *testing.T) {
11612 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11613 p := NewPopulatedNinOptStructUnion(popr, true)
11614 msg := p.TestProto()
11615 if !p.Equal(msg) {
11616 t.Fatalf("%#v !Face Equal %#v", msg, p)
11617 }
11618 }
11619 func TestNinEmbeddedStructUnionFace(t *testing.T) {
11620 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11621 p := NewPopulatedNinEmbeddedStructUnion(popr, true)
11622 msg := p.TestProto()
11623 if !p.Equal(msg) {
11624 t.Fatalf("%#v !Face Equal %#v", msg, p)
11625 }
11626 }
11627 func TestNinNestedStructUnionFace(t *testing.T) {
11628 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11629 p := NewPopulatedNinNestedStructUnion(popr, true)
11630 msg := p.TestProto()
11631 if !p.Equal(msg) {
11632 t.Fatalf("%#v !Face Equal %#v", msg, p)
11633 }
11634 }
11635 func TestTreeFace(t *testing.T) {
11636 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11637 p := NewPopulatedTree(popr, true)
11638 msg := p.TestProto()
11639 if !p.Equal(msg) {
11640 t.Fatalf("%#v !Face Equal %#v", msg, p)
11641 }
11642 }
11643 func TestOrBranchFace(t *testing.T) {
11644 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11645 p := NewPopulatedOrBranch(popr, true)
11646 msg := p.TestProto()
11647 if !p.Equal(msg) {
11648 t.Fatalf("%#v !Face Equal %#v", msg, p)
11649 }
11650 }
11651 func TestAndBranchFace(t *testing.T) {
11652 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11653 p := NewPopulatedAndBranch(popr, true)
11654 msg := p.TestProto()
11655 if !p.Equal(msg) {
11656 t.Fatalf("%#v !Face Equal %#v", msg, p)
11657 }
11658 }
11659 func TestLeafFace(t *testing.T) {
11660 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11661 p := NewPopulatedLeaf(popr, true)
11662 msg := p.TestProto()
11663 if !p.Equal(msg) {
11664 t.Fatalf("%#v !Face Equal %#v", msg, p)
11665 }
11666 }
11667 func TestDeepTreeFace(t *testing.T) {
11668 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11669 p := NewPopulatedDeepTree(popr, true)
11670 msg := p.TestProto()
11671 if !p.Equal(msg) {
11672 t.Fatalf("%#v !Face Equal %#v", msg, p)
11673 }
11674 }
11675 func TestADeepBranchFace(t *testing.T) {
11676 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11677 p := NewPopulatedADeepBranch(popr, true)
11678 msg := p.TestProto()
11679 if !p.Equal(msg) {
11680 t.Fatalf("%#v !Face Equal %#v", msg, p)
11681 }
11682 }
11683 func TestAndDeepBranchFace(t *testing.T) {
11684 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11685 p := NewPopulatedAndDeepBranch(popr, true)
11686 msg := p.TestProto()
11687 if !p.Equal(msg) {
11688 t.Fatalf("%#v !Face Equal %#v", msg, p)
11689 }
11690 }
11691 func TestDeepLeafFace(t *testing.T) {
11692 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11693 p := NewPopulatedDeepLeaf(popr, true)
11694 msg := p.TestProto()
11695 if !p.Equal(msg) {
11696 t.Fatalf("%#v !Face Equal %#v", msg, p)
11697 }
11698 }
11699 func TestNilFace(t *testing.T) {
11700 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11701 p := NewPopulatedNil(popr, true)
11702 msg := p.TestProto()
11703 if !p.Equal(msg) {
11704 t.Fatalf("%#v !Face Equal %#v", msg, p)
11705 }
11706 }
11707 func TestNidOptEnumFace(t *testing.T) {
11708 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11709 p := NewPopulatedNidOptEnum(popr, true)
11710 msg := p.TestProto()
11711 if !p.Equal(msg) {
11712 t.Fatalf("%#v !Face Equal %#v", msg, p)
11713 }
11714 }
11715 func TestNinOptEnumFace(t *testing.T) {
11716 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11717 p := NewPopulatedNinOptEnum(popr, true)
11718 msg := p.TestProto()
11719 if !p.Equal(msg) {
11720 t.Fatalf("%#v !Face Equal %#v", msg, p)
11721 }
11722 }
11723 func TestNidRepEnumFace(t *testing.T) {
11724 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11725 p := NewPopulatedNidRepEnum(popr, true)
11726 msg := p.TestProto()
11727 if !p.Equal(msg) {
11728 t.Fatalf("%#v !Face Equal %#v", msg, p)
11729 }
11730 }
11731 func TestNinRepEnumFace(t *testing.T) {
11732 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11733 p := NewPopulatedNinRepEnum(popr, true)
11734 msg := p.TestProto()
11735 if !p.Equal(msg) {
11736 t.Fatalf("%#v !Face Equal %#v", msg, p)
11737 }
11738 }
11739 func TestAnotherNinOptEnumFace(t *testing.T) {
11740 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11741 p := NewPopulatedAnotherNinOptEnum(popr, true)
11742 msg := p.TestProto()
11743 if !p.Equal(msg) {
11744 t.Fatalf("%#v !Face Equal %#v", msg, p)
11745 }
11746 }
11747 func TestTimerFace(t *testing.T) {
11748 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11749 p := NewPopulatedTimer(popr, true)
11750 msg := p.TestProto()
11751 if !p.Equal(msg) {
11752 t.Fatalf("%#v !Face Equal %#v", msg, p)
11753 }
11754 }
11755 func TestNestedDefinitionFace(t *testing.T) {
11756 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11757 p := NewPopulatedNestedDefinition(popr, true)
11758 msg := p.TestProto()
11759 if !p.Equal(msg) {
11760 t.Fatalf("%#v !Face Equal %#v", msg, p)
11761 }
11762 }
11763 func TestNestedDefinition_NestedMessageFace(t *testing.T) {
11764 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11765 p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
11766 msg := p.TestProto()
11767 if !p.Equal(msg) {
11768 t.Fatalf("%#v !Face Equal %#v", msg, p)
11769 }
11770 }
11771 func TestNestedDefinition_NestedMessage_NestedNestedMsgFace(t *testing.T) {
11772 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11773 p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
11774 msg := p.TestProto()
11775 if !p.Equal(msg) {
11776 t.Fatalf("%#v !Face Equal %#v", msg, p)
11777 }
11778 }
11779 func TestNestedScopeFace(t *testing.T) {
11780 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11781 p := NewPopulatedNestedScope(popr, true)
11782 msg := p.TestProto()
11783 if !p.Equal(msg) {
11784 t.Fatalf("%#v !Face Equal %#v", msg, p)
11785 }
11786 }
11787 func TestCustomContainerFace(t *testing.T) {
11788 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11789 p := NewPopulatedCustomContainer(popr, true)
11790 msg := p.TestProto()
11791 if !p.Equal(msg) {
11792 t.Fatalf("%#v !Face Equal %#v", msg, p)
11793 }
11794 }
11795 func TestCustomNameNidOptNativeFace(t *testing.T) {
11796 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11797 p := NewPopulatedCustomNameNidOptNative(popr, true)
11798 msg := p.TestProto()
11799 if !p.Equal(msg) {
11800 t.Fatalf("%#v !Face Equal %#v", msg, p)
11801 }
11802 }
11803 func TestCustomNameNinOptNativeFace(t *testing.T) {
11804 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11805 p := NewPopulatedCustomNameNinOptNative(popr, true)
11806 msg := p.TestProto()
11807 if !p.Equal(msg) {
11808 t.Fatalf("%#v !Face Equal %#v", msg, p)
11809 }
11810 }
11811 func TestCustomNameNinRepNativeFace(t *testing.T) {
11812 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11813 p := NewPopulatedCustomNameNinRepNative(popr, true)
11814 msg := p.TestProto()
11815 if !p.Equal(msg) {
11816 t.Fatalf("%#v !Face Equal %#v", msg, p)
11817 }
11818 }
11819 func TestCustomNameNinStructFace(t *testing.T) {
11820 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11821 p := NewPopulatedCustomNameNinStruct(popr, true)
11822 msg := p.TestProto()
11823 if !p.Equal(msg) {
11824 t.Fatalf("%#v !Face Equal %#v", msg, p)
11825 }
11826 }
11827 func TestCustomNameCustomTypeFace(t *testing.T) {
11828 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11829 p := NewPopulatedCustomNameCustomType(popr, true)
11830 msg := p.TestProto()
11831 if !p.Equal(msg) {
11832 t.Fatalf("%#v !Face Equal %#v", msg, p)
11833 }
11834 }
11835 func TestCustomNameNinEmbeddedStructUnionFace(t *testing.T) {
11836 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11837 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
11838 msg := p.TestProto()
11839 if !p.Equal(msg) {
11840 t.Fatalf("%#v !Face Equal %#v", msg, p)
11841 }
11842 }
11843 func TestCustomNameEnumFace(t *testing.T) {
11844 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11845 p := NewPopulatedCustomNameEnum(popr, true)
11846 msg := p.TestProto()
11847 if !p.Equal(msg) {
11848 t.Fatalf("%#v !Face Equal %#v", msg, p)
11849 }
11850 }
11851 func TestUnrecognizedFace(t *testing.T) {
11852 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11853 p := NewPopulatedUnrecognized(popr, true)
11854 msg := p.TestProto()
11855 if !p.Equal(msg) {
11856 t.Fatalf("%#v !Face Equal %#v", msg, p)
11857 }
11858 }
11859 func TestUnrecognizedWithInnerFace(t *testing.T) {
11860 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11861 p := NewPopulatedUnrecognizedWithInner(popr, true)
11862 msg := p.TestProto()
11863 if !p.Equal(msg) {
11864 t.Fatalf("%#v !Face Equal %#v", msg, p)
11865 }
11866 }
11867 func TestUnrecognizedWithInner_InnerFace(t *testing.T) {
11868 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11869 p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
11870 msg := p.TestProto()
11871 if !p.Equal(msg) {
11872 t.Fatalf("%#v !Face Equal %#v", msg, p)
11873 }
11874 }
11875 func TestUnrecognizedWithEmbedFace(t *testing.T) {
11876 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11877 p := NewPopulatedUnrecognizedWithEmbed(popr, true)
11878 msg := p.TestProto()
11879 if !p.Equal(msg) {
11880 t.Fatalf("%#v !Face Equal %#v", msg, p)
11881 }
11882 }
11883 func TestUnrecognizedWithEmbed_EmbeddedFace(t *testing.T) {
11884 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11885 p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
11886 msg := p.TestProto()
11887 if !p.Equal(msg) {
11888 t.Fatalf("%#v !Face Equal %#v", msg, p)
11889 }
11890 }
11891 func TestNodeFace(t *testing.T) {
11892 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11893 p := NewPopulatedNode(popr, true)
11894 msg := p.TestProto()
11895 if !p.Equal(msg) {
11896 t.Fatalf("%#v !Face Equal %#v", msg, p)
11897 }
11898 }
11899 func TestNonByteCustomTypeFace(t *testing.T) {
11900 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11901 p := NewPopulatedNonByteCustomType(popr, true)
11902 msg := p.TestProto()
11903 if !p.Equal(msg) {
11904 t.Fatalf("%#v !Face Equal %#v", msg, p)
11905 }
11906 }
11907 func TestNidOptNonByteCustomTypeFace(t *testing.T) {
11908 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11909 p := NewPopulatedNidOptNonByteCustomType(popr, true)
11910 msg := p.TestProto()
11911 if !p.Equal(msg) {
11912 t.Fatalf("%#v !Face Equal %#v", msg, p)
11913 }
11914 }
11915 func TestNinOptNonByteCustomTypeFace(t *testing.T) {
11916 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11917 p := NewPopulatedNinOptNonByteCustomType(popr, true)
11918 msg := p.TestProto()
11919 if !p.Equal(msg) {
11920 t.Fatalf("%#v !Face Equal %#v", msg, p)
11921 }
11922 }
11923 func TestNidRepNonByteCustomTypeFace(t *testing.T) {
11924 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11925 p := NewPopulatedNidRepNonByteCustomType(popr, true)
11926 msg := p.TestProto()
11927 if !p.Equal(msg) {
11928 t.Fatalf("%#v !Face Equal %#v", msg, p)
11929 }
11930 }
11931 func TestNinRepNonByteCustomTypeFace(t *testing.T) {
11932 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11933 p := NewPopulatedNinRepNonByteCustomType(popr, true)
11934 msg := p.TestProto()
11935 if !p.Equal(msg) {
11936 t.Fatalf("%#v !Face Equal %#v", msg, p)
11937 }
11938 }
11939 func TestProtoTypeFace(t *testing.T) {
11940 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11941 p := NewPopulatedProtoType(popr, true)
11942 msg := p.TestProto()
11943 if !p.Equal(msg) {
11944 t.Fatalf("%#v !Face Equal %#v", msg, p)
11945 }
11946 }
11947 func TestNidOptNativeGoString(t *testing.T) {
11948 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11949 p := NewPopulatedNidOptNative(popr, false)
11950 s1 := p.GoString()
11951 s2 := fmt.Sprintf("%#v", p)
11952 if s1 != s2 {
11953 t.Fatalf("GoString want %v got %v", s1, s2)
11954 }
11955 _, err := go_parser.ParseExpr(s1)
11956 if err != nil {
11957 t.Fatal(err)
11958 }
11959 }
11960 func TestNinOptNativeGoString(t *testing.T) {
11961 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11962 p := NewPopulatedNinOptNative(popr, false)
11963 s1 := p.GoString()
11964 s2 := fmt.Sprintf("%#v", p)
11965 if s1 != s2 {
11966 t.Fatalf("GoString want %v got %v", s1, s2)
11967 }
11968 _, err := go_parser.ParseExpr(s1)
11969 if err != nil {
11970 t.Fatal(err)
11971 }
11972 }
11973 func TestNidRepNativeGoString(t *testing.T) {
11974 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11975 p := NewPopulatedNidRepNative(popr, false)
11976 s1 := p.GoString()
11977 s2 := fmt.Sprintf("%#v", p)
11978 if s1 != s2 {
11979 t.Fatalf("GoString want %v got %v", s1, s2)
11980 }
11981 _, err := go_parser.ParseExpr(s1)
11982 if err != nil {
11983 t.Fatal(err)
11984 }
11985 }
11986 func TestNinRepNativeGoString(t *testing.T) {
11987 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
11988 p := NewPopulatedNinRepNative(popr, false)
11989 s1 := p.GoString()
11990 s2 := fmt.Sprintf("%#v", p)
11991 if s1 != s2 {
11992 t.Fatalf("GoString want %v got %v", s1, s2)
11993 }
11994 _, err := go_parser.ParseExpr(s1)
11995 if err != nil {
11996 t.Fatal(err)
11997 }
11998 }
11999 func TestNidRepPackedNativeGoString(t *testing.T) {
12000 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12001 p := NewPopulatedNidRepPackedNative(popr, false)
12002 s1 := p.GoString()
12003 s2 := fmt.Sprintf("%#v", p)
12004 if s1 != s2 {
12005 t.Fatalf("GoString want %v got %v", s1, s2)
12006 }
12007 _, err := go_parser.ParseExpr(s1)
12008 if err != nil {
12009 t.Fatal(err)
12010 }
12011 }
12012 func TestNinRepPackedNativeGoString(t *testing.T) {
12013 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12014 p := NewPopulatedNinRepPackedNative(popr, false)
12015 s1 := p.GoString()
12016 s2 := fmt.Sprintf("%#v", p)
12017 if s1 != s2 {
12018 t.Fatalf("GoString want %v got %v", s1, s2)
12019 }
12020 _, err := go_parser.ParseExpr(s1)
12021 if err != nil {
12022 t.Fatal(err)
12023 }
12024 }
12025 func TestNidOptStructGoString(t *testing.T) {
12026 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12027 p := NewPopulatedNidOptStruct(popr, false)
12028 s1 := p.GoString()
12029 s2 := fmt.Sprintf("%#v", p)
12030 if s1 != s2 {
12031 t.Fatalf("GoString want %v got %v", s1, s2)
12032 }
12033 _, err := go_parser.ParseExpr(s1)
12034 if err != nil {
12035 t.Fatal(err)
12036 }
12037 }
12038 func TestNinOptStructGoString(t *testing.T) {
12039 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12040 p := NewPopulatedNinOptStruct(popr, false)
12041 s1 := p.GoString()
12042 s2 := fmt.Sprintf("%#v", p)
12043 if s1 != s2 {
12044 t.Fatalf("GoString want %v got %v", s1, s2)
12045 }
12046 _, err := go_parser.ParseExpr(s1)
12047 if err != nil {
12048 t.Fatal(err)
12049 }
12050 }
12051 func TestNidRepStructGoString(t *testing.T) {
12052 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12053 p := NewPopulatedNidRepStruct(popr, false)
12054 s1 := p.GoString()
12055 s2 := fmt.Sprintf("%#v", p)
12056 if s1 != s2 {
12057 t.Fatalf("GoString want %v got %v", s1, s2)
12058 }
12059 _, err := go_parser.ParseExpr(s1)
12060 if err != nil {
12061 t.Fatal(err)
12062 }
12063 }
12064 func TestNinRepStructGoString(t *testing.T) {
12065 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12066 p := NewPopulatedNinRepStruct(popr, false)
12067 s1 := p.GoString()
12068 s2 := fmt.Sprintf("%#v", p)
12069 if s1 != s2 {
12070 t.Fatalf("GoString want %v got %v", s1, s2)
12071 }
12072 _, err := go_parser.ParseExpr(s1)
12073 if err != nil {
12074 t.Fatal(err)
12075 }
12076 }
12077 func TestNidEmbeddedStructGoString(t *testing.T) {
12078 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12079 p := NewPopulatedNidEmbeddedStruct(popr, false)
12080 s1 := p.GoString()
12081 s2 := fmt.Sprintf("%#v", p)
12082 if s1 != s2 {
12083 t.Fatalf("GoString want %v got %v", s1, s2)
12084 }
12085 _, err := go_parser.ParseExpr(s1)
12086 if err != nil {
12087 t.Fatal(err)
12088 }
12089 }
12090 func TestNinEmbeddedStructGoString(t *testing.T) {
12091 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12092 p := NewPopulatedNinEmbeddedStruct(popr, false)
12093 s1 := p.GoString()
12094 s2 := fmt.Sprintf("%#v", p)
12095 if s1 != s2 {
12096 t.Fatalf("GoString want %v got %v", s1, s2)
12097 }
12098 _, err := go_parser.ParseExpr(s1)
12099 if err != nil {
12100 t.Fatal(err)
12101 }
12102 }
12103 func TestNidNestedStructGoString(t *testing.T) {
12104 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12105 p := NewPopulatedNidNestedStruct(popr, false)
12106 s1 := p.GoString()
12107 s2 := fmt.Sprintf("%#v", p)
12108 if s1 != s2 {
12109 t.Fatalf("GoString want %v got %v", s1, s2)
12110 }
12111 _, err := go_parser.ParseExpr(s1)
12112 if err != nil {
12113 t.Fatal(err)
12114 }
12115 }
12116 func TestNinNestedStructGoString(t *testing.T) {
12117 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12118 p := NewPopulatedNinNestedStruct(popr, false)
12119 s1 := p.GoString()
12120 s2 := fmt.Sprintf("%#v", p)
12121 if s1 != s2 {
12122 t.Fatalf("GoString want %v got %v", s1, s2)
12123 }
12124 _, err := go_parser.ParseExpr(s1)
12125 if err != nil {
12126 t.Fatal(err)
12127 }
12128 }
12129 func TestNidOptCustomGoString(t *testing.T) {
12130 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12131 p := NewPopulatedNidOptCustom(popr, false)
12132 s1 := p.GoString()
12133 s2 := fmt.Sprintf("%#v", p)
12134 if s1 != s2 {
12135 t.Fatalf("GoString want %v got %v", s1, s2)
12136 }
12137 _, err := go_parser.ParseExpr(s1)
12138 if err != nil {
12139 t.Fatal(err)
12140 }
12141 }
12142 func TestCustomDashGoString(t *testing.T) {
12143 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12144 p := NewPopulatedCustomDash(popr, false)
12145 s1 := p.GoString()
12146 s2 := fmt.Sprintf("%#v", p)
12147 if s1 != s2 {
12148 t.Fatalf("GoString want %v got %v", s1, s2)
12149 }
12150 _, err := go_parser.ParseExpr(s1)
12151 if err != nil {
12152 t.Fatal(err)
12153 }
12154 }
12155 func TestNinOptCustomGoString(t *testing.T) {
12156 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12157 p := NewPopulatedNinOptCustom(popr, false)
12158 s1 := p.GoString()
12159 s2 := fmt.Sprintf("%#v", p)
12160 if s1 != s2 {
12161 t.Fatalf("GoString want %v got %v", s1, s2)
12162 }
12163 _, err := go_parser.ParseExpr(s1)
12164 if err != nil {
12165 t.Fatal(err)
12166 }
12167 }
12168 func TestNidRepCustomGoString(t *testing.T) {
12169 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12170 p := NewPopulatedNidRepCustom(popr, false)
12171 s1 := p.GoString()
12172 s2 := fmt.Sprintf("%#v", p)
12173 if s1 != s2 {
12174 t.Fatalf("GoString want %v got %v", s1, s2)
12175 }
12176 _, err := go_parser.ParseExpr(s1)
12177 if err != nil {
12178 t.Fatal(err)
12179 }
12180 }
12181 func TestNinRepCustomGoString(t *testing.T) {
12182 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12183 p := NewPopulatedNinRepCustom(popr, false)
12184 s1 := p.GoString()
12185 s2 := fmt.Sprintf("%#v", p)
12186 if s1 != s2 {
12187 t.Fatalf("GoString want %v got %v", s1, s2)
12188 }
12189 _, err := go_parser.ParseExpr(s1)
12190 if err != nil {
12191 t.Fatal(err)
12192 }
12193 }
12194 func TestNinOptNativeUnionGoString(t *testing.T) {
12195 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12196 p := NewPopulatedNinOptNativeUnion(popr, false)
12197 s1 := p.GoString()
12198 s2 := fmt.Sprintf("%#v", p)
12199 if s1 != s2 {
12200 t.Fatalf("GoString want %v got %v", s1, s2)
12201 }
12202 _, err := go_parser.ParseExpr(s1)
12203 if err != nil {
12204 t.Fatal(err)
12205 }
12206 }
12207 func TestNinOptStructUnionGoString(t *testing.T) {
12208 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12209 p := NewPopulatedNinOptStructUnion(popr, false)
12210 s1 := p.GoString()
12211 s2 := fmt.Sprintf("%#v", p)
12212 if s1 != s2 {
12213 t.Fatalf("GoString want %v got %v", s1, s2)
12214 }
12215 _, err := go_parser.ParseExpr(s1)
12216 if err != nil {
12217 t.Fatal(err)
12218 }
12219 }
12220 func TestNinEmbeddedStructUnionGoString(t *testing.T) {
12221 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12222 p := NewPopulatedNinEmbeddedStructUnion(popr, false)
12223 s1 := p.GoString()
12224 s2 := fmt.Sprintf("%#v", p)
12225 if s1 != s2 {
12226 t.Fatalf("GoString want %v got %v", s1, s2)
12227 }
12228 _, err := go_parser.ParseExpr(s1)
12229 if err != nil {
12230 t.Fatal(err)
12231 }
12232 }
12233 func TestNinNestedStructUnionGoString(t *testing.T) {
12234 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12235 p := NewPopulatedNinNestedStructUnion(popr, false)
12236 s1 := p.GoString()
12237 s2 := fmt.Sprintf("%#v", p)
12238 if s1 != s2 {
12239 t.Fatalf("GoString want %v got %v", s1, s2)
12240 }
12241 _, err := go_parser.ParseExpr(s1)
12242 if err != nil {
12243 t.Fatal(err)
12244 }
12245 }
12246 func TestTreeGoString(t *testing.T) {
12247 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12248 p := NewPopulatedTree(popr, false)
12249 s1 := p.GoString()
12250 s2 := fmt.Sprintf("%#v", p)
12251 if s1 != s2 {
12252 t.Fatalf("GoString want %v got %v", s1, s2)
12253 }
12254 _, err := go_parser.ParseExpr(s1)
12255 if err != nil {
12256 t.Fatal(err)
12257 }
12258 }
12259 func TestOrBranchGoString(t *testing.T) {
12260 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12261 p := NewPopulatedOrBranch(popr, false)
12262 s1 := p.GoString()
12263 s2 := fmt.Sprintf("%#v", p)
12264 if s1 != s2 {
12265 t.Fatalf("GoString want %v got %v", s1, s2)
12266 }
12267 _, err := go_parser.ParseExpr(s1)
12268 if err != nil {
12269 t.Fatal(err)
12270 }
12271 }
12272 func TestAndBranchGoString(t *testing.T) {
12273 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12274 p := NewPopulatedAndBranch(popr, false)
12275 s1 := p.GoString()
12276 s2 := fmt.Sprintf("%#v", p)
12277 if s1 != s2 {
12278 t.Fatalf("GoString want %v got %v", s1, s2)
12279 }
12280 _, err := go_parser.ParseExpr(s1)
12281 if err != nil {
12282 t.Fatal(err)
12283 }
12284 }
12285 func TestLeafGoString(t *testing.T) {
12286 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12287 p := NewPopulatedLeaf(popr, false)
12288 s1 := p.GoString()
12289 s2 := fmt.Sprintf("%#v", p)
12290 if s1 != s2 {
12291 t.Fatalf("GoString want %v got %v", s1, s2)
12292 }
12293 _, err := go_parser.ParseExpr(s1)
12294 if err != nil {
12295 t.Fatal(err)
12296 }
12297 }
12298 func TestDeepTreeGoString(t *testing.T) {
12299 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12300 p := NewPopulatedDeepTree(popr, false)
12301 s1 := p.GoString()
12302 s2 := fmt.Sprintf("%#v", p)
12303 if s1 != s2 {
12304 t.Fatalf("GoString want %v got %v", s1, s2)
12305 }
12306 _, err := go_parser.ParseExpr(s1)
12307 if err != nil {
12308 t.Fatal(err)
12309 }
12310 }
12311 func TestADeepBranchGoString(t *testing.T) {
12312 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12313 p := NewPopulatedADeepBranch(popr, false)
12314 s1 := p.GoString()
12315 s2 := fmt.Sprintf("%#v", p)
12316 if s1 != s2 {
12317 t.Fatalf("GoString want %v got %v", s1, s2)
12318 }
12319 _, err := go_parser.ParseExpr(s1)
12320 if err != nil {
12321 t.Fatal(err)
12322 }
12323 }
12324 func TestAndDeepBranchGoString(t *testing.T) {
12325 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12326 p := NewPopulatedAndDeepBranch(popr, false)
12327 s1 := p.GoString()
12328 s2 := fmt.Sprintf("%#v", p)
12329 if s1 != s2 {
12330 t.Fatalf("GoString want %v got %v", s1, s2)
12331 }
12332 _, err := go_parser.ParseExpr(s1)
12333 if err != nil {
12334 t.Fatal(err)
12335 }
12336 }
12337 func TestDeepLeafGoString(t *testing.T) {
12338 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12339 p := NewPopulatedDeepLeaf(popr, false)
12340 s1 := p.GoString()
12341 s2 := fmt.Sprintf("%#v", p)
12342 if s1 != s2 {
12343 t.Fatalf("GoString want %v got %v", s1, s2)
12344 }
12345 _, err := go_parser.ParseExpr(s1)
12346 if err != nil {
12347 t.Fatal(err)
12348 }
12349 }
12350 func TestNilGoString(t *testing.T) {
12351 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12352 p := NewPopulatedNil(popr, false)
12353 s1 := p.GoString()
12354 s2 := fmt.Sprintf("%#v", p)
12355 if s1 != s2 {
12356 t.Fatalf("GoString want %v got %v", s1, s2)
12357 }
12358 _, err := go_parser.ParseExpr(s1)
12359 if err != nil {
12360 t.Fatal(err)
12361 }
12362 }
12363 func TestNidOptEnumGoString(t *testing.T) {
12364 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12365 p := NewPopulatedNidOptEnum(popr, false)
12366 s1 := p.GoString()
12367 s2 := fmt.Sprintf("%#v", p)
12368 if s1 != s2 {
12369 t.Fatalf("GoString want %v got %v", s1, s2)
12370 }
12371 _, err := go_parser.ParseExpr(s1)
12372 if err != nil {
12373 t.Fatal(err)
12374 }
12375 }
12376 func TestNinOptEnumGoString(t *testing.T) {
12377 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12378 p := NewPopulatedNinOptEnum(popr, false)
12379 s1 := p.GoString()
12380 s2 := fmt.Sprintf("%#v", p)
12381 if s1 != s2 {
12382 t.Fatalf("GoString want %v got %v", s1, s2)
12383 }
12384 _, err := go_parser.ParseExpr(s1)
12385 if err != nil {
12386 t.Fatal(err)
12387 }
12388 }
12389 func TestNidRepEnumGoString(t *testing.T) {
12390 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12391 p := NewPopulatedNidRepEnum(popr, false)
12392 s1 := p.GoString()
12393 s2 := fmt.Sprintf("%#v", p)
12394 if s1 != s2 {
12395 t.Fatalf("GoString want %v got %v", s1, s2)
12396 }
12397 _, err := go_parser.ParseExpr(s1)
12398 if err != nil {
12399 t.Fatal(err)
12400 }
12401 }
12402 func TestNinRepEnumGoString(t *testing.T) {
12403 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12404 p := NewPopulatedNinRepEnum(popr, false)
12405 s1 := p.GoString()
12406 s2 := fmt.Sprintf("%#v", p)
12407 if s1 != s2 {
12408 t.Fatalf("GoString want %v got %v", s1, s2)
12409 }
12410 _, err := go_parser.ParseExpr(s1)
12411 if err != nil {
12412 t.Fatal(err)
12413 }
12414 }
12415 func TestNinOptEnumDefaultGoString(t *testing.T) {
12416 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12417 p := NewPopulatedNinOptEnumDefault(popr, false)
12418 s1 := p.GoString()
12419 s2 := fmt.Sprintf("%#v", p)
12420 if s1 != s2 {
12421 t.Fatalf("GoString want %v got %v", s1, s2)
12422 }
12423 _, err := go_parser.ParseExpr(s1)
12424 if err != nil {
12425 t.Fatal(err)
12426 }
12427 }
12428 func TestAnotherNinOptEnumGoString(t *testing.T) {
12429 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12430 p := NewPopulatedAnotherNinOptEnum(popr, false)
12431 s1 := p.GoString()
12432 s2 := fmt.Sprintf("%#v", p)
12433 if s1 != s2 {
12434 t.Fatalf("GoString want %v got %v", s1, s2)
12435 }
12436 _, err := go_parser.ParseExpr(s1)
12437 if err != nil {
12438 t.Fatal(err)
12439 }
12440 }
12441 func TestAnotherNinOptEnumDefaultGoString(t *testing.T) {
12442 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12443 p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
12444 s1 := p.GoString()
12445 s2 := fmt.Sprintf("%#v", p)
12446 if s1 != s2 {
12447 t.Fatalf("GoString want %v got %v", s1, s2)
12448 }
12449 _, err := go_parser.ParseExpr(s1)
12450 if err != nil {
12451 t.Fatal(err)
12452 }
12453 }
12454 func TestTimerGoString(t *testing.T) {
12455 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12456 p := NewPopulatedTimer(popr, false)
12457 s1 := p.GoString()
12458 s2 := fmt.Sprintf("%#v", p)
12459 if s1 != s2 {
12460 t.Fatalf("GoString want %v got %v", s1, s2)
12461 }
12462 _, err := go_parser.ParseExpr(s1)
12463 if err != nil {
12464 t.Fatal(err)
12465 }
12466 }
12467 func TestMyExtendableGoString(t *testing.T) {
12468 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12469 p := NewPopulatedMyExtendable(popr, false)
12470 s1 := p.GoString()
12471 s2 := fmt.Sprintf("%#v", p)
12472 if s1 != s2 {
12473 t.Fatalf("GoString want %v got %v", s1, s2)
12474 }
12475 _, err := go_parser.ParseExpr(s1)
12476 if err != nil {
12477 t.Fatal(err)
12478 }
12479 }
12480 func TestOtherExtenableGoString(t *testing.T) {
12481 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12482 p := NewPopulatedOtherExtenable(popr, false)
12483 s1 := p.GoString()
12484 s2 := fmt.Sprintf("%#v", p)
12485 if s1 != s2 {
12486 t.Fatalf("GoString want %v got %v", s1, s2)
12487 }
12488 _, err := go_parser.ParseExpr(s1)
12489 if err != nil {
12490 t.Fatal(err)
12491 }
12492 }
12493 func TestNestedDefinitionGoString(t *testing.T) {
12494 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12495 p := NewPopulatedNestedDefinition(popr, false)
12496 s1 := p.GoString()
12497 s2 := fmt.Sprintf("%#v", p)
12498 if s1 != s2 {
12499 t.Fatalf("GoString want %v got %v", s1, s2)
12500 }
12501 _, err := go_parser.ParseExpr(s1)
12502 if err != nil {
12503 t.Fatal(err)
12504 }
12505 }
12506 func TestNestedDefinition_NestedMessageGoString(t *testing.T) {
12507 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12508 p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
12509 s1 := p.GoString()
12510 s2 := fmt.Sprintf("%#v", p)
12511 if s1 != s2 {
12512 t.Fatalf("GoString want %v got %v", s1, s2)
12513 }
12514 _, err := go_parser.ParseExpr(s1)
12515 if err != nil {
12516 t.Fatal(err)
12517 }
12518 }
12519 func TestNestedDefinition_NestedMessage_NestedNestedMsgGoString(t *testing.T) {
12520 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12521 p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
12522 s1 := p.GoString()
12523 s2 := fmt.Sprintf("%#v", p)
12524 if s1 != s2 {
12525 t.Fatalf("GoString want %v got %v", s1, s2)
12526 }
12527 _, err := go_parser.ParseExpr(s1)
12528 if err != nil {
12529 t.Fatal(err)
12530 }
12531 }
12532 func TestNestedScopeGoString(t *testing.T) {
12533 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12534 p := NewPopulatedNestedScope(popr, false)
12535 s1 := p.GoString()
12536 s2 := fmt.Sprintf("%#v", p)
12537 if s1 != s2 {
12538 t.Fatalf("GoString want %v got %v", s1, s2)
12539 }
12540 _, err := go_parser.ParseExpr(s1)
12541 if err != nil {
12542 t.Fatal(err)
12543 }
12544 }
12545 func TestNinOptNativeDefaultGoString(t *testing.T) {
12546 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12547 p := NewPopulatedNinOptNativeDefault(popr, false)
12548 s1 := p.GoString()
12549 s2 := fmt.Sprintf("%#v", p)
12550 if s1 != s2 {
12551 t.Fatalf("GoString want %v got %v", s1, s2)
12552 }
12553 _, err := go_parser.ParseExpr(s1)
12554 if err != nil {
12555 t.Fatal(err)
12556 }
12557 }
12558 func TestCustomContainerGoString(t *testing.T) {
12559 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12560 p := NewPopulatedCustomContainer(popr, false)
12561 s1 := p.GoString()
12562 s2 := fmt.Sprintf("%#v", p)
12563 if s1 != s2 {
12564 t.Fatalf("GoString want %v got %v", s1, s2)
12565 }
12566 _, err := go_parser.ParseExpr(s1)
12567 if err != nil {
12568 t.Fatal(err)
12569 }
12570 }
12571 func TestCustomNameNidOptNativeGoString(t *testing.T) {
12572 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12573 p := NewPopulatedCustomNameNidOptNative(popr, false)
12574 s1 := p.GoString()
12575 s2 := fmt.Sprintf("%#v", p)
12576 if s1 != s2 {
12577 t.Fatalf("GoString want %v got %v", s1, s2)
12578 }
12579 _, err := go_parser.ParseExpr(s1)
12580 if err != nil {
12581 t.Fatal(err)
12582 }
12583 }
12584 func TestCustomNameNinOptNativeGoString(t *testing.T) {
12585 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12586 p := NewPopulatedCustomNameNinOptNative(popr, false)
12587 s1 := p.GoString()
12588 s2 := fmt.Sprintf("%#v", p)
12589 if s1 != s2 {
12590 t.Fatalf("GoString want %v got %v", s1, s2)
12591 }
12592 _, err := go_parser.ParseExpr(s1)
12593 if err != nil {
12594 t.Fatal(err)
12595 }
12596 }
12597 func TestCustomNameNinRepNativeGoString(t *testing.T) {
12598 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12599 p := NewPopulatedCustomNameNinRepNative(popr, false)
12600 s1 := p.GoString()
12601 s2 := fmt.Sprintf("%#v", p)
12602 if s1 != s2 {
12603 t.Fatalf("GoString want %v got %v", s1, s2)
12604 }
12605 _, err := go_parser.ParseExpr(s1)
12606 if err != nil {
12607 t.Fatal(err)
12608 }
12609 }
12610 func TestCustomNameNinStructGoString(t *testing.T) {
12611 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12612 p := NewPopulatedCustomNameNinStruct(popr, false)
12613 s1 := p.GoString()
12614 s2 := fmt.Sprintf("%#v", p)
12615 if s1 != s2 {
12616 t.Fatalf("GoString want %v got %v", s1, s2)
12617 }
12618 _, err := go_parser.ParseExpr(s1)
12619 if err != nil {
12620 t.Fatal(err)
12621 }
12622 }
12623 func TestCustomNameCustomTypeGoString(t *testing.T) {
12624 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12625 p := NewPopulatedCustomNameCustomType(popr, false)
12626 s1 := p.GoString()
12627 s2 := fmt.Sprintf("%#v", p)
12628 if s1 != s2 {
12629 t.Fatalf("GoString want %v got %v", s1, s2)
12630 }
12631 _, err := go_parser.ParseExpr(s1)
12632 if err != nil {
12633 t.Fatal(err)
12634 }
12635 }
12636 func TestCustomNameNinEmbeddedStructUnionGoString(t *testing.T) {
12637 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12638 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
12639 s1 := p.GoString()
12640 s2 := fmt.Sprintf("%#v", p)
12641 if s1 != s2 {
12642 t.Fatalf("GoString want %v got %v", s1, s2)
12643 }
12644 _, err := go_parser.ParseExpr(s1)
12645 if err != nil {
12646 t.Fatal(err)
12647 }
12648 }
12649 func TestCustomNameEnumGoString(t *testing.T) {
12650 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12651 p := NewPopulatedCustomNameEnum(popr, false)
12652 s1 := p.GoString()
12653 s2 := fmt.Sprintf("%#v", p)
12654 if s1 != s2 {
12655 t.Fatalf("GoString want %v got %v", s1, s2)
12656 }
12657 _, err := go_parser.ParseExpr(s1)
12658 if err != nil {
12659 t.Fatal(err)
12660 }
12661 }
12662 func TestNoExtensionsMapGoString(t *testing.T) {
12663 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12664 p := NewPopulatedNoExtensionsMap(popr, false)
12665 s1 := p.GoString()
12666 s2 := fmt.Sprintf("%#v", p)
12667 if s1 != s2 {
12668 t.Fatalf("GoString want %v got %v", s1, s2)
12669 }
12670 _, err := go_parser.ParseExpr(s1)
12671 if err != nil {
12672 t.Fatal(err)
12673 }
12674 }
12675 func TestUnrecognizedGoString(t *testing.T) {
12676 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12677 p := NewPopulatedUnrecognized(popr, false)
12678 s1 := p.GoString()
12679 s2 := fmt.Sprintf("%#v", p)
12680 if s1 != s2 {
12681 t.Fatalf("GoString want %v got %v", s1, s2)
12682 }
12683 _, err := go_parser.ParseExpr(s1)
12684 if err != nil {
12685 t.Fatal(err)
12686 }
12687 }
12688 func TestUnrecognizedWithInnerGoString(t *testing.T) {
12689 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12690 p := NewPopulatedUnrecognizedWithInner(popr, false)
12691 s1 := p.GoString()
12692 s2 := fmt.Sprintf("%#v", p)
12693 if s1 != s2 {
12694 t.Fatalf("GoString want %v got %v", s1, s2)
12695 }
12696 _, err := go_parser.ParseExpr(s1)
12697 if err != nil {
12698 t.Fatal(err)
12699 }
12700 }
12701 func TestUnrecognizedWithInner_InnerGoString(t *testing.T) {
12702 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12703 p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
12704 s1 := p.GoString()
12705 s2 := fmt.Sprintf("%#v", p)
12706 if s1 != s2 {
12707 t.Fatalf("GoString want %v got %v", s1, s2)
12708 }
12709 _, err := go_parser.ParseExpr(s1)
12710 if err != nil {
12711 t.Fatal(err)
12712 }
12713 }
12714 func TestUnrecognizedWithEmbedGoString(t *testing.T) {
12715 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12716 p := NewPopulatedUnrecognizedWithEmbed(popr, false)
12717 s1 := p.GoString()
12718 s2 := fmt.Sprintf("%#v", p)
12719 if s1 != s2 {
12720 t.Fatalf("GoString want %v got %v", s1, s2)
12721 }
12722 _, err := go_parser.ParseExpr(s1)
12723 if err != nil {
12724 t.Fatal(err)
12725 }
12726 }
12727 func TestUnrecognizedWithEmbed_EmbeddedGoString(t *testing.T) {
12728 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12729 p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
12730 s1 := p.GoString()
12731 s2 := fmt.Sprintf("%#v", p)
12732 if s1 != s2 {
12733 t.Fatalf("GoString want %v got %v", s1, s2)
12734 }
12735 _, err := go_parser.ParseExpr(s1)
12736 if err != nil {
12737 t.Fatal(err)
12738 }
12739 }
12740 func TestNodeGoString(t *testing.T) {
12741 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12742 p := NewPopulatedNode(popr, false)
12743 s1 := p.GoString()
12744 s2 := fmt.Sprintf("%#v", p)
12745 if s1 != s2 {
12746 t.Fatalf("GoString want %v got %v", s1, s2)
12747 }
12748 _, err := go_parser.ParseExpr(s1)
12749 if err != nil {
12750 t.Fatal(err)
12751 }
12752 }
12753 func TestNonByteCustomTypeGoString(t *testing.T) {
12754 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12755 p := NewPopulatedNonByteCustomType(popr, false)
12756 s1 := p.GoString()
12757 s2 := fmt.Sprintf("%#v", p)
12758 if s1 != s2 {
12759 t.Fatalf("GoString want %v got %v", s1, s2)
12760 }
12761 _, err := go_parser.ParseExpr(s1)
12762 if err != nil {
12763 t.Fatal(err)
12764 }
12765 }
12766 func TestNidOptNonByteCustomTypeGoString(t *testing.T) {
12767 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12768 p := NewPopulatedNidOptNonByteCustomType(popr, false)
12769 s1 := p.GoString()
12770 s2 := fmt.Sprintf("%#v", p)
12771 if s1 != s2 {
12772 t.Fatalf("GoString want %v got %v", s1, s2)
12773 }
12774 _, err := go_parser.ParseExpr(s1)
12775 if err != nil {
12776 t.Fatal(err)
12777 }
12778 }
12779 func TestNinOptNonByteCustomTypeGoString(t *testing.T) {
12780 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12781 p := NewPopulatedNinOptNonByteCustomType(popr, false)
12782 s1 := p.GoString()
12783 s2 := fmt.Sprintf("%#v", p)
12784 if s1 != s2 {
12785 t.Fatalf("GoString want %v got %v", s1, s2)
12786 }
12787 _, err := go_parser.ParseExpr(s1)
12788 if err != nil {
12789 t.Fatal(err)
12790 }
12791 }
12792 func TestNidRepNonByteCustomTypeGoString(t *testing.T) {
12793 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12794 p := NewPopulatedNidRepNonByteCustomType(popr, false)
12795 s1 := p.GoString()
12796 s2 := fmt.Sprintf("%#v", p)
12797 if s1 != s2 {
12798 t.Fatalf("GoString want %v got %v", s1, s2)
12799 }
12800 _, err := go_parser.ParseExpr(s1)
12801 if err != nil {
12802 t.Fatal(err)
12803 }
12804 }
12805 func TestNinRepNonByteCustomTypeGoString(t *testing.T) {
12806 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12807 p := NewPopulatedNinRepNonByteCustomType(popr, false)
12808 s1 := p.GoString()
12809 s2 := fmt.Sprintf("%#v", p)
12810 if s1 != s2 {
12811 t.Fatalf("GoString want %v got %v", s1, s2)
12812 }
12813 _, err := go_parser.ParseExpr(s1)
12814 if err != nil {
12815 t.Fatal(err)
12816 }
12817 }
12818 func TestProtoTypeGoString(t *testing.T) {
12819 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
12820 p := NewPopulatedProtoType(popr, false)
12821 s1 := p.GoString()
12822 s2 := fmt.Sprintf("%#v", p)
12823 if s1 != s2 {
12824 t.Fatalf("GoString want %v got %v", s1, s2)
12825 }
12826 _, err := go_parser.ParseExpr(s1)
12827 if err != nil {
12828 t.Fatal(err)
12829 }
12830 }
12831 func TestNidOptNativeSize(t *testing.T) {
12832 seed := time.Now().UnixNano()
12833 popr := math_rand.New(math_rand.NewSource(seed))
12834 p := NewPopulatedNidOptNative(popr, true)
12835 size2 := github_com_gogo_protobuf_proto.Size(p)
12836 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
12837 if err != nil {
12838 t.Fatalf("seed = %d, err = %v", seed, err)
12839 }
12840 size := p.Size()
12841 if len(dAtA) != size {
12842 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
12843 }
12844 if size2 != size {
12845 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
12846 }
12847 size3 := github_com_gogo_protobuf_proto.Size(p)
12848 if size3 != size {
12849 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
12850 }
12851 }
12852
12853 func BenchmarkNidOptNativeSize(b *testing.B) {
12854 popr := math_rand.New(math_rand.NewSource(616))
12855 total := 0
12856 pops := make([]*NidOptNative, 1000)
12857 for i := 0; i < 1000; i++ {
12858 pops[i] = NewPopulatedNidOptNative(popr, false)
12859 }
12860 b.ResetTimer()
12861 for i := 0; i < b.N; i++ {
12862 total += pops[i%1000].Size()
12863 }
12864 b.SetBytes(int64(total / b.N))
12865 }
12866
12867 func TestNinOptNativeSize(t *testing.T) {
12868 seed := time.Now().UnixNano()
12869 popr := math_rand.New(math_rand.NewSource(seed))
12870 p := NewPopulatedNinOptNative(popr, true)
12871 size2 := github_com_gogo_protobuf_proto.Size(p)
12872 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
12873 if err != nil {
12874 t.Fatalf("seed = %d, err = %v", seed, err)
12875 }
12876 size := p.Size()
12877 if len(dAtA) != size {
12878 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
12879 }
12880 if size2 != size {
12881 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
12882 }
12883 size3 := github_com_gogo_protobuf_proto.Size(p)
12884 if size3 != size {
12885 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
12886 }
12887 }
12888
12889 func BenchmarkNinOptNativeSize(b *testing.B) {
12890 popr := math_rand.New(math_rand.NewSource(616))
12891 total := 0
12892 pops := make([]*NinOptNative, 1000)
12893 for i := 0; i < 1000; i++ {
12894 pops[i] = NewPopulatedNinOptNative(popr, false)
12895 }
12896 b.ResetTimer()
12897 for i := 0; i < b.N; i++ {
12898 total += pops[i%1000].Size()
12899 }
12900 b.SetBytes(int64(total / b.N))
12901 }
12902
12903 func TestNidRepNativeSize(t *testing.T) {
12904 seed := time.Now().UnixNano()
12905 popr := math_rand.New(math_rand.NewSource(seed))
12906 p := NewPopulatedNidRepNative(popr, true)
12907 size2 := github_com_gogo_protobuf_proto.Size(p)
12908 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
12909 if err != nil {
12910 t.Fatalf("seed = %d, err = %v", seed, err)
12911 }
12912 size := p.Size()
12913 if len(dAtA) != size {
12914 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
12915 }
12916 if size2 != size {
12917 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
12918 }
12919 size3 := github_com_gogo_protobuf_proto.Size(p)
12920 if size3 != size {
12921 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
12922 }
12923 }
12924
12925 func BenchmarkNidRepNativeSize(b *testing.B) {
12926 popr := math_rand.New(math_rand.NewSource(616))
12927 total := 0
12928 pops := make([]*NidRepNative, 1000)
12929 for i := 0; i < 1000; i++ {
12930 pops[i] = NewPopulatedNidRepNative(popr, false)
12931 }
12932 b.ResetTimer()
12933 for i := 0; i < b.N; i++ {
12934 total += pops[i%1000].Size()
12935 }
12936 b.SetBytes(int64(total / b.N))
12937 }
12938
12939 func TestNinRepNativeSize(t *testing.T) {
12940 seed := time.Now().UnixNano()
12941 popr := math_rand.New(math_rand.NewSource(seed))
12942 p := NewPopulatedNinRepNative(popr, true)
12943 size2 := github_com_gogo_protobuf_proto.Size(p)
12944 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
12945 if err != nil {
12946 t.Fatalf("seed = %d, err = %v", seed, err)
12947 }
12948 size := p.Size()
12949 if len(dAtA) != size {
12950 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
12951 }
12952 if size2 != size {
12953 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
12954 }
12955 size3 := github_com_gogo_protobuf_proto.Size(p)
12956 if size3 != size {
12957 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
12958 }
12959 }
12960
12961 func BenchmarkNinRepNativeSize(b *testing.B) {
12962 popr := math_rand.New(math_rand.NewSource(616))
12963 total := 0
12964 pops := make([]*NinRepNative, 1000)
12965 for i := 0; i < 1000; i++ {
12966 pops[i] = NewPopulatedNinRepNative(popr, false)
12967 }
12968 b.ResetTimer()
12969 for i := 0; i < b.N; i++ {
12970 total += pops[i%1000].Size()
12971 }
12972 b.SetBytes(int64(total / b.N))
12973 }
12974
12975 func TestNidRepPackedNativeSize(t *testing.T) {
12976 seed := time.Now().UnixNano()
12977 popr := math_rand.New(math_rand.NewSource(seed))
12978 p := NewPopulatedNidRepPackedNative(popr, true)
12979 size2 := github_com_gogo_protobuf_proto.Size(p)
12980 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
12981 if err != nil {
12982 t.Fatalf("seed = %d, err = %v", seed, err)
12983 }
12984 size := p.Size()
12985 if len(dAtA) != size {
12986 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
12987 }
12988 if size2 != size {
12989 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
12990 }
12991 size3 := github_com_gogo_protobuf_proto.Size(p)
12992 if size3 != size {
12993 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
12994 }
12995 }
12996
12997 func BenchmarkNidRepPackedNativeSize(b *testing.B) {
12998 popr := math_rand.New(math_rand.NewSource(616))
12999 total := 0
13000 pops := make([]*NidRepPackedNative, 1000)
13001 for i := 0; i < 1000; i++ {
13002 pops[i] = NewPopulatedNidRepPackedNative(popr, false)
13003 }
13004 b.ResetTimer()
13005 for i := 0; i < b.N; i++ {
13006 total += pops[i%1000].Size()
13007 }
13008 b.SetBytes(int64(total / b.N))
13009 }
13010
13011 func TestNinRepPackedNativeSize(t *testing.T) {
13012 seed := time.Now().UnixNano()
13013 popr := math_rand.New(math_rand.NewSource(seed))
13014 p := NewPopulatedNinRepPackedNative(popr, true)
13015 size2 := github_com_gogo_protobuf_proto.Size(p)
13016 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13017 if err != nil {
13018 t.Fatalf("seed = %d, err = %v", seed, err)
13019 }
13020 size := p.Size()
13021 if len(dAtA) != size {
13022 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13023 }
13024 if size2 != size {
13025 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13026 }
13027 size3 := github_com_gogo_protobuf_proto.Size(p)
13028 if size3 != size {
13029 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13030 }
13031 }
13032
13033 func BenchmarkNinRepPackedNativeSize(b *testing.B) {
13034 popr := math_rand.New(math_rand.NewSource(616))
13035 total := 0
13036 pops := make([]*NinRepPackedNative, 1000)
13037 for i := 0; i < 1000; i++ {
13038 pops[i] = NewPopulatedNinRepPackedNative(popr, false)
13039 }
13040 b.ResetTimer()
13041 for i := 0; i < b.N; i++ {
13042 total += pops[i%1000].Size()
13043 }
13044 b.SetBytes(int64(total / b.N))
13045 }
13046
13047 func TestNidOptStructSize(t *testing.T) {
13048 seed := time.Now().UnixNano()
13049 popr := math_rand.New(math_rand.NewSource(seed))
13050 p := NewPopulatedNidOptStruct(popr, true)
13051 size2 := github_com_gogo_protobuf_proto.Size(p)
13052 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13053 if err != nil {
13054 t.Fatalf("seed = %d, err = %v", seed, err)
13055 }
13056 size := p.Size()
13057 if len(dAtA) != size {
13058 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13059 }
13060 if size2 != size {
13061 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13062 }
13063 size3 := github_com_gogo_protobuf_proto.Size(p)
13064 if size3 != size {
13065 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13066 }
13067 }
13068
13069 func BenchmarkNidOptStructSize(b *testing.B) {
13070 popr := math_rand.New(math_rand.NewSource(616))
13071 total := 0
13072 pops := make([]*NidOptStruct, 1000)
13073 for i := 0; i < 1000; i++ {
13074 pops[i] = NewPopulatedNidOptStruct(popr, false)
13075 }
13076 b.ResetTimer()
13077 for i := 0; i < b.N; i++ {
13078 total += pops[i%1000].Size()
13079 }
13080 b.SetBytes(int64(total / b.N))
13081 }
13082
13083 func TestNinOptStructSize(t *testing.T) {
13084 seed := time.Now().UnixNano()
13085 popr := math_rand.New(math_rand.NewSource(seed))
13086 p := NewPopulatedNinOptStruct(popr, true)
13087 size2 := github_com_gogo_protobuf_proto.Size(p)
13088 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13089 if err != nil {
13090 t.Fatalf("seed = %d, err = %v", seed, err)
13091 }
13092 size := p.Size()
13093 if len(dAtA) != size {
13094 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13095 }
13096 if size2 != size {
13097 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13098 }
13099 size3 := github_com_gogo_protobuf_proto.Size(p)
13100 if size3 != size {
13101 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13102 }
13103 }
13104
13105 func BenchmarkNinOptStructSize(b *testing.B) {
13106 popr := math_rand.New(math_rand.NewSource(616))
13107 total := 0
13108 pops := make([]*NinOptStruct, 1000)
13109 for i := 0; i < 1000; i++ {
13110 pops[i] = NewPopulatedNinOptStruct(popr, false)
13111 }
13112 b.ResetTimer()
13113 for i := 0; i < b.N; i++ {
13114 total += pops[i%1000].Size()
13115 }
13116 b.SetBytes(int64(total / b.N))
13117 }
13118
13119 func TestNidRepStructSize(t *testing.T) {
13120 seed := time.Now().UnixNano()
13121 popr := math_rand.New(math_rand.NewSource(seed))
13122 p := NewPopulatedNidRepStruct(popr, true)
13123 size2 := github_com_gogo_protobuf_proto.Size(p)
13124 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13125 if err != nil {
13126 t.Fatalf("seed = %d, err = %v", seed, err)
13127 }
13128 size := p.Size()
13129 if len(dAtA) != size {
13130 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13131 }
13132 if size2 != size {
13133 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13134 }
13135 size3 := github_com_gogo_protobuf_proto.Size(p)
13136 if size3 != size {
13137 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13138 }
13139 }
13140
13141 func BenchmarkNidRepStructSize(b *testing.B) {
13142 popr := math_rand.New(math_rand.NewSource(616))
13143 total := 0
13144 pops := make([]*NidRepStruct, 1000)
13145 for i := 0; i < 1000; i++ {
13146 pops[i] = NewPopulatedNidRepStruct(popr, false)
13147 }
13148 b.ResetTimer()
13149 for i := 0; i < b.N; i++ {
13150 total += pops[i%1000].Size()
13151 }
13152 b.SetBytes(int64(total / b.N))
13153 }
13154
13155 func TestNinRepStructSize(t *testing.T) {
13156 seed := time.Now().UnixNano()
13157 popr := math_rand.New(math_rand.NewSource(seed))
13158 p := NewPopulatedNinRepStruct(popr, true)
13159 size2 := github_com_gogo_protobuf_proto.Size(p)
13160 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13161 if err != nil {
13162 t.Fatalf("seed = %d, err = %v", seed, err)
13163 }
13164 size := p.Size()
13165 if len(dAtA) != size {
13166 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13167 }
13168 if size2 != size {
13169 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13170 }
13171 size3 := github_com_gogo_protobuf_proto.Size(p)
13172 if size3 != size {
13173 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13174 }
13175 }
13176
13177 func BenchmarkNinRepStructSize(b *testing.B) {
13178 popr := math_rand.New(math_rand.NewSource(616))
13179 total := 0
13180 pops := make([]*NinRepStruct, 1000)
13181 for i := 0; i < 1000; i++ {
13182 pops[i] = NewPopulatedNinRepStruct(popr, false)
13183 }
13184 b.ResetTimer()
13185 for i := 0; i < b.N; i++ {
13186 total += pops[i%1000].Size()
13187 }
13188 b.SetBytes(int64(total / b.N))
13189 }
13190
13191 func TestNidEmbeddedStructSize(t *testing.T) {
13192 seed := time.Now().UnixNano()
13193 popr := math_rand.New(math_rand.NewSource(seed))
13194 p := NewPopulatedNidEmbeddedStruct(popr, true)
13195 size2 := github_com_gogo_protobuf_proto.Size(p)
13196 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13197 if err != nil {
13198 t.Fatalf("seed = %d, err = %v", seed, err)
13199 }
13200 size := p.Size()
13201 if len(dAtA) != size {
13202 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13203 }
13204 if size2 != size {
13205 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13206 }
13207 size3 := github_com_gogo_protobuf_proto.Size(p)
13208 if size3 != size {
13209 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13210 }
13211 }
13212
13213 func BenchmarkNidEmbeddedStructSize(b *testing.B) {
13214 popr := math_rand.New(math_rand.NewSource(616))
13215 total := 0
13216 pops := make([]*NidEmbeddedStruct, 1000)
13217 for i := 0; i < 1000; i++ {
13218 pops[i] = NewPopulatedNidEmbeddedStruct(popr, false)
13219 }
13220 b.ResetTimer()
13221 for i := 0; i < b.N; i++ {
13222 total += pops[i%1000].Size()
13223 }
13224 b.SetBytes(int64(total / b.N))
13225 }
13226
13227 func TestNinEmbeddedStructSize(t *testing.T) {
13228 seed := time.Now().UnixNano()
13229 popr := math_rand.New(math_rand.NewSource(seed))
13230 p := NewPopulatedNinEmbeddedStruct(popr, true)
13231 size2 := github_com_gogo_protobuf_proto.Size(p)
13232 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13233 if err != nil {
13234 t.Fatalf("seed = %d, err = %v", seed, err)
13235 }
13236 size := p.Size()
13237 if len(dAtA) != size {
13238 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13239 }
13240 if size2 != size {
13241 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13242 }
13243 size3 := github_com_gogo_protobuf_proto.Size(p)
13244 if size3 != size {
13245 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13246 }
13247 }
13248
13249 func BenchmarkNinEmbeddedStructSize(b *testing.B) {
13250 popr := math_rand.New(math_rand.NewSource(616))
13251 total := 0
13252 pops := make([]*NinEmbeddedStruct, 1000)
13253 for i := 0; i < 1000; i++ {
13254 pops[i] = NewPopulatedNinEmbeddedStruct(popr, false)
13255 }
13256 b.ResetTimer()
13257 for i := 0; i < b.N; i++ {
13258 total += pops[i%1000].Size()
13259 }
13260 b.SetBytes(int64(total / b.N))
13261 }
13262
13263 func TestNidNestedStructSize(t *testing.T) {
13264 seed := time.Now().UnixNano()
13265 popr := math_rand.New(math_rand.NewSource(seed))
13266 p := NewPopulatedNidNestedStruct(popr, true)
13267 size2 := github_com_gogo_protobuf_proto.Size(p)
13268 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13269 if err != nil {
13270 t.Fatalf("seed = %d, err = %v", seed, err)
13271 }
13272 size := p.Size()
13273 if len(dAtA) != size {
13274 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13275 }
13276 if size2 != size {
13277 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13278 }
13279 size3 := github_com_gogo_protobuf_proto.Size(p)
13280 if size3 != size {
13281 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13282 }
13283 }
13284
13285 func BenchmarkNidNestedStructSize(b *testing.B) {
13286 popr := math_rand.New(math_rand.NewSource(616))
13287 total := 0
13288 pops := make([]*NidNestedStruct, 1000)
13289 for i := 0; i < 1000; i++ {
13290 pops[i] = NewPopulatedNidNestedStruct(popr, false)
13291 }
13292 b.ResetTimer()
13293 for i := 0; i < b.N; i++ {
13294 total += pops[i%1000].Size()
13295 }
13296 b.SetBytes(int64(total / b.N))
13297 }
13298
13299 func TestNinNestedStructSize(t *testing.T) {
13300 seed := time.Now().UnixNano()
13301 popr := math_rand.New(math_rand.NewSource(seed))
13302 p := NewPopulatedNinNestedStruct(popr, true)
13303 size2 := github_com_gogo_protobuf_proto.Size(p)
13304 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13305 if err != nil {
13306 t.Fatalf("seed = %d, err = %v", seed, err)
13307 }
13308 size := p.Size()
13309 if len(dAtA) != size {
13310 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13311 }
13312 if size2 != size {
13313 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13314 }
13315 size3 := github_com_gogo_protobuf_proto.Size(p)
13316 if size3 != size {
13317 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13318 }
13319 }
13320
13321 func BenchmarkNinNestedStructSize(b *testing.B) {
13322 popr := math_rand.New(math_rand.NewSource(616))
13323 total := 0
13324 pops := make([]*NinNestedStruct, 1000)
13325 for i := 0; i < 1000; i++ {
13326 pops[i] = NewPopulatedNinNestedStruct(popr, false)
13327 }
13328 b.ResetTimer()
13329 for i := 0; i < b.N; i++ {
13330 total += pops[i%1000].Size()
13331 }
13332 b.SetBytes(int64(total / b.N))
13333 }
13334
13335 func TestNidOptCustomSize(t *testing.T) {
13336 seed := time.Now().UnixNano()
13337 popr := math_rand.New(math_rand.NewSource(seed))
13338 p := NewPopulatedNidOptCustom(popr, true)
13339 size2 := github_com_gogo_protobuf_proto.Size(p)
13340 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13341 if err != nil {
13342 t.Fatalf("seed = %d, err = %v", seed, err)
13343 }
13344 size := p.Size()
13345 if len(dAtA) != size {
13346 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13347 }
13348 if size2 != size {
13349 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13350 }
13351 size3 := github_com_gogo_protobuf_proto.Size(p)
13352 if size3 != size {
13353 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13354 }
13355 }
13356
13357 func BenchmarkNidOptCustomSize(b *testing.B) {
13358 popr := math_rand.New(math_rand.NewSource(616))
13359 total := 0
13360 pops := make([]*NidOptCustom, 1000)
13361 for i := 0; i < 1000; i++ {
13362 pops[i] = NewPopulatedNidOptCustom(popr, false)
13363 }
13364 b.ResetTimer()
13365 for i := 0; i < b.N; i++ {
13366 total += pops[i%1000].Size()
13367 }
13368 b.SetBytes(int64(total / b.N))
13369 }
13370
13371 func TestCustomDashSize(t *testing.T) {
13372 seed := time.Now().UnixNano()
13373 popr := math_rand.New(math_rand.NewSource(seed))
13374 p := NewPopulatedCustomDash(popr, true)
13375 size2 := github_com_gogo_protobuf_proto.Size(p)
13376 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13377 if err != nil {
13378 t.Fatalf("seed = %d, err = %v", seed, err)
13379 }
13380 size := p.Size()
13381 if len(dAtA) != size {
13382 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13383 }
13384 if size2 != size {
13385 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13386 }
13387 size3 := github_com_gogo_protobuf_proto.Size(p)
13388 if size3 != size {
13389 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13390 }
13391 }
13392
13393 func BenchmarkCustomDashSize(b *testing.B) {
13394 popr := math_rand.New(math_rand.NewSource(616))
13395 total := 0
13396 pops := make([]*CustomDash, 1000)
13397 for i := 0; i < 1000; i++ {
13398 pops[i] = NewPopulatedCustomDash(popr, false)
13399 }
13400 b.ResetTimer()
13401 for i := 0; i < b.N; i++ {
13402 total += pops[i%1000].Size()
13403 }
13404 b.SetBytes(int64(total / b.N))
13405 }
13406
13407 func TestNinOptCustomSize(t *testing.T) {
13408 seed := time.Now().UnixNano()
13409 popr := math_rand.New(math_rand.NewSource(seed))
13410 p := NewPopulatedNinOptCustom(popr, true)
13411 size2 := github_com_gogo_protobuf_proto.Size(p)
13412 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13413 if err != nil {
13414 t.Fatalf("seed = %d, err = %v", seed, err)
13415 }
13416 size := p.Size()
13417 if len(dAtA) != size {
13418 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13419 }
13420 if size2 != size {
13421 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13422 }
13423 size3 := github_com_gogo_protobuf_proto.Size(p)
13424 if size3 != size {
13425 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13426 }
13427 }
13428
13429 func BenchmarkNinOptCustomSize(b *testing.B) {
13430 popr := math_rand.New(math_rand.NewSource(616))
13431 total := 0
13432 pops := make([]*NinOptCustom, 1000)
13433 for i := 0; i < 1000; i++ {
13434 pops[i] = NewPopulatedNinOptCustom(popr, false)
13435 }
13436 b.ResetTimer()
13437 for i := 0; i < b.N; i++ {
13438 total += pops[i%1000].Size()
13439 }
13440 b.SetBytes(int64(total / b.N))
13441 }
13442
13443 func TestNidRepCustomSize(t *testing.T) {
13444 seed := time.Now().UnixNano()
13445 popr := math_rand.New(math_rand.NewSource(seed))
13446 p := NewPopulatedNidRepCustom(popr, true)
13447 size2 := github_com_gogo_protobuf_proto.Size(p)
13448 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13449 if err != nil {
13450 t.Fatalf("seed = %d, err = %v", seed, err)
13451 }
13452 size := p.Size()
13453 if len(dAtA) != size {
13454 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13455 }
13456 if size2 != size {
13457 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13458 }
13459 size3 := github_com_gogo_protobuf_proto.Size(p)
13460 if size3 != size {
13461 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13462 }
13463 }
13464
13465 func BenchmarkNidRepCustomSize(b *testing.B) {
13466 popr := math_rand.New(math_rand.NewSource(616))
13467 total := 0
13468 pops := make([]*NidRepCustom, 1000)
13469 for i := 0; i < 1000; i++ {
13470 pops[i] = NewPopulatedNidRepCustom(popr, false)
13471 }
13472 b.ResetTimer()
13473 for i := 0; i < b.N; i++ {
13474 total += pops[i%1000].Size()
13475 }
13476 b.SetBytes(int64(total / b.N))
13477 }
13478
13479 func TestNinRepCustomSize(t *testing.T) {
13480 seed := time.Now().UnixNano()
13481 popr := math_rand.New(math_rand.NewSource(seed))
13482 p := NewPopulatedNinRepCustom(popr, true)
13483 size2 := github_com_gogo_protobuf_proto.Size(p)
13484 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13485 if err != nil {
13486 t.Fatalf("seed = %d, err = %v", seed, err)
13487 }
13488 size := p.Size()
13489 if len(dAtA) != size {
13490 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13491 }
13492 if size2 != size {
13493 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13494 }
13495 size3 := github_com_gogo_protobuf_proto.Size(p)
13496 if size3 != size {
13497 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13498 }
13499 }
13500
13501 func BenchmarkNinRepCustomSize(b *testing.B) {
13502 popr := math_rand.New(math_rand.NewSource(616))
13503 total := 0
13504 pops := make([]*NinRepCustom, 1000)
13505 for i := 0; i < 1000; i++ {
13506 pops[i] = NewPopulatedNinRepCustom(popr, false)
13507 }
13508 b.ResetTimer()
13509 for i := 0; i < b.N; i++ {
13510 total += pops[i%1000].Size()
13511 }
13512 b.SetBytes(int64(total / b.N))
13513 }
13514
13515 func TestNinOptNativeUnionSize(t *testing.T) {
13516 seed := time.Now().UnixNano()
13517 popr := math_rand.New(math_rand.NewSource(seed))
13518 p := NewPopulatedNinOptNativeUnion(popr, true)
13519 size2 := github_com_gogo_protobuf_proto.Size(p)
13520 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13521 if err != nil {
13522 t.Fatalf("seed = %d, err = %v", seed, err)
13523 }
13524 size := p.Size()
13525 if len(dAtA) != size {
13526 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13527 }
13528 if size2 != size {
13529 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13530 }
13531 size3 := github_com_gogo_protobuf_proto.Size(p)
13532 if size3 != size {
13533 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13534 }
13535 }
13536
13537 func BenchmarkNinOptNativeUnionSize(b *testing.B) {
13538 popr := math_rand.New(math_rand.NewSource(616))
13539 total := 0
13540 pops := make([]*NinOptNativeUnion, 1000)
13541 for i := 0; i < 1000; i++ {
13542 pops[i] = NewPopulatedNinOptNativeUnion(popr, false)
13543 }
13544 b.ResetTimer()
13545 for i := 0; i < b.N; i++ {
13546 total += pops[i%1000].Size()
13547 }
13548 b.SetBytes(int64(total / b.N))
13549 }
13550
13551 func TestNinOptStructUnionSize(t *testing.T) {
13552 seed := time.Now().UnixNano()
13553 popr := math_rand.New(math_rand.NewSource(seed))
13554 p := NewPopulatedNinOptStructUnion(popr, true)
13555 size2 := github_com_gogo_protobuf_proto.Size(p)
13556 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13557 if err != nil {
13558 t.Fatalf("seed = %d, err = %v", seed, err)
13559 }
13560 size := p.Size()
13561 if len(dAtA) != size {
13562 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13563 }
13564 if size2 != size {
13565 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13566 }
13567 size3 := github_com_gogo_protobuf_proto.Size(p)
13568 if size3 != size {
13569 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13570 }
13571 }
13572
13573 func BenchmarkNinOptStructUnionSize(b *testing.B) {
13574 popr := math_rand.New(math_rand.NewSource(616))
13575 total := 0
13576 pops := make([]*NinOptStructUnion, 1000)
13577 for i := 0; i < 1000; i++ {
13578 pops[i] = NewPopulatedNinOptStructUnion(popr, false)
13579 }
13580 b.ResetTimer()
13581 for i := 0; i < b.N; i++ {
13582 total += pops[i%1000].Size()
13583 }
13584 b.SetBytes(int64(total / b.N))
13585 }
13586
13587 func TestNinEmbeddedStructUnionSize(t *testing.T) {
13588 seed := time.Now().UnixNano()
13589 popr := math_rand.New(math_rand.NewSource(seed))
13590 p := NewPopulatedNinEmbeddedStructUnion(popr, true)
13591 size2 := github_com_gogo_protobuf_proto.Size(p)
13592 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13593 if err != nil {
13594 t.Fatalf("seed = %d, err = %v", seed, err)
13595 }
13596 size := p.Size()
13597 if len(dAtA) != size {
13598 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13599 }
13600 if size2 != size {
13601 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13602 }
13603 size3 := github_com_gogo_protobuf_proto.Size(p)
13604 if size3 != size {
13605 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13606 }
13607 }
13608
13609 func BenchmarkNinEmbeddedStructUnionSize(b *testing.B) {
13610 popr := math_rand.New(math_rand.NewSource(616))
13611 total := 0
13612 pops := make([]*NinEmbeddedStructUnion, 1000)
13613 for i := 0; i < 1000; i++ {
13614 pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false)
13615 }
13616 b.ResetTimer()
13617 for i := 0; i < b.N; i++ {
13618 total += pops[i%1000].Size()
13619 }
13620 b.SetBytes(int64(total / b.N))
13621 }
13622
13623 func TestNinNestedStructUnionSize(t *testing.T) {
13624 seed := time.Now().UnixNano()
13625 popr := math_rand.New(math_rand.NewSource(seed))
13626 p := NewPopulatedNinNestedStructUnion(popr, true)
13627 size2 := github_com_gogo_protobuf_proto.Size(p)
13628 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13629 if err != nil {
13630 t.Fatalf("seed = %d, err = %v", seed, err)
13631 }
13632 size := p.Size()
13633 if len(dAtA) != size {
13634 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13635 }
13636 if size2 != size {
13637 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13638 }
13639 size3 := github_com_gogo_protobuf_proto.Size(p)
13640 if size3 != size {
13641 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13642 }
13643 }
13644
13645 func BenchmarkNinNestedStructUnionSize(b *testing.B) {
13646 popr := math_rand.New(math_rand.NewSource(616))
13647 total := 0
13648 pops := make([]*NinNestedStructUnion, 1000)
13649 for i := 0; i < 1000; i++ {
13650 pops[i] = NewPopulatedNinNestedStructUnion(popr, false)
13651 }
13652 b.ResetTimer()
13653 for i := 0; i < b.N; i++ {
13654 total += pops[i%1000].Size()
13655 }
13656 b.SetBytes(int64(total / b.N))
13657 }
13658
13659 func TestTreeSize(t *testing.T) {
13660 seed := time.Now().UnixNano()
13661 popr := math_rand.New(math_rand.NewSource(seed))
13662 p := NewPopulatedTree(popr, true)
13663 size2 := github_com_gogo_protobuf_proto.Size(p)
13664 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13665 if err != nil {
13666 t.Fatalf("seed = %d, err = %v", seed, err)
13667 }
13668 size := p.Size()
13669 if len(dAtA) != size {
13670 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13671 }
13672 if size2 != size {
13673 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13674 }
13675 size3 := github_com_gogo_protobuf_proto.Size(p)
13676 if size3 != size {
13677 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13678 }
13679 }
13680
13681 func BenchmarkTreeSize(b *testing.B) {
13682 popr := math_rand.New(math_rand.NewSource(616))
13683 total := 0
13684 pops := make([]*Tree, 1000)
13685 for i := 0; i < 1000; i++ {
13686 pops[i] = NewPopulatedTree(popr, false)
13687 }
13688 b.ResetTimer()
13689 for i := 0; i < b.N; i++ {
13690 total += pops[i%1000].Size()
13691 }
13692 b.SetBytes(int64(total / b.N))
13693 }
13694
13695 func TestOrBranchSize(t *testing.T) {
13696 seed := time.Now().UnixNano()
13697 popr := math_rand.New(math_rand.NewSource(seed))
13698 p := NewPopulatedOrBranch(popr, true)
13699 size2 := github_com_gogo_protobuf_proto.Size(p)
13700 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13701 if err != nil {
13702 t.Fatalf("seed = %d, err = %v", seed, err)
13703 }
13704 size := p.Size()
13705 if len(dAtA) != size {
13706 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13707 }
13708 if size2 != size {
13709 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13710 }
13711 size3 := github_com_gogo_protobuf_proto.Size(p)
13712 if size3 != size {
13713 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13714 }
13715 }
13716
13717 func BenchmarkOrBranchSize(b *testing.B) {
13718 popr := math_rand.New(math_rand.NewSource(616))
13719 total := 0
13720 pops := make([]*OrBranch, 1000)
13721 for i := 0; i < 1000; i++ {
13722 pops[i] = NewPopulatedOrBranch(popr, false)
13723 }
13724 b.ResetTimer()
13725 for i := 0; i < b.N; i++ {
13726 total += pops[i%1000].Size()
13727 }
13728 b.SetBytes(int64(total / b.N))
13729 }
13730
13731 func TestAndBranchSize(t *testing.T) {
13732 seed := time.Now().UnixNano()
13733 popr := math_rand.New(math_rand.NewSource(seed))
13734 p := NewPopulatedAndBranch(popr, true)
13735 size2 := github_com_gogo_protobuf_proto.Size(p)
13736 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13737 if err != nil {
13738 t.Fatalf("seed = %d, err = %v", seed, err)
13739 }
13740 size := p.Size()
13741 if len(dAtA) != size {
13742 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13743 }
13744 if size2 != size {
13745 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13746 }
13747 size3 := github_com_gogo_protobuf_proto.Size(p)
13748 if size3 != size {
13749 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13750 }
13751 }
13752
13753 func BenchmarkAndBranchSize(b *testing.B) {
13754 popr := math_rand.New(math_rand.NewSource(616))
13755 total := 0
13756 pops := make([]*AndBranch, 1000)
13757 for i := 0; i < 1000; i++ {
13758 pops[i] = NewPopulatedAndBranch(popr, false)
13759 }
13760 b.ResetTimer()
13761 for i := 0; i < b.N; i++ {
13762 total += pops[i%1000].Size()
13763 }
13764 b.SetBytes(int64(total / b.N))
13765 }
13766
13767 func TestLeafSize(t *testing.T) {
13768 seed := time.Now().UnixNano()
13769 popr := math_rand.New(math_rand.NewSource(seed))
13770 p := NewPopulatedLeaf(popr, true)
13771 size2 := github_com_gogo_protobuf_proto.Size(p)
13772 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13773 if err != nil {
13774 t.Fatalf("seed = %d, err = %v", seed, err)
13775 }
13776 size := p.Size()
13777 if len(dAtA) != size {
13778 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13779 }
13780 if size2 != size {
13781 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13782 }
13783 size3 := github_com_gogo_protobuf_proto.Size(p)
13784 if size3 != size {
13785 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13786 }
13787 }
13788
13789 func BenchmarkLeafSize(b *testing.B) {
13790 popr := math_rand.New(math_rand.NewSource(616))
13791 total := 0
13792 pops := make([]*Leaf, 1000)
13793 for i := 0; i < 1000; i++ {
13794 pops[i] = NewPopulatedLeaf(popr, false)
13795 }
13796 b.ResetTimer()
13797 for i := 0; i < b.N; i++ {
13798 total += pops[i%1000].Size()
13799 }
13800 b.SetBytes(int64(total / b.N))
13801 }
13802
13803 func TestDeepTreeSize(t *testing.T) {
13804 seed := time.Now().UnixNano()
13805 popr := math_rand.New(math_rand.NewSource(seed))
13806 p := NewPopulatedDeepTree(popr, true)
13807 size2 := github_com_gogo_protobuf_proto.Size(p)
13808 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13809 if err != nil {
13810 t.Fatalf("seed = %d, err = %v", seed, err)
13811 }
13812 size := p.Size()
13813 if len(dAtA) != size {
13814 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13815 }
13816 if size2 != size {
13817 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13818 }
13819 size3 := github_com_gogo_protobuf_proto.Size(p)
13820 if size3 != size {
13821 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13822 }
13823 }
13824
13825 func BenchmarkDeepTreeSize(b *testing.B) {
13826 popr := math_rand.New(math_rand.NewSource(616))
13827 total := 0
13828 pops := make([]*DeepTree, 1000)
13829 for i := 0; i < 1000; i++ {
13830 pops[i] = NewPopulatedDeepTree(popr, false)
13831 }
13832 b.ResetTimer()
13833 for i := 0; i < b.N; i++ {
13834 total += pops[i%1000].Size()
13835 }
13836 b.SetBytes(int64(total / b.N))
13837 }
13838
13839 func TestADeepBranchSize(t *testing.T) {
13840 seed := time.Now().UnixNano()
13841 popr := math_rand.New(math_rand.NewSource(seed))
13842 p := NewPopulatedADeepBranch(popr, true)
13843 size2 := github_com_gogo_protobuf_proto.Size(p)
13844 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13845 if err != nil {
13846 t.Fatalf("seed = %d, err = %v", seed, err)
13847 }
13848 size := p.Size()
13849 if len(dAtA) != size {
13850 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13851 }
13852 if size2 != size {
13853 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13854 }
13855 size3 := github_com_gogo_protobuf_proto.Size(p)
13856 if size3 != size {
13857 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13858 }
13859 }
13860
13861 func BenchmarkADeepBranchSize(b *testing.B) {
13862 popr := math_rand.New(math_rand.NewSource(616))
13863 total := 0
13864 pops := make([]*ADeepBranch, 1000)
13865 for i := 0; i < 1000; i++ {
13866 pops[i] = NewPopulatedADeepBranch(popr, false)
13867 }
13868 b.ResetTimer()
13869 for i := 0; i < b.N; i++ {
13870 total += pops[i%1000].Size()
13871 }
13872 b.SetBytes(int64(total / b.N))
13873 }
13874
13875 func TestAndDeepBranchSize(t *testing.T) {
13876 seed := time.Now().UnixNano()
13877 popr := math_rand.New(math_rand.NewSource(seed))
13878 p := NewPopulatedAndDeepBranch(popr, true)
13879 size2 := github_com_gogo_protobuf_proto.Size(p)
13880 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13881 if err != nil {
13882 t.Fatalf("seed = %d, err = %v", seed, err)
13883 }
13884 size := p.Size()
13885 if len(dAtA) != size {
13886 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13887 }
13888 if size2 != size {
13889 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13890 }
13891 size3 := github_com_gogo_protobuf_proto.Size(p)
13892 if size3 != size {
13893 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13894 }
13895 }
13896
13897 func BenchmarkAndDeepBranchSize(b *testing.B) {
13898 popr := math_rand.New(math_rand.NewSource(616))
13899 total := 0
13900 pops := make([]*AndDeepBranch, 1000)
13901 for i := 0; i < 1000; i++ {
13902 pops[i] = NewPopulatedAndDeepBranch(popr, false)
13903 }
13904 b.ResetTimer()
13905 for i := 0; i < b.N; i++ {
13906 total += pops[i%1000].Size()
13907 }
13908 b.SetBytes(int64(total / b.N))
13909 }
13910
13911 func TestDeepLeafSize(t *testing.T) {
13912 seed := time.Now().UnixNano()
13913 popr := math_rand.New(math_rand.NewSource(seed))
13914 p := NewPopulatedDeepLeaf(popr, true)
13915 size2 := github_com_gogo_protobuf_proto.Size(p)
13916 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13917 if err != nil {
13918 t.Fatalf("seed = %d, err = %v", seed, err)
13919 }
13920 size := p.Size()
13921 if len(dAtA) != size {
13922 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13923 }
13924 if size2 != size {
13925 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13926 }
13927 size3 := github_com_gogo_protobuf_proto.Size(p)
13928 if size3 != size {
13929 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13930 }
13931 }
13932
13933 func BenchmarkDeepLeafSize(b *testing.B) {
13934 popr := math_rand.New(math_rand.NewSource(616))
13935 total := 0
13936 pops := make([]*DeepLeaf, 1000)
13937 for i := 0; i < 1000; i++ {
13938 pops[i] = NewPopulatedDeepLeaf(popr, false)
13939 }
13940 b.ResetTimer()
13941 for i := 0; i < b.N; i++ {
13942 total += pops[i%1000].Size()
13943 }
13944 b.SetBytes(int64(total / b.N))
13945 }
13946
13947 func TestNilSize(t *testing.T) {
13948 seed := time.Now().UnixNano()
13949 popr := math_rand.New(math_rand.NewSource(seed))
13950 p := NewPopulatedNil(popr, true)
13951 size2 := github_com_gogo_protobuf_proto.Size(p)
13952 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13953 if err != nil {
13954 t.Fatalf("seed = %d, err = %v", seed, err)
13955 }
13956 size := p.Size()
13957 if len(dAtA) != size {
13958 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13959 }
13960 if size2 != size {
13961 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13962 }
13963 size3 := github_com_gogo_protobuf_proto.Size(p)
13964 if size3 != size {
13965 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
13966 }
13967 }
13968
13969 func BenchmarkNilSize(b *testing.B) {
13970 popr := math_rand.New(math_rand.NewSource(616))
13971 total := 0
13972 pops := make([]*Nil, 1000)
13973 for i := 0; i < 1000; i++ {
13974 pops[i] = NewPopulatedNil(popr, false)
13975 }
13976 b.ResetTimer()
13977 for i := 0; i < b.N; i++ {
13978 total += pops[i%1000].Size()
13979 }
13980 b.SetBytes(int64(total / b.N))
13981 }
13982
13983 func TestNidOptEnumSize(t *testing.T) {
13984 seed := time.Now().UnixNano()
13985 popr := math_rand.New(math_rand.NewSource(seed))
13986 p := NewPopulatedNidOptEnum(popr, true)
13987 size2 := github_com_gogo_protobuf_proto.Size(p)
13988 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
13989 if err != nil {
13990 t.Fatalf("seed = %d, err = %v", seed, err)
13991 }
13992 size := p.Size()
13993 if len(dAtA) != size {
13994 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
13995 }
13996 if size2 != size {
13997 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
13998 }
13999 size3 := github_com_gogo_protobuf_proto.Size(p)
14000 if size3 != size {
14001 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14002 }
14003 }
14004
14005 func BenchmarkNidOptEnumSize(b *testing.B) {
14006 popr := math_rand.New(math_rand.NewSource(616))
14007 total := 0
14008 pops := make([]*NidOptEnum, 1000)
14009 for i := 0; i < 1000; i++ {
14010 pops[i] = NewPopulatedNidOptEnum(popr, false)
14011 }
14012 b.ResetTimer()
14013 for i := 0; i < b.N; i++ {
14014 total += pops[i%1000].Size()
14015 }
14016 b.SetBytes(int64(total / b.N))
14017 }
14018
14019 func TestNinOptEnumSize(t *testing.T) {
14020 seed := time.Now().UnixNano()
14021 popr := math_rand.New(math_rand.NewSource(seed))
14022 p := NewPopulatedNinOptEnum(popr, true)
14023 size2 := github_com_gogo_protobuf_proto.Size(p)
14024 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14025 if err != nil {
14026 t.Fatalf("seed = %d, err = %v", seed, err)
14027 }
14028 size := p.Size()
14029 if len(dAtA) != size {
14030 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14031 }
14032 if size2 != size {
14033 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14034 }
14035 size3 := github_com_gogo_protobuf_proto.Size(p)
14036 if size3 != size {
14037 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14038 }
14039 }
14040
14041 func BenchmarkNinOptEnumSize(b *testing.B) {
14042 popr := math_rand.New(math_rand.NewSource(616))
14043 total := 0
14044 pops := make([]*NinOptEnum, 1000)
14045 for i := 0; i < 1000; i++ {
14046 pops[i] = NewPopulatedNinOptEnum(popr, false)
14047 }
14048 b.ResetTimer()
14049 for i := 0; i < b.N; i++ {
14050 total += pops[i%1000].Size()
14051 }
14052 b.SetBytes(int64(total / b.N))
14053 }
14054
14055 func TestNidRepEnumSize(t *testing.T) {
14056 seed := time.Now().UnixNano()
14057 popr := math_rand.New(math_rand.NewSource(seed))
14058 p := NewPopulatedNidRepEnum(popr, true)
14059 size2 := github_com_gogo_protobuf_proto.Size(p)
14060 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14061 if err != nil {
14062 t.Fatalf("seed = %d, err = %v", seed, err)
14063 }
14064 size := p.Size()
14065 if len(dAtA) != size {
14066 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14067 }
14068 if size2 != size {
14069 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14070 }
14071 size3 := github_com_gogo_protobuf_proto.Size(p)
14072 if size3 != size {
14073 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14074 }
14075 }
14076
14077 func BenchmarkNidRepEnumSize(b *testing.B) {
14078 popr := math_rand.New(math_rand.NewSource(616))
14079 total := 0
14080 pops := make([]*NidRepEnum, 1000)
14081 for i := 0; i < 1000; i++ {
14082 pops[i] = NewPopulatedNidRepEnum(popr, false)
14083 }
14084 b.ResetTimer()
14085 for i := 0; i < b.N; i++ {
14086 total += pops[i%1000].Size()
14087 }
14088 b.SetBytes(int64(total / b.N))
14089 }
14090
14091 func TestNinRepEnumSize(t *testing.T) {
14092 seed := time.Now().UnixNano()
14093 popr := math_rand.New(math_rand.NewSource(seed))
14094 p := NewPopulatedNinRepEnum(popr, true)
14095 size2 := github_com_gogo_protobuf_proto.Size(p)
14096 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14097 if err != nil {
14098 t.Fatalf("seed = %d, err = %v", seed, err)
14099 }
14100 size := p.Size()
14101 if len(dAtA) != size {
14102 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14103 }
14104 if size2 != size {
14105 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14106 }
14107 size3 := github_com_gogo_protobuf_proto.Size(p)
14108 if size3 != size {
14109 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14110 }
14111 }
14112
14113 func BenchmarkNinRepEnumSize(b *testing.B) {
14114 popr := math_rand.New(math_rand.NewSource(616))
14115 total := 0
14116 pops := make([]*NinRepEnum, 1000)
14117 for i := 0; i < 1000; i++ {
14118 pops[i] = NewPopulatedNinRepEnum(popr, false)
14119 }
14120 b.ResetTimer()
14121 for i := 0; i < b.N; i++ {
14122 total += pops[i%1000].Size()
14123 }
14124 b.SetBytes(int64(total / b.N))
14125 }
14126
14127 func TestNinOptEnumDefaultSize(t *testing.T) {
14128 seed := time.Now().UnixNano()
14129 popr := math_rand.New(math_rand.NewSource(seed))
14130 p := NewPopulatedNinOptEnumDefault(popr, true)
14131 size2 := github_com_gogo_protobuf_proto.Size(p)
14132 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14133 if err != nil {
14134 t.Fatalf("seed = %d, err = %v", seed, err)
14135 }
14136 size := p.Size()
14137 if len(dAtA) != size {
14138 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14139 }
14140 if size2 != size {
14141 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14142 }
14143 size3 := github_com_gogo_protobuf_proto.Size(p)
14144 if size3 != size {
14145 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14146 }
14147 }
14148
14149 func BenchmarkNinOptEnumDefaultSize(b *testing.B) {
14150 popr := math_rand.New(math_rand.NewSource(616))
14151 total := 0
14152 pops := make([]*NinOptEnumDefault, 1000)
14153 for i := 0; i < 1000; i++ {
14154 pops[i] = NewPopulatedNinOptEnumDefault(popr, false)
14155 }
14156 b.ResetTimer()
14157 for i := 0; i < b.N; i++ {
14158 total += pops[i%1000].Size()
14159 }
14160 b.SetBytes(int64(total / b.N))
14161 }
14162
14163 func TestAnotherNinOptEnumSize(t *testing.T) {
14164 seed := time.Now().UnixNano()
14165 popr := math_rand.New(math_rand.NewSource(seed))
14166 p := NewPopulatedAnotherNinOptEnum(popr, true)
14167 size2 := github_com_gogo_protobuf_proto.Size(p)
14168 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14169 if err != nil {
14170 t.Fatalf("seed = %d, err = %v", seed, err)
14171 }
14172 size := p.Size()
14173 if len(dAtA) != size {
14174 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14175 }
14176 if size2 != size {
14177 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14178 }
14179 size3 := github_com_gogo_protobuf_proto.Size(p)
14180 if size3 != size {
14181 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14182 }
14183 }
14184
14185 func BenchmarkAnotherNinOptEnumSize(b *testing.B) {
14186 popr := math_rand.New(math_rand.NewSource(616))
14187 total := 0
14188 pops := make([]*AnotherNinOptEnum, 1000)
14189 for i := 0; i < 1000; i++ {
14190 pops[i] = NewPopulatedAnotherNinOptEnum(popr, false)
14191 }
14192 b.ResetTimer()
14193 for i := 0; i < b.N; i++ {
14194 total += pops[i%1000].Size()
14195 }
14196 b.SetBytes(int64(total / b.N))
14197 }
14198
14199 func TestAnotherNinOptEnumDefaultSize(t *testing.T) {
14200 seed := time.Now().UnixNano()
14201 popr := math_rand.New(math_rand.NewSource(seed))
14202 p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
14203 size2 := github_com_gogo_protobuf_proto.Size(p)
14204 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14205 if err != nil {
14206 t.Fatalf("seed = %d, err = %v", seed, err)
14207 }
14208 size := p.Size()
14209 if len(dAtA) != size {
14210 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14211 }
14212 if size2 != size {
14213 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14214 }
14215 size3 := github_com_gogo_protobuf_proto.Size(p)
14216 if size3 != size {
14217 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14218 }
14219 }
14220
14221 func BenchmarkAnotherNinOptEnumDefaultSize(b *testing.B) {
14222 popr := math_rand.New(math_rand.NewSource(616))
14223 total := 0
14224 pops := make([]*AnotherNinOptEnumDefault, 1000)
14225 for i := 0; i < 1000; i++ {
14226 pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false)
14227 }
14228 b.ResetTimer()
14229 for i := 0; i < b.N; i++ {
14230 total += pops[i%1000].Size()
14231 }
14232 b.SetBytes(int64(total / b.N))
14233 }
14234
14235 func TestTimerSize(t *testing.T) {
14236 seed := time.Now().UnixNano()
14237 popr := math_rand.New(math_rand.NewSource(seed))
14238 p := NewPopulatedTimer(popr, true)
14239 size2 := github_com_gogo_protobuf_proto.Size(p)
14240 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14241 if err != nil {
14242 t.Fatalf("seed = %d, err = %v", seed, err)
14243 }
14244 size := p.Size()
14245 if len(dAtA) != size {
14246 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14247 }
14248 if size2 != size {
14249 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14250 }
14251 size3 := github_com_gogo_protobuf_proto.Size(p)
14252 if size3 != size {
14253 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14254 }
14255 }
14256
14257 func BenchmarkTimerSize(b *testing.B) {
14258 popr := math_rand.New(math_rand.NewSource(616))
14259 total := 0
14260 pops := make([]*Timer, 1000)
14261 for i := 0; i < 1000; i++ {
14262 pops[i] = NewPopulatedTimer(popr, false)
14263 }
14264 b.ResetTimer()
14265 for i := 0; i < b.N; i++ {
14266 total += pops[i%1000].Size()
14267 }
14268 b.SetBytes(int64(total / b.N))
14269 }
14270
14271 func TestMyExtendableSize(t *testing.T) {
14272 seed := time.Now().UnixNano()
14273 popr := math_rand.New(math_rand.NewSource(seed))
14274 p := NewPopulatedMyExtendable(popr, true)
14275 size2 := github_com_gogo_protobuf_proto.Size(p)
14276 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14277 if err != nil {
14278 t.Fatalf("seed = %d, err = %v", seed, err)
14279 }
14280 size := p.Size()
14281 if len(dAtA) != size {
14282 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14283 }
14284 if size2 != size {
14285 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14286 }
14287 size3 := github_com_gogo_protobuf_proto.Size(p)
14288 if size3 != size {
14289 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14290 }
14291 }
14292
14293 func BenchmarkMyExtendableSize(b *testing.B) {
14294 popr := math_rand.New(math_rand.NewSource(616))
14295 total := 0
14296 pops := make([]*MyExtendable, 1000)
14297 for i := 0; i < 1000; i++ {
14298 pops[i] = NewPopulatedMyExtendable(popr, false)
14299 }
14300 b.ResetTimer()
14301 for i := 0; i < b.N; i++ {
14302 total += pops[i%1000].Size()
14303 }
14304 b.SetBytes(int64(total / b.N))
14305 }
14306
14307 func TestOtherExtenableSize(t *testing.T) {
14308 seed := time.Now().UnixNano()
14309 popr := math_rand.New(math_rand.NewSource(seed))
14310 p := NewPopulatedOtherExtenable(popr, true)
14311 size2 := github_com_gogo_protobuf_proto.Size(p)
14312 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14313 if err != nil {
14314 t.Fatalf("seed = %d, err = %v", seed, err)
14315 }
14316 size := p.Size()
14317 if len(dAtA) != size {
14318 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14319 }
14320 if size2 != size {
14321 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14322 }
14323 size3 := github_com_gogo_protobuf_proto.Size(p)
14324 if size3 != size {
14325 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14326 }
14327 }
14328
14329 func BenchmarkOtherExtenableSize(b *testing.B) {
14330 popr := math_rand.New(math_rand.NewSource(616))
14331 total := 0
14332 pops := make([]*OtherExtenable, 1000)
14333 for i := 0; i < 1000; i++ {
14334 pops[i] = NewPopulatedOtherExtenable(popr, false)
14335 }
14336 b.ResetTimer()
14337 for i := 0; i < b.N; i++ {
14338 total += pops[i%1000].Size()
14339 }
14340 b.SetBytes(int64(total / b.N))
14341 }
14342
14343 func TestNestedDefinitionSize(t *testing.T) {
14344 seed := time.Now().UnixNano()
14345 popr := math_rand.New(math_rand.NewSource(seed))
14346 p := NewPopulatedNestedDefinition(popr, true)
14347 size2 := github_com_gogo_protobuf_proto.Size(p)
14348 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14349 if err != nil {
14350 t.Fatalf("seed = %d, err = %v", seed, err)
14351 }
14352 size := p.Size()
14353 if len(dAtA) != size {
14354 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14355 }
14356 if size2 != size {
14357 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14358 }
14359 size3 := github_com_gogo_protobuf_proto.Size(p)
14360 if size3 != size {
14361 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14362 }
14363 }
14364
14365 func BenchmarkNestedDefinitionSize(b *testing.B) {
14366 popr := math_rand.New(math_rand.NewSource(616))
14367 total := 0
14368 pops := make([]*NestedDefinition, 1000)
14369 for i := 0; i < 1000; i++ {
14370 pops[i] = NewPopulatedNestedDefinition(popr, false)
14371 }
14372 b.ResetTimer()
14373 for i := 0; i < b.N; i++ {
14374 total += pops[i%1000].Size()
14375 }
14376 b.SetBytes(int64(total / b.N))
14377 }
14378
14379 func TestNestedDefinition_NestedMessageSize(t *testing.T) {
14380 seed := time.Now().UnixNano()
14381 popr := math_rand.New(math_rand.NewSource(seed))
14382 p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
14383 size2 := github_com_gogo_protobuf_proto.Size(p)
14384 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14385 if err != nil {
14386 t.Fatalf("seed = %d, err = %v", seed, err)
14387 }
14388 size := p.Size()
14389 if len(dAtA) != size {
14390 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14391 }
14392 if size2 != size {
14393 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14394 }
14395 size3 := github_com_gogo_protobuf_proto.Size(p)
14396 if size3 != size {
14397 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14398 }
14399 }
14400
14401 func BenchmarkNestedDefinition_NestedMessageSize(b *testing.B) {
14402 popr := math_rand.New(math_rand.NewSource(616))
14403 total := 0
14404 pops := make([]*NestedDefinition_NestedMessage, 1000)
14405 for i := 0; i < 1000; i++ {
14406 pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false)
14407 }
14408 b.ResetTimer()
14409 for i := 0; i < b.N; i++ {
14410 total += pops[i%1000].Size()
14411 }
14412 b.SetBytes(int64(total / b.N))
14413 }
14414
14415 func TestNestedDefinition_NestedMessage_NestedNestedMsgSize(t *testing.T) {
14416 seed := time.Now().UnixNano()
14417 popr := math_rand.New(math_rand.NewSource(seed))
14418 p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
14419 size2 := github_com_gogo_protobuf_proto.Size(p)
14420 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14421 if err != nil {
14422 t.Fatalf("seed = %d, err = %v", seed, err)
14423 }
14424 size := p.Size()
14425 if len(dAtA) != size {
14426 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14427 }
14428 if size2 != size {
14429 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14430 }
14431 size3 := github_com_gogo_protobuf_proto.Size(p)
14432 if size3 != size {
14433 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14434 }
14435 }
14436
14437 func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgSize(b *testing.B) {
14438 popr := math_rand.New(math_rand.NewSource(616))
14439 total := 0
14440 pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 1000)
14441 for i := 0; i < 1000; i++ {
14442 pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
14443 }
14444 b.ResetTimer()
14445 for i := 0; i < b.N; i++ {
14446 total += pops[i%1000].Size()
14447 }
14448 b.SetBytes(int64(total / b.N))
14449 }
14450
14451 func TestNestedScopeSize(t *testing.T) {
14452 seed := time.Now().UnixNano()
14453 popr := math_rand.New(math_rand.NewSource(seed))
14454 p := NewPopulatedNestedScope(popr, true)
14455 size2 := github_com_gogo_protobuf_proto.Size(p)
14456 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14457 if err != nil {
14458 t.Fatalf("seed = %d, err = %v", seed, err)
14459 }
14460 size := p.Size()
14461 if len(dAtA) != size {
14462 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14463 }
14464 if size2 != size {
14465 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14466 }
14467 size3 := github_com_gogo_protobuf_proto.Size(p)
14468 if size3 != size {
14469 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14470 }
14471 }
14472
14473 func BenchmarkNestedScopeSize(b *testing.B) {
14474 popr := math_rand.New(math_rand.NewSource(616))
14475 total := 0
14476 pops := make([]*NestedScope, 1000)
14477 for i := 0; i < 1000; i++ {
14478 pops[i] = NewPopulatedNestedScope(popr, false)
14479 }
14480 b.ResetTimer()
14481 for i := 0; i < b.N; i++ {
14482 total += pops[i%1000].Size()
14483 }
14484 b.SetBytes(int64(total / b.N))
14485 }
14486
14487 func TestNinOptNativeDefaultSize(t *testing.T) {
14488 seed := time.Now().UnixNano()
14489 popr := math_rand.New(math_rand.NewSource(seed))
14490 p := NewPopulatedNinOptNativeDefault(popr, true)
14491 size2 := github_com_gogo_protobuf_proto.Size(p)
14492 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14493 if err != nil {
14494 t.Fatalf("seed = %d, err = %v", seed, err)
14495 }
14496 size := p.Size()
14497 if len(dAtA) != size {
14498 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14499 }
14500 if size2 != size {
14501 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14502 }
14503 size3 := github_com_gogo_protobuf_proto.Size(p)
14504 if size3 != size {
14505 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14506 }
14507 }
14508
14509 func BenchmarkNinOptNativeDefaultSize(b *testing.B) {
14510 popr := math_rand.New(math_rand.NewSource(616))
14511 total := 0
14512 pops := make([]*NinOptNativeDefault, 1000)
14513 for i := 0; i < 1000; i++ {
14514 pops[i] = NewPopulatedNinOptNativeDefault(popr, false)
14515 }
14516 b.ResetTimer()
14517 for i := 0; i < b.N; i++ {
14518 total += pops[i%1000].Size()
14519 }
14520 b.SetBytes(int64(total / b.N))
14521 }
14522
14523 func TestCustomContainerSize(t *testing.T) {
14524 seed := time.Now().UnixNano()
14525 popr := math_rand.New(math_rand.NewSource(seed))
14526 p := NewPopulatedCustomContainer(popr, true)
14527 size2 := github_com_gogo_protobuf_proto.Size(p)
14528 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14529 if err != nil {
14530 t.Fatalf("seed = %d, err = %v", seed, err)
14531 }
14532 size := p.Size()
14533 if len(dAtA) != size {
14534 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14535 }
14536 if size2 != size {
14537 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14538 }
14539 size3 := github_com_gogo_protobuf_proto.Size(p)
14540 if size3 != size {
14541 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14542 }
14543 }
14544
14545 func BenchmarkCustomContainerSize(b *testing.B) {
14546 popr := math_rand.New(math_rand.NewSource(616))
14547 total := 0
14548 pops := make([]*CustomContainer, 1000)
14549 for i := 0; i < 1000; i++ {
14550 pops[i] = NewPopulatedCustomContainer(popr, false)
14551 }
14552 b.ResetTimer()
14553 for i := 0; i < b.N; i++ {
14554 total += pops[i%1000].Size()
14555 }
14556 b.SetBytes(int64(total / b.N))
14557 }
14558
14559 func TestCustomNameNidOptNativeSize(t *testing.T) {
14560 seed := time.Now().UnixNano()
14561 popr := math_rand.New(math_rand.NewSource(seed))
14562 p := NewPopulatedCustomNameNidOptNative(popr, true)
14563 size2 := github_com_gogo_protobuf_proto.Size(p)
14564 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14565 if err != nil {
14566 t.Fatalf("seed = %d, err = %v", seed, err)
14567 }
14568 size := p.Size()
14569 if len(dAtA) != size {
14570 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14571 }
14572 if size2 != size {
14573 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14574 }
14575 size3 := github_com_gogo_protobuf_proto.Size(p)
14576 if size3 != size {
14577 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14578 }
14579 }
14580
14581 func BenchmarkCustomNameNidOptNativeSize(b *testing.B) {
14582 popr := math_rand.New(math_rand.NewSource(616))
14583 total := 0
14584 pops := make([]*CustomNameNidOptNative, 1000)
14585 for i := 0; i < 1000; i++ {
14586 pops[i] = NewPopulatedCustomNameNidOptNative(popr, false)
14587 }
14588 b.ResetTimer()
14589 for i := 0; i < b.N; i++ {
14590 total += pops[i%1000].Size()
14591 }
14592 b.SetBytes(int64(total / b.N))
14593 }
14594
14595 func TestCustomNameNinOptNativeSize(t *testing.T) {
14596 seed := time.Now().UnixNano()
14597 popr := math_rand.New(math_rand.NewSource(seed))
14598 p := NewPopulatedCustomNameNinOptNative(popr, true)
14599 size2 := github_com_gogo_protobuf_proto.Size(p)
14600 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14601 if err != nil {
14602 t.Fatalf("seed = %d, err = %v", seed, err)
14603 }
14604 size := p.Size()
14605 if len(dAtA) != size {
14606 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14607 }
14608 if size2 != size {
14609 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14610 }
14611 size3 := github_com_gogo_protobuf_proto.Size(p)
14612 if size3 != size {
14613 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14614 }
14615 }
14616
14617 func BenchmarkCustomNameNinOptNativeSize(b *testing.B) {
14618 popr := math_rand.New(math_rand.NewSource(616))
14619 total := 0
14620 pops := make([]*CustomNameNinOptNative, 1000)
14621 for i := 0; i < 1000; i++ {
14622 pops[i] = NewPopulatedCustomNameNinOptNative(popr, false)
14623 }
14624 b.ResetTimer()
14625 for i := 0; i < b.N; i++ {
14626 total += pops[i%1000].Size()
14627 }
14628 b.SetBytes(int64(total / b.N))
14629 }
14630
14631 func TestCustomNameNinRepNativeSize(t *testing.T) {
14632 seed := time.Now().UnixNano()
14633 popr := math_rand.New(math_rand.NewSource(seed))
14634 p := NewPopulatedCustomNameNinRepNative(popr, true)
14635 size2 := github_com_gogo_protobuf_proto.Size(p)
14636 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14637 if err != nil {
14638 t.Fatalf("seed = %d, err = %v", seed, err)
14639 }
14640 size := p.Size()
14641 if len(dAtA) != size {
14642 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14643 }
14644 if size2 != size {
14645 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14646 }
14647 size3 := github_com_gogo_protobuf_proto.Size(p)
14648 if size3 != size {
14649 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14650 }
14651 }
14652
14653 func BenchmarkCustomNameNinRepNativeSize(b *testing.B) {
14654 popr := math_rand.New(math_rand.NewSource(616))
14655 total := 0
14656 pops := make([]*CustomNameNinRepNative, 1000)
14657 for i := 0; i < 1000; i++ {
14658 pops[i] = NewPopulatedCustomNameNinRepNative(popr, false)
14659 }
14660 b.ResetTimer()
14661 for i := 0; i < b.N; i++ {
14662 total += pops[i%1000].Size()
14663 }
14664 b.SetBytes(int64(total / b.N))
14665 }
14666
14667 func TestCustomNameNinStructSize(t *testing.T) {
14668 seed := time.Now().UnixNano()
14669 popr := math_rand.New(math_rand.NewSource(seed))
14670 p := NewPopulatedCustomNameNinStruct(popr, true)
14671 size2 := github_com_gogo_protobuf_proto.Size(p)
14672 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14673 if err != nil {
14674 t.Fatalf("seed = %d, err = %v", seed, err)
14675 }
14676 size := p.Size()
14677 if len(dAtA) != size {
14678 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14679 }
14680 if size2 != size {
14681 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14682 }
14683 size3 := github_com_gogo_protobuf_proto.Size(p)
14684 if size3 != size {
14685 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14686 }
14687 }
14688
14689 func BenchmarkCustomNameNinStructSize(b *testing.B) {
14690 popr := math_rand.New(math_rand.NewSource(616))
14691 total := 0
14692 pops := make([]*CustomNameNinStruct, 1000)
14693 for i := 0; i < 1000; i++ {
14694 pops[i] = NewPopulatedCustomNameNinStruct(popr, false)
14695 }
14696 b.ResetTimer()
14697 for i := 0; i < b.N; i++ {
14698 total += pops[i%1000].Size()
14699 }
14700 b.SetBytes(int64(total / b.N))
14701 }
14702
14703 func TestCustomNameCustomTypeSize(t *testing.T) {
14704 seed := time.Now().UnixNano()
14705 popr := math_rand.New(math_rand.NewSource(seed))
14706 p := NewPopulatedCustomNameCustomType(popr, true)
14707 size2 := github_com_gogo_protobuf_proto.Size(p)
14708 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14709 if err != nil {
14710 t.Fatalf("seed = %d, err = %v", seed, err)
14711 }
14712 size := p.Size()
14713 if len(dAtA) != size {
14714 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14715 }
14716 if size2 != size {
14717 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14718 }
14719 size3 := github_com_gogo_protobuf_proto.Size(p)
14720 if size3 != size {
14721 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14722 }
14723 }
14724
14725 func BenchmarkCustomNameCustomTypeSize(b *testing.B) {
14726 popr := math_rand.New(math_rand.NewSource(616))
14727 total := 0
14728 pops := make([]*CustomNameCustomType, 1000)
14729 for i := 0; i < 1000; i++ {
14730 pops[i] = NewPopulatedCustomNameCustomType(popr, false)
14731 }
14732 b.ResetTimer()
14733 for i := 0; i < b.N; i++ {
14734 total += pops[i%1000].Size()
14735 }
14736 b.SetBytes(int64(total / b.N))
14737 }
14738
14739 func TestCustomNameNinEmbeddedStructUnionSize(t *testing.T) {
14740 seed := time.Now().UnixNano()
14741 popr := math_rand.New(math_rand.NewSource(seed))
14742 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
14743 size2 := github_com_gogo_protobuf_proto.Size(p)
14744 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14745 if err != nil {
14746 t.Fatalf("seed = %d, err = %v", seed, err)
14747 }
14748 size := p.Size()
14749 if len(dAtA) != size {
14750 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14751 }
14752 if size2 != size {
14753 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14754 }
14755 size3 := github_com_gogo_protobuf_proto.Size(p)
14756 if size3 != size {
14757 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14758 }
14759 }
14760
14761 func BenchmarkCustomNameNinEmbeddedStructUnionSize(b *testing.B) {
14762 popr := math_rand.New(math_rand.NewSource(616))
14763 total := 0
14764 pops := make([]*CustomNameNinEmbeddedStructUnion, 1000)
14765 for i := 0; i < 1000; i++ {
14766 pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
14767 }
14768 b.ResetTimer()
14769 for i := 0; i < b.N; i++ {
14770 total += pops[i%1000].Size()
14771 }
14772 b.SetBytes(int64(total / b.N))
14773 }
14774
14775 func TestCustomNameEnumSize(t *testing.T) {
14776 seed := time.Now().UnixNano()
14777 popr := math_rand.New(math_rand.NewSource(seed))
14778 p := NewPopulatedCustomNameEnum(popr, true)
14779 size2 := github_com_gogo_protobuf_proto.Size(p)
14780 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14781 if err != nil {
14782 t.Fatalf("seed = %d, err = %v", seed, err)
14783 }
14784 size := p.Size()
14785 if len(dAtA) != size {
14786 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14787 }
14788 if size2 != size {
14789 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14790 }
14791 size3 := github_com_gogo_protobuf_proto.Size(p)
14792 if size3 != size {
14793 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14794 }
14795 }
14796
14797 func BenchmarkCustomNameEnumSize(b *testing.B) {
14798 popr := math_rand.New(math_rand.NewSource(616))
14799 total := 0
14800 pops := make([]*CustomNameEnum, 1000)
14801 for i := 0; i < 1000; i++ {
14802 pops[i] = NewPopulatedCustomNameEnum(popr, false)
14803 }
14804 b.ResetTimer()
14805 for i := 0; i < b.N; i++ {
14806 total += pops[i%1000].Size()
14807 }
14808 b.SetBytes(int64(total / b.N))
14809 }
14810
14811 func TestNoExtensionsMapSize(t *testing.T) {
14812 seed := time.Now().UnixNano()
14813 popr := math_rand.New(math_rand.NewSource(seed))
14814 p := NewPopulatedNoExtensionsMap(popr, true)
14815 size2 := github_com_gogo_protobuf_proto.Size(p)
14816 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14817 if err != nil {
14818 t.Fatalf("seed = %d, err = %v", seed, err)
14819 }
14820 size := p.Size()
14821 if len(dAtA) != size {
14822 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14823 }
14824 if size2 != size {
14825 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14826 }
14827 size3 := github_com_gogo_protobuf_proto.Size(p)
14828 if size3 != size {
14829 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14830 }
14831 }
14832
14833 func BenchmarkNoExtensionsMapSize(b *testing.B) {
14834 popr := math_rand.New(math_rand.NewSource(616))
14835 total := 0
14836 pops := make([]*NoExtensionsMap, 1000)
14837 for i := 0; i < 1000; i++ {
14838 pops[i] = NewPopulatedNoExtensionsMap(popr, false)
14839 }
14840 b.ResetTimer()
14841 for i := 0; i < b.N; i++ {
14842 total += pops[i%1000].Size()
14843 }
14844 b.SetBytes(int64(total / b.N))
14845 }
14846
14847 func TestUnrecognizedSize(t *testing.T) {
14848 seed := time.Now().UnixNano()
14849 popr := math_rand.New(math_rand.NewSource(seed))
14850 p := NewPopulatedUnrecognized(popr, true)
14851 size2 := github_com_gogo_protobuf_proto.Size(p)
14852 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14853 if err != nil {
14854 t.Fatalf("seed = %d, err = %v", seed, err)
14855 }
14856 size := p.Size()
14857 if len(dAtA) != size {
14858 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14859 }
14860 if size2 != size {
14861 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14862 }
14863 size3 := github_com_gogo_protobuf_proto.Size(p)
14864 if size3 != size {
14865 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14866 }
14867 }
14868
14869 func BenchmarkUnrecognizedSize(b *testing.B) {
14870 popr := math_rand.New(math_rand.NewSource(616))
14871 total := 0
14872 pops := make([]*Unrecognized, 1000)
14873 for i := 0; i < 1000; i++ {
14874 pops[i] = NewPopulatedUnrecognized(popr, false)
14875 }
14876 b.ResetTimer()
14877 for i := 0; i < b.N; i++ {
14878 total += pops[i%1000].Size()
14879 }
14880 b.SetBytes(int64(total / b.N))
14881 }
14882
14883 func TestUnrecognizedWithInnerSize(t *testing.T) {
14884 seed := time.Now().UnixNano()
14885 popr := math_rand.New(math_rand.NewSource(seed))
14886 p := NewPopulatedUnrecognizedWithInner(popr, true)
14887 size2 := github_com_gogo_protobuf_proto.Size(p)
14888 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14889 if err != nil {
14890 t.Fatalf("seed = %d, err = %v", seed, err)
14891 }
14892 size := p.Size()
14893 if len(dAtA) != size {
14894 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14895 }
14896 if size2 != size {
14897 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14898 }
14899 size3 := github_com_gogo_protobuf_proto.Size(p)
14900 if size3 != size {
14901 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14902 }
14903 }
14904
14905 func BenchmarkUnrecognizedWithInnerSize(b *testing.B) {
14906 popr := math_rand.New(math_rand.NewSource(616))
14907 total := 0
14908 pops := make([]*UnrecognizedWithInner, 1000)
14909 for i := 0; i < 1000; i++ {
14910 pops[i] = NewPopulatedUnrecognizedWithInner(popr, false)
14911 }
14912 b.ResetTimer()
14913 for i := 0; i < b.N; i++ {
14914 total += pops[i%1000].Size()
14915 }
14916 b.SetBytes(int64(total / b.N))
14917 }
14918
14919 func TestUnrecognizedWithInner_InnerSize(t *testing.T) {
14920 seed := time.Now().UnixNano()
14921 popr := math_rand.New(math_rand.NewSource(seed))
14922 p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
14923 size2 := github_com_gogo_protobuf_proto.Size(p)
14924 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14925 if err != nil {
14926 t.Fatalf("seed = %d, err = %v", seed, err)
14927 }
14928 size := p.Size()
14929 if len(dAtA) != size {
14930 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14931 }
14932 if size2 != size {
14933 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14934 }
14935 size3 := github_com_gogo_protobuf_proto.Size(p)
14936 if size3 != size {
14937 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14938 }
14939 }
14940
14941 func BenchmarkUnrecognizedWithInner_InnerSize(b *testing.B) {
14942 popr := math_rand.New(math_rand.NewSource(616))
14943 total := 0
14944 pops := make([]*UnrecognizedWithInner_Inner, 1000)
14945 for i := 0; i < 1000; i++ {
14946 pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false)
14947 }
14948 b.ResetTimer()
14949 for i := 0; i < b.N; i++ {
14950 total += pops[i%1000].Size()
14951 }
14952 b.SetBytes(int64(total / b.N))
14953 }
14954
14955 func TestUnrecognizedWithEmbedSize(t *testing.T) {
14956 seed := time.Now().UnixNano()
14957 popr := math_rand.New(math_rand.NewSource(seed))
14958 p := NewPopulatedUnrecognizedWithEmbed(popr, true)
14959 size2 := github_com_gogo_protobuf_proto.Size(p)
14960 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14961 if err != nil {
14962 t.Fatalf("seed = %d, err = %v", seed, err)
14963 }
14964 size := p.Size()
14965 if len(dAtA) != size {
14966 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
14967 }
14968 if size2 != size {
14969 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
14970 }
14971 size3 := github_com_gogo_protobuf_proto.Size(p)
14972 if size3 != size {
14973 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
14974 }
14975 }
14976
14977 func BenchmarkUnrecognizedWithEmbedSize(b *testing.B) {
14978 popr := math_rand.New(math_rand.NewSource(616))
14979 total := 0
14980 pops := make([]*UnrecognizedWithEmbed, 1000)
14981 for i := 0; i < 1000; i++ {
14982 pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false)
14983 }
14984 b.ResetTimer()
14985 for i := 0; i < b.N; i++ {
14986 total += pops[i%1000].Size()
14987 }
14988 b.SetBytes(int64(total / b.N))
14989 }
14990
14991 func TestUnrecognizedWithEmbed_EmbeddedSize(t *testing.T) {
14992 seed := time.Now().UnixNano()
14993 popr := math_rand.New(math_rand.NewSource(seed))
14994 p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
14995 size2 := github_com_gogo_protobuf_proto.Size(p)
14996 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
14997 if err != nil {
14998 t.Fatalf("seed = %d, err = %v", seed, err)
14999 }
15000 size := p.Size()
15001 if len(dAtA) != size {
15002 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
15003 }
15004 if size2 != size {
15005 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
15006 }
15007 size3 := github_com_gogo_protobuf_proto.Size(p)
15008 if size3 != size {
15009 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
15010 }
15011 }
15012
15013 func BenchmarkUnrecognizedWithEmbed_EmbeddedSize(b *testing.B) {
15014 popr := math_rand.New(math_rand.NewSource(616))
15015 total := 0
15016 pops := make([]*UnrecognizedWithEmbed_Embedded, 1000)
15017 for i := 0; i < 1000; i++ {
15018 pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
15019 }
15020 b.ResetTimer()
15021 for i := 0; i < b.N; i++ {
15022 total += pops[i%1000].Size()
15023 }
15024 b.SetBytes(int64(total / b.N))
15025 }
15026
15027 func TestNodeSize(t *testing.T) {
15028 seed := time.Now().UnixNano()
15029 popr := math_rand.New(math_rand.NewSource(seed))
15030 p := NewPopulatedNode(popr, true)
15031 size2 := github_com_gogo_protobuf_proto.Size(p)
15032 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
15033 if err != nil {
15034 t.Fatalf("seed = %d, err = %v", seed, err)
15035 }
15036 size := p.Size()
15037 if len(dAtA) != size {
15038 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
15039 }
15040 if size2 != size {
15041 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
15042 }
15043 size3 := github_com_gogo_protobuf_proto.Size(p)
15044 if size3 != size {
15045 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
15046 }
15047 }
15048
15049 func BenchmarkNodeSize(b *testing.B) {
15050 popr := math_rand.New(math_rand.NewSource(616))
15051 total := 0
15052 pops := make([]*Node, 1000)
15053 for i := 0; i < 1000; i++ {
15054 pops[i] = NewPopulatedNode(popr, false)
15055 }
15056 b.ResetTimer()
15057 for i := 0; i < b.N; i++ {
15058 total += pops[i%1000].Size()
15059 }
15060 b.SetBytes(int64(total / b.N))
15061 }
15062
15063 func TestNonByteCustomTypeSize(t *testing.T) {
15064 seed := time.Now().UnixNano()
15065 popr := math_rand.New(math_rand.NewSource(seed))
15066 p := NewPopulatedNonByteCustomType(popr, true)
15067 size2 := github_com_gogo_protobuf_proto.Size(p)
15068 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
15069 if err != nil {
15070 t.Fatalf("seed = %d, err = %v", seed, err)
15071 }
15072 size := p.Size()
15073 if len(dAtA) != size {
15074 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
15075 }
15076 if size2 != size {
15077 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
15078 }
15079 size3 := github_com_gogo_protobuf_proto.Size(p)
15080 if size3 != size {
15081 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
15082 }
15083 }
15084
15085 func BenchmarkNonByteCustomTypeSize(b *testing.B) {
15086 popr := math_rand.New(math_rand.NewSource(616))
15087 total := 0
15088 pops := make([]*NonByteCustomType, 1000)
15089 for i := 0; i < 1000; i++ {
15090 pops[i] = NewPopulatedNonByteCustomType(popr, false)
15091 }
15092 b.ResetTimer()
15093 for i := 0; i < b.N; i++ {
15094 total += pops[i%1000].Size()
15095 }
15096 b.SetBytes(int64(total / b.N))
15097 }
15098
15099 func TestNidOptNonByteCustomTypeSize(t *testing.T) {
15100 seed := time.Now().UnixNano()
15101 popr := math_rand.New(math_rand.NewSource(seed))
15102 p := NewPopulatedNidOptNonByteCustomType(popr, true)
15103 size2 := github_com_gogo_protobuf_proto.Size(p)
15104 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
15105 if err != nil {
15106 t.Fatalf("seed = %d, err = %v", seed, err)
15107 }
15108 size := p.Size()
15109 if len(dAtA) != size {
15110 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
15111 }
15112 if size2 != size {
15113 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
15114 }
15115 size3 := github_com_gogo_protobuf_proto.Size(p)
15116 if size3 != size {
15117 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
15118 }
15119 }
15120
15121 func BenchmarkNidOptNonByteCustomTypeSize(b *testing.B) {
15122 popr := math_rand.New(math_rand.NewSource(616))
15123 total := 0
15124 pops := make([]*NidOptNonByteCustomType, 1000)
15125 for i := 0; i < 1000; i++ {
15126 pops[i] = NewPopulatedNidOptNonByteCustomType(popr, false)
15127 }
15128 b.ResetTimer()
15129 for i := 0; i < b.N; i++ {
15130 total += pops[i%1000].Size()
15131 }
15132 b.SetBytes(int64(total / b.N))
15133 }
15134
15135 func TestNinOptNonByteCustomTypeSize(t *testing.T) {
15136 seed := time.Now().UnixNano()
15137 popr := math_rand.New(math_rand.NewSource(seed))
15138 p := NewPopulatedNinOptNonByteCustomType(popr, true)
15139 size2 := github_com_gogo_protobuf_proto.Size(p)
15140 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
15141 if err != nil {
15142 t.Fatalf("seed = %d, err = %v", seed, err)
15143 }
15144 size := p.Size()
15145 if len(dAtA) != size {
15146 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
15147 }
15148 if size2 != size {
15149 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
15150 }
15151 size3 := github_com_gogo_protobuf_proto.Size(p)
15152 if size3 != size {
15153 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
15154 }
15155 }
15156
15157 func BenchmarkNinOptNonByteCustomTypeSize(b *testing.B) {
15158 popr := math_rand.New(math_rand.NewSource(616))
15159 total := 0
15160 pops := make([]*NinOptNonByteCustomType, 1000)
15161 for i := 0; i < 1000; i++ {
15162 pops[i] = NewPopulatedNinOptNonByteCustomType(popr, false)
15163 }
15164 b.ResetTimer()
15165 for i := 0; i < b.N; i++ {
15166 total += pops[i%1000].Size()
15167 }
15168 b.SetBytes(int64(total / b.N))
15169 }
15170
15171 func TestNidRepNonByteCustomTypeSize(t *testing.T) {
15172 seed := time.Now().UnixNano()
15173 popr := math_rand.New(math_rand.NewSource(seed))
15174 p := NewPopulatedNidRepNonByteCustomType(popr, true)
15175 size2 := github_com_gogo_protobuf_proto.Size(p)
15176 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
15177 if err != nil {
15178 t.Fatalf("seed = %d, err = %v", seed, err)
15179 }
15180 size := p.Size()
15181 if len(dAtA) != size {
15182 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
15183 }
15184 if size2 != size {
15185 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
15186 }
15187 size3 := github_com_gogo_protobuf_proto.Size(p)
15188 if size3 != size {
15189 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
15190 }
15191 }
15192
15193 func BenchmarkNidRepNonByteCustomTypeSize(b *testing.B) {
15194 popr := math_rand.New(math_rand.NewSource(616))
15195 total := 0
15196 pops := make([]*NidRepNonByteCustomType, 1000)
15197 for i := 0; i < 1000; i++ {
15198 pops[i] = NewPopulatedNidRepNonByteCustomType(popr, false)
15199 }
15200 b.ResetTimer()
15201 for i := 0; i < b.N; i++ {
15202 total += pops[i%1000].Size()
15203 }
15204 b.SetBytes(int64(total / b.N))
15205 }
15206
15207 func TestNinRepNonByteCustomTypeSize(t *testing.T) {
15208 seed := time.Now().UnixNano()
15209 popr := math_rand.New(math_rand.NewSource(seed))
15210 p := NewPopulatedNinRepNonByteCustomType(popr, true)
15211 size2 := github_com_gogo_protobuf_proto.Size(p)
15212 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
15213 if err != nil {
15214 t.Fatalf("seed = %d, err = %v", seed, err)
15215 }
15216 size := p.Size()
15217 if len(dAtA) != size {
15218 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
15219 }
15220 if size2 != size {
15221 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
15222 }
15223 size3 := github_com_gogo_protobuf_proto.Size(p)
15224 if size3 != size {
15225 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
15226 }
15227 }
15228
15229 func BenchmarkNinRepNonByteCustomTypeSize(b *testing.B) {
15230 popr := math_rand.New(math_rand.NewSource(616))
15231 total := 0
15232 pops := make([]*NinRepNonByteCustomType, 1000)
15233 for i := 0; i < 1000; i++ {
15234 pops[i] = NewPopulatedNinRepNonByteCustomType(popr, false)
15235 }
15236 b.ResetTimer()
15237 for i := 0; i < b.N; i++ {
15238 total += pops[i%1000].Size()
15239 }
15240 b.SetBytes(int64(total / b.N))
15241 }
15242
15243 func TestProtoTypeSize(t *testing.T) {
15244 seed := time.Now().UnixNano()
15245 popr := math_rand.New(math_rand.NewSource(seed))
15246 p := NewPopulatedProtoType(popr, true)
15247 size2 := github_com_gogo_protobuf_proto.Size(p)
15248 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
15249 if err != nil {
15250 t.Fatalf("seed = %d, err = %v", seed, err)
15251 }
15252 size := p.Size()
15253 if len(dAtA) != size {
15254 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
15255 }
15256 if size2 != size {
15257 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
15258 }
15259 size3 := github_com_gogo_protobuf_proto.Size(p)
15260 if size3 != size {
15261 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
15262 }
15263 }
15264
15265 func BenchmarkProtoTypeSize(b *testing.B) {
15266 popr := math_rand.New(math_rand.NewSource(616))
15267 total := 0
15268 pops := make([]*ProtoType, 1000)
15269 for i := 0; i < 1000; i++ {
15270 pops[i] = NewPopulatedProtoType(popr, false)
15271 }
15272 b.ResetTimer()
15273 for i := 0; i < b.N; i++ {
15274 total += pops[i%1000].Size()
15275 }
15276 b.SetBytes(int64(total / b.N))
15277 }
15278
15279 func TestNidOptNativeStringer(t *testing.T) {
15280 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15281 p := NewPopulatedNidOptNative(popr, false)
15282 s1 := p.String()
15283 s2 := fmt.Sprintf("%v", p)
15284 if s1 != s2 {
15285 t.Fatalf("String want %v got %v", s1, s2)
15286 }
15287 }
15288 func TestNinOptNativeStringer(t *testing.T) {
15289 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15290 p := NewPopulatedNinOptNative(popr, false)
15291 s1 := p.String()
15292 s2 := fmt.Sprintf("%v", p)
15293 if s1 != s2 {
15294 t.Fatalf("String want %v got %v", s1, s2)
15295 }
15296 }
15297 func TestNidRepNativeStringer(t *testing.T) {
15298 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15299 p := NewPopulatedNidRepNative(popr, false)
15300 s1 := p.String()
15301 s2 := fmt.Sprintf("%v", p)
15302 if s1 != s2 {
15303 t.Fatalf("String want %v got %v", s1, s2)
15304 }
15305 }
15306 func TestNinRepNativeStringer(t *testing.T) {
15307 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15308 p := NewPopulatedNinRepNative(popr, false)
15309 s1 := p.String()
15310 s2 := fmt.Sprintf("%v", p)
15311 if s1 != s2 {
15312 t.Fatalf("String want %v got %v", s1, s2)
15313 }
15314 }
15315 func TestNidRepPackedNativeStringer(t *testing.T) {
15316 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15317 p := NewPopulatedNidRepPackedNative(popr, false)
15318 s1 := p.String()
15319 s2 := fmt.Sprintf("%v", p)
15320 if s1 != s2 {
15321 t.Fatalf("String want %v got %v", s1, s2)
15322 }
15323 }
15324 func TestNinRepPackedNativeStringer(t *testing.T) {
15325 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15326 p := NewPopulatedNinRepPackedNative(popr, false)
15327 s1 := p.String()
15328 s2 := fmt.Sprintf("%v", p)
15329 if s1 != s2 {
15330 t.Fatalf("String want %v got %v", s1, s2)
15331 }
15332 }
15333 func TestNidOptStructStringer(t *testing.T) {
15334 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15335 p := NewPopulatedNidOptStruct(popr, false)
15336 s1 := p.String()
15337 s2 := fmt.Sprintf("%v", p)
15338 if s1 != s2 {
15339 t.Fatalf("String want %v got %v", s1, s2)
15340 }
15341 }
15342 func TestNinOptStructStringer(t *testing.T) {
15343 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15344 p := NewPopulatedNinOptStruct(popr, false)
15345 s1 := p.String()
15346 s2 := fmt.Sprintf("%v", p)
15347 if s1 != s2 {
15348 t.Fatalf("String want %v got %v", s1, s2)
15349 }
15350 }
15351 func TestNidRepStructStringer(t *testing.T) {
15352 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15353 p := NewPopulatedNidRepStruct(popr, false)
15354 s1 := p.String()
15355 s2 := fmt.Sprintf("%v", p)
15356 if s1 != s2 {
15357 t.Fatalf("String want %v got %v", s1, s2)
15358 }
15359 }
15360 func TestNinRepStructStringer(t *testing.T) {
15361 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15362 p := NewPopulatedNinRepStruct(popr, false)
15363 s1 := p.String()
15364 s2 := fmt.Sprintf("%v", p)
15365 if s1 != s2 {
15366 t.Fatalf("String want %v got %v", s1, s2)
15367 }
15368 }
15369 func TestNidEmbeddedStructStringer(t *testing.T) {
15370 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15371 p := NewPopulatedNidEmbeddedStruct(popr, false)
15372 s1 := p.String()
15373 s2 := fmt.Sprintf("%v", p)
15374 if s1 != s2 {
15375 t.Fatalf("String want %v got %v", s1, s2)
15376 }
15377 }
15378 func TestNinEmbeddedStructStringer(t *testing.T) {
15379 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15380 p := NewPopulatedNinEmbeddedStruct(popr, false)
15381 s1 := p.String()
15382 s2 := fmt.Sprintf("%v", p)
15383 if s1 != s2 {
15384 t.Fatalf("String want %v got %v", s1, s2)
15385 }
15386 }
15387 func TestNidNestedStructStringer(t *testing.T) {
15388 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15389 p := NewPopulatedNidNestedStruct(popr, false)
15390 s1 := p.String()
15391 s2 := fmt.Sprintf("%v", p)
15392 if s1 != s2 {
15393 t.Fatalf("String want %v got %v", s1, s2)
15394 }
15395 }
15396 func TestNinNestedStructStringer(t *testing.T) {
15397 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15398 p := NewPopulatedNinNestedStruct(popr, false)
15399 s1 := p.String()
15400 s2 := fmt.Sprintf("%v", p)
15401 if s1 != s2 {
15402 t.Fatalf("String want %v got %v", s1, s2)
15403 }
15404 }
15405 func TestNidOptCustomStringer(t *testing.T) {
15406 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15407 p := NewPopulatedNidOptCustom(popr, false)
15408 s1 := p.String()
15409 s2 := fmt.Sprintf("%v", p)
15410 if s1 != s2 {
15411 t.Fatalf("String want %v got %v", s1, s2)
15412 }
15413 }
15414 func TestCustomDashStringer(t *testing.T) {
15415 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15416 p := NewPopulatedCustomDash(popr, false)
15417 s1 := p.String()
15418 s2 := fmt.Sprintf("%v", p)
15419 if s1 != s2 {
15420 t.Fatalf("String want %v got %v", s1, s2)
15421 }
15422 }
15423 func TestNinOptCustomStringer(t *testing.T) {
15424 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15425 p := NewPopulatedNinOptCustom(popr, false)
15426 s1 := p.String()
15427 s2 := fmt.Sprintf("%v", p)
15428 if s1 != s2 {
15429 t.Fatalf("String want %v got %v", s1, s2)
15430 }
15431 }
15432 func TestNidRepCustomStringer(t *testing.T) {
15433 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15434 p := NewPopulatedNidRepCustom(popr, false)
15435 s1 := p.String()
15436 s2 := fmt.Sprintf("%v", p)
15437 if s1 != s2 {
15438 t.Fatalf("String want %v got %v", s1, s2)
15439 }
15440 }
15441 func TestNinRepCustomStringer(t *testing.T) {
15442 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15443 p := NewPopulatedNinRepCustom(popr, false)
15444 s1 := p.String()
15445 s2 := fmt.Sprintf("%v", p)
15446 if s1 != s2 {
15447 t.Fatalf("String want %v got %v", s1, s2)
15448 }
15449 }
15450 func TestNinOptNativeUnionStringer(t *testing.T) {
15451 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15452 p := NewPopulatedNinOptNativeUnion(popr, false)
15453 s1 := p.String()
15454 s2 := fmt.Sprintf("%v", p)
15455 if s1 != s2 {
15456 t.Fatalf("String want %v got %v", s1, s2)
15457 }
15458 }
15459 func TestNinOptStructUnionStringer(t *testing.T) {
15460 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15461 p := NewPopulatedNinOptStructUnion(popr, false)
15462 s1 := p.String()
15463 s2 := fmt.Sprintf("%v", p)
15464 if s1 != s2 {
15465 t.Fatalf("String want %v got %v", s1, s2)
15466 }
15467 }
15468 func TestNinEmbeddedStructUnionStringer(t *testing.T) {
15469 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15470 p := NewPopulatedNinEmbeddedStructUnion(popr, false)
15471 s1 := p.String()
15472 s2 := fmt.Sprintf("%v", p)
15473 if s1 != s2 {
15474 t.Fatalf("String want %v got %v", s1, s2)
15475 }
15476 }
15477 func TestNinNestedStructUnionStringer(t *testing.T) {
15478 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15479 p := NewPopulatedNinNestedStructUnion(popr, false)
15480 s1 := p.String()
15481 s2 := fmt.Sprintf("%v", p)
15482 if s1 != s2 {
15483 t.Fatalf("String want %v got %v", s1, s2)
15484 }
15485 }
15486 func TestTreeStringer(t *testing.T) {
15487 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15488 p := NewPopulatedTree(popr, false)
15489 s1 := p.String()
15490 s2 := fmt.Sprintf("%v", p)
15491 if s1 != s2 {
15492 t.Fatalf("String want %v got %v", s1, s2)
15493 }
15494 }
15495 func TestOrBranchStringer(t *testing.T) {
15496 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15497 p := NewPopulatedOrBranch(popr, false)
15498 s1 := p.String()
15499 s2 := fmt.Sprintf("%v", p)
15500 if s1 != s2 {
15501 t.Fatalf("String want %v got %v", s1, s2)
15502 }
15503 }
15504 func TestAndBranchStringer(t *testing.T) {
15505 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15506 p := NewPopulatedAndBranch(popr, false)
15507 s1 := p.String()
15508 s2 := fmt.Sprintf("%v", p)
15509 if s1 != s2 {
15510 t.Fatalf("String want %v got %v", s1, s2)
15511 }
15512 }
15513 func TestLeafStringer(t *testing.T) {
15514 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15515 p := NewPopulatedLeaf(popr, false)
15516 s1 := p.String()
15517 s2 := fmt.Sprintf("%v", p)
15518 if s1 != s2 {
15519 t.Fatalf("String want %v got %v", s1, s2)
15520 }
15521 }
15522 func TestDeepTreeStringer(t *testing.T) {
15523 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15524 p := NewPopulatedDeepTree(popr, false)
15525 s1 := p.String()
15526 s2 := fmt.Sprintf("%v", p)
15527 if s1 != s2 {
15528 t.Fatalf("String want %v got %v", s1, s2)
15529 }
15530 }
15531 func TestADeepBranchStringer(t *testing.T) {
15532 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15533 p := NewPopulatedADeepBranch(popr, false)
15534 s1 := p.String()
15535 s2 := fmt.Sprintf("%v", p)
15536 if s1 != s2 {
15537 t.Fatalf("String want %v got %v", s1, s2)
15538 }
15539 }
15540 func TestAndDeepBranchStringer(t *testing.T) {
15541 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15542 p := NewPopulatedAndDeepBranch(popr, false)
15543 s1 := p.String()
15544 s2 := fmt.Sprintf("%v", p)
15545 if s1 != s2 {
15546 t.Fatalf("String want %v got %v", s1, s2)
15547 }
15548 }
15549 func TestDeepLeafStringer(t *testing.T) {
15550 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15551 p := NewPopulatedDeepLeaf(popr, false)
15552 s1 := p.String()
15553 s2 := fmt.Sprintf("%v", p)
15554 if s1 != s2 {
15555 t.Fatalf("String want %v got %v", s1, s2)
15556 }
15557 }
15558 func TestNilStringer(t *testing.T) {
15559 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15560 p := NewPopulatedNil(popr, false)
15561 s1 := p.String()
15562 s2 := fmt.Sprintf("%v", p)
15563 if s1 != s2 {
15564 t.Fatalf("String want %v got %v", s1, s2)
15565 }
15566 }
15567 func TestNidOptEnumStringer(t *testing.T) {
15568 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15569 p := NewPopulatedNidOptEnum(popr, false)
15570 s1 := p.String()
15571 s2 := fmt.Sprintf("%v", p)
15572 if s1 != s2 {
15573 t.Fatalf("String want %v got %v", s1, s2)
15574 }
15575 }
15576 func TestNinOptEnumStringer(t *testing.T) {
15577 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15578 p := NewPopulatedNinOptEnum(popr, false)
15579 s1 := p.String()
15580 s2 := fmt.Sprintf("%v", p)
15581 if s1 != s2 {
15582 t.Fatalf("String want %v got %v", s1, s2)
15583 }
15584 }
15585 func TestNidRepEnumStringer(t *testing.T) {
15586 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15587 p := NewPopulatedNidRepEnum(popr, false)
15588 s1 := p.String()
15589 s2 := fmt.Sprintf("%v", p)
15590 if s1 != s2 {
15591 t.Fatalf("String want %v got %v", s1, s2)
15592 }
15593 }
15594 func TestNinRepEnumStringer(t *testing.T) {
15595 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15596 p := NewPopulatedNinRepEnum(popr, false)
15597 s1 := p.String()
15598 s2 := fmt.Sprintf("%v", p)
15599 if s1 != s2 {
15600 t.Fatalf("String want %v got %v", s1, s2)
15601 }
15602 }
15603 func TestNinOptEnumDefaultStringer(t *testing.T) {
15604 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15605 p := NewPopulatedNinOptEnumDefault(popr, false)
15606 s1 := p.String()
15607 s2 := fmt.Sprintf("%v", p)
15608 if s1 != s2 {
15609 t.Fatalf("String want %v got %v", s1, s2)
15610 }
15611 }
15612 func TestAnotherNinOptEnumStringer(t *testing.T) {
15613 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15614 p := NewPopulatedAnotherNinOptEnum(popr, false)
15615 s1 := p.String()
15616 s2 := fmt.Sprintf("%v", p)
15617 if s1 != s2 {
15618 t.Fatalf("String want %v got %v", s1, s2)
15619 }
15620 }
15621 func TestAnotherNinOptEnumDefaultStringer(t *testing.T) {
15622 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15623 p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
15624 s1 := p.String()
15625 s2 := fmt.Sprintf("%v", p)
15626 if s1 != s2 {
15627 t.Fatalf("String want %v got %v", s1, s2)
15628 }
15629 }
15630 func TestTimerStringer(t *testing.T) {
15631 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15632 p := NewPopulatedTimer(popr, false)
15633 s1 := p.String()
15634 s2 := fmt.Sprintf("%v", p)
15635 if s1 != s2 {
15636 t.Fatalf("String want %v got %v", s1, s2)
15637 }
15638 }
15639 func TestMyExtendableStringer(t *testing.T) {
15640 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15641 p := NewPopulatedMyExtendable(popr, false)
15642 s1 := p.String()
15643 s2 := fmt.Sprintf("%v", p)
15644 if s1 != s2 {
15645 t.Fatalf("String want %v got %v", s1, s2)
15646 }
15647 }
15648 func TestOtherExtenableStringer(t *testing.T) {
15649 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15650 p := NewPopulatedOtherExtenable(popr, false)
15651 s1 := p.String()
15652 s2 := fmt.Sprintf("%v", p)
15653 if s1 != s2 {
15654 t.Fatalf("String want %v got %v", s1, s2)
15655 }
15656 }
15657 func TestNestedDefinitionStringer(t *testing.T) {
15658 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15659 p := NewPopulatedNestedDefinition(popr, false)
15660 s1 := p.String()
15661 s2 := fmt.Sprintf("%v", p)
15662 if s1 != s2 {
15663 t.Fatalf("String want %v got %v", s1, s2)
15664 }
15665 }
15666 func TestNestedDefinition_NestedMessageStringer(t *testing.T) {
15667 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15668 p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
15669 s1 := p.String()
15670 s2 := fmt.Sprintf("%v", p)
15671 if s1 != s2 {
15672 t.Fatalf("String want %v got %v", s1, s2)
15673 }
15674 }
15675 func TestNestedDefinition_NestedMessage_NestedNestedMsgStringer(t *testing.T) {
15676 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15677 p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
15678 s1 := p.String()
15679 s2 := fmt.Sprintf("%v", p)
15680 if s1 != s2 {
15681 t.Fatalf("String want %v got %v", s1, s2)
15682 }
15683 }
15684 func TestNestedScopeStringer(t *testing.T) {
15685 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15686 p := NewPopulatedNestedScope(popr, false)
15687 s1 := p.String()
15688 s2 := fmt.Sprintf("%v", p)
15689 if s1 != s2 {
15690 t.Fatalf("String want %v got %v", s1, s2)
15691 }
15692 }
15693 func TestNinOptNativeDefaultStringer(t *testing.T) {
15694 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15695 p := NewPopulatedNinOptNativeDefault(popr, false)
15696 s1 := p.String()
15697 s2 := fmt.Sprintf("%v", p)
15698 if s1 != s2 {
15699 t.Fatalf("String want %v got %v", s1, s2)
15700 }
15701 }
15702 func TestCustomContainerStringer(t *testing.T) {
15703 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15704 p := NewPopulatedCustomContainer(popr, false)
15705 s1 := p.String()
15706 s2 := fmt.Sprintf("%v", p)
15707 if s1 != s2 {
15708 t.Fatalf("String want %v got %v", s1, s2)
15709 }
15710 }
15711 func TestCustomNameNidOptNativeStringer(t *testing.T) {
15712 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15713 p := NewPopulatedCustomNameNidOptNative(popr, false)
15714 s1 := p.String()
15715 s2 := fmt.Sprintf("%v", p)
15716 if s1 != s2 {
15717 t.Fatalf("String want %v got %v", s1, s2)
15718 }
15719 }
15720 func TestCustomNameNinOptNativeStringer(t *testing.T) {
15721 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15722 p := NewPopulatedCustomNameNinOptNative(popr, false)
15723 s1 := p.String()
15724 s2 := fmt.Sprintf("%v", p)
15725 if s1 != s2 {
15726 t.Fatalf("String want %v got %v", s1, s2)
15727 }
15728 }
15729 func TestCustomNameNinRepNativeStringer(t *testing.T) {
15730 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15731 p := NewPopulatedCustomNameNinRepNative(popr, false)
15732 s1 := p.String()
15733 s2 := fmt.Sprintf("%v", p)
15734 if s1 != s2 {
15735 t.Fatalf("String want %v got %v", s1, s2)
15736 }
15737 }
15738 func TestCustomNameNinStructStringer(t *testing.T) {
15739 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15740 p := NewPopulatedCustomNameNinStruct(popr, false)
15741 s1 := p.String()
15742 s2 := fmt.Sprintf("%v", p)
15743 if s1 != s2 {
15744 t.Fatalf("String want %v got %v", s1, s2)
15745 }
15746 }
15747 func TestCustomNameCustomTypeStringer(t *testing.T) {
15748 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15749 p := NewPopulatedCustomNameCustomType(popr, false)
15750 s1 := p.String()
15751 s2 := fmt.Sprintf("%v", p)
15752 if s1 != s2 {
15753 t.Fatalf("String want %v got %v", s1, s2)
15754 }
15755 }
15756 func TestCustomNameNinEmbeddedStructUnionStringer(t *testing.T) {
15757 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15758 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
15759 s1 := p.String()
15760 s2 := fmt.Sprintf("%v", p)
15761 if s1 != s2 {
15762 t.Fatalf("String want %v got %v", s1, s2)
15763 }
15764 }
15765 func TestCustomNameEnumStringer(t *testing.T) {
15766 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15767 p := NewPopulatedCustomNameEnum(popr, false)
15768 s1 := p.String()
15769 s2 := fmt.Sprintf("%v", p)
15770 if s1 != s2 {
15771 t.Fatalf("String want %v got %v", s1, s2)
15772 }
15773 }
15774 func TestNoExtensionsMapStringer(t *testing.T) {
15775 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15776 p := NewPopulatedNoExtensionsMap(popr, false)
15777 s1 := p.String()
15778 s2 := fmt.Sprintf("%v", p)
15779 if s1 != s2 {
15780 t.Fatalf("String want %v got %v", s1, s2)
15781 }
15782 }
15783 func TestUnrecognizedStringer(t *testing.T) {
15784 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15785 p := NewPopulatedUnrecognized(popr, false)
15786 s1 := p.String()
15787 s2 := fmt.Sprintf("%v", p)
15788 if s1 != s2 {
15789 t.Fatalf("String want %v got %v", s1, s2)
15790 }
15791 }
15792 func TestUnrecognizedWithInnerStringer(t *testing.T) {
15793 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15794 p := NewPopulatedUnrecognizedWithInner(popr, false)
15795 s1 := p.String()
15796 s2 := fmt.Sprintf("%v", p)
15797 if s1 != s2 {
15798 t.Fatalf("String want %v got %v", s1, s2)
15799 }
15800 }
15801 func TestUnrecognizedWithInner_InnerStringer(t *testing.T) {
15802 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15803 p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
15804 s1 := p.String()
15805 s2 := fmt.Sprintf("%v", p)
15806 if s1 != s2 {
15807 t.Fatalf("String want %v got %v", s1, s2)
15808 }
15809 }
15810 func TestUnrecognizedWithEmbedStringer(t *testing.T) {
15811 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15812 p := NewPopulatedUnrecognizedWithEmbed(popr, false)
15813 s1 := p.String()
15814 s2 := fmt.Sprintf("%v", p)
15815 if s1 != s2 {
15816 t.Fatalf("String want %v got %v", s1, s2)
15817 }
15818 }
15819 func TestUnrecognizedWithEmbed_EmbeddedStringer(t *testing.T) {
15820 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15821 p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
15822 s1 := p.String()
15823 s2 := fmt.Sprintf("%v", p)
15824 if s1 != s2 {
15825 t.Fatalf("String want %v got %v", s1, s2)
15826 }
15827 }
15828 func TestNodeStringer(t *testing.T) {
15829 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15830 p := NewPopulatedNode(popr, false)
15831 s1 := p.String()
15832 s2 := fmt.Sprintf("%v", p)
15833 if s1 != s2 {
15834 t.Fatalf("String want %v got %v", s1, s2)
15835 }
15836 }
15837 func TestNonByteCustomTypeStringer(t *testing.T) {
15838 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15839 p := NewPopulatedNonByteCustomType(popr, false)
15840 s1 := p.String()
15841 s2 := fmt.Sprintf("%v", p)
15842 if s1 != s2 {
15843 t.Fatalf("String want %v got %v", s1, s2)
15844 }
15845 }
15846 func TestNidOptNonByteCustomTypeStringer(t *testing.T) {
15847 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15848 p := NewPopulatedNidOptNonByteCustomType(popr, false)
15849 s1 := p.String()
15850 s2 := fmt.Sprintf("%v", p)
15851 if s1 != s2 {
15852 t.Fatalf("String want %v got %v", s1, s2)
15853 }
15854 }
15855 func TestNinOptNonByteCustomTypeStringer(t *testing.T) {
15856 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15857 p := NewPopulatedNinOptNonByteCustomType(popr, false)
15858 s1 := p.String()
15859 s2 := fmt.Sprintf("%v", p)
15860 if s1 != s2 {
15861 t.Fatalf("String want %v got %v", s1, s2)
15862 }
15863 }
15864 func TestNidRepNonByteCustomTypeStringer(t *testing.T) {
15865 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15866 p := NewPopulatedNidRepNonByteCustomType(popr, false)
15867 s1 := p.String()
15868 s2 := fmt.Sprintf("%v", p)
15869 if s1 != s2 {
15870 t.Fatalf("String want %v got %v", s1, s2)
15871 }
15872 }
15873 func TestNinRepNonByteCustomTypeStringer(t *testing.T) {
15874 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15875 p := NewPopulatedNinRepNonByteCustomType(popr, false)
15876 s1 := p.String()
15877 s2 := fmt.Sprintf("%v", p)
15878 if s1 != s2 {
15879 t.Fatalf("String want %v got %v", s1, s2)
15880 }
15881 }
15882 func TestProtoTypeStringer(t *testing.T) {
15883 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15884 p := NewPopulatedProtoType(popr, false)
15885 s1 := p.String()
15886 s2 := fmt.Sprintf("%v", p)
15887 if s1 != s2 {
15888 t.Fatalf("String want %v got %v", s1, s2)
15889 }
15890 }
15891 func TestNinOptNativeUnionOnlyOne(t *testing.T) {
15892 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15893 p := NewPopulatedNinOptNativeUnion(popr, true)
15894 v := p.GetValue()
15895 msg := &NinOptNativeUnion{}
15896 if !msg.SetValue(v) {
15897 t.Fatalf("OnlyOne: Could not set Value")
15898 }
15899 if !p.Equal(msg) {
15900 t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
15901 }
15902 }
15903 func TestNinOptStructUnionOnlyOne(t *testing.T) {
15904 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15905 p := NewPopulatedNinOptStructUnion(popr, true)
15906 v := p.GetValue()
15907 msg := &NinOptStructUnion{}
15908 if !msg.SetValue(v) {
15909 t.Fatalf("OnlyOne: Could not set Value")
15910 }
15911 if !p.Equal(msg) {
15912 t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
15913 }
15914 }
15915 func TestNinEmbeddedStructUnionOnlyOne(t *testing.T) {
15916 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15917 p := NewPopulatedNinEmbeddedStructUnion(popr, true)
15918 v := p.GetValue()
15919 msg := &NinEmbeddedStructUnion{}
15920 if !msg.SetValue(v) {
15921 t.Fatalf("OnlyOne: Could not set Value")
15922 }
15923 if !p.Equal(msg) {
15924 t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
15925 }
15926 }
15927 func TestNinNestedStructUnionOnlyOne(t *testing.T) {
15928 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15929 p := NewPopulatedNinNestedStructUnion(popr, true)
15930 v := p.GetValue()
15931 msg := &NinNestedStructUnion{}
15932 if !msg.SetValue(v) {
15933 t.Fatalf("OnlyOne: Could not set Value")
15934 }
15935 if !p.Equal(msg) {
15936 t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
15937 }
15938 }
15939 func TestTreeOnlyOne(t *testing.T) {
15940 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15941 p := NewPopulatedTree(popr, true)
15942 v := p.GetValue()
15943 msg := &Tree{}
15944 if !msg.SetValue(v) {
15945 t.Fatalf("OnlyOne: Could not set Value")
15946 }
15947 if !p.Equal(msg) {
15948 t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
15949 }
15950 }
15951 func TestDeepTreeOnlyOne(t *testing.T) {
15952 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15953 p := NewPopulatedDeepTree(popr, true)
15954 v := p.GetValue()
15955 msg := &DeepTree{}
15956 if !msg.SetValue(v) {
15957 t.Fatalf("OnlyOne: Could not set Value")
15958 }
15959 if !p.Equal(msg) {
15960 t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
15961 }
15962 }
15963 func TestCustomNameNinEmbeddedStructUnionOnlyOne(t *testing.T) {
15964 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
15965 p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
15966 v := p.GetValue()
15967 msg := &CustomNameNinEmbeddedStructUnion{}
15968 if !msg.SetValue(v) {
15969 t.Fatalf("OnlyOne: Could not set Value")
15970 }
15971 if !p.Equal(msg) {
15972 t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
15973 }
15974 }
15975
15976
15977
View as plain text