1
2
3
4 package unrecognized
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 TestAProto(t *testing.T) {
25 seed := time.Now().UnixNano()
26 popr := math_rand.New(math_rand.NewSource(seed))
27 p := NewPopulatedA(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 := &A{}
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 TestAMarshalTo(t *testing.T) {
59 seed := time.Now().UnixNano()
60 popr := math_rand.New(math_rand.NewSource(seed))
61 p := NewPopulatedA(popr, false)
62 size := p.Size()
63 dAtA := make([]byte, size)
64 for i := range dAtA {
65 dAtA[i] = byte(popr.Intn(256))
66 }
67 _, err := p.MarshalTo(dAtA)
68 if err != nil {
69 t.Fatalf("seed = %d, err = %v", seed, err)
70 }
71 msg := &A{}
72 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
73 t.Fatalf("seed = %d, err = %v", seed, err)
74 }
75 for i := range dAtA {
76 dAtA[i] = byte(popr.Intn(256))
77 }
78 if err := p.VerboseEqual(msg); err != nil {
79 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
80 }
81 if !p.Equal(msg) {
82 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
83 }
84 }
85
86 func TestBProto(t *testing.T) {
87 seed := time.Now().UnixNano()
88 popr := math_rand.New(math_rand.NewSource(seed))
89 p := NewPopulatedB(popr, false)
90 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
91 if err != nil {
92 t.Fatalf("seed = %d, err = %v", seed, err)
93 }
94 msg := &B{}
95 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
96 t.Fatalf("seed = %d, err = %v", seed, err)
97 }
98 littlefuzz := make([]byte, len(dAtA))
99 copy(littlefuzz, dAtA)
100 for i := range dAtA {
101 dAtA[i] = byte(popr.Intn(256))
102 }
103 if err := p.VerboseEqual(msg); err != nil {
104 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
105 }
106 if !p.Equal(msg) {
107 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
108 }
109 if len(littlefuzz) > 0 {
110 fuzzamount := 100
111 for i := 0; i < fuzzamount; i++ {
112 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
113 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
114 }
115
116 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
117 }
118 }
119
120 func TestBMarshalTo(t *testing.T) {
121 seed := time.Now().UnixNano()
122 popr := math_rand.New(math_rand.NewSource(seed))
123 p := NewPopulatedB(popr, false)
124 size := p.Size()
125 dAtA := make([]byte, size)
126 for i := range dAtA {
127 dAtA[i] = byte(popr.Intn(256))
128 }
129 _, err := p.MarshalTo(dAtA)
130 if err != nil {
131 t.Fatalf("seed = %d, err = %v", seed, err)
132 }
133 msg := &B{}
134 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
135 t.Fatalf("seed = %d, err = %v", seed, err)
136 }
137 for i := range dAtA {
138 dAtA[i] = byte(popr.Intn(256))
139 }
140 if err := p.VerboseEqual(msg); err != nil {
141 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
142 }
143 if !p.Equal(msg) {
144 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
145 }
146 }
147
148 func TestDProto(t *testing.T) {
149 seed := time.Now().UnixNano()
150 popr := math_rand.New(math_rand.NewSource(seed))
151 p := NewPopulatedD(popr, false)
152 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
153 if err != nil {
154 t.Fatalf("seed = %d, err = %v", seed, err)
155 }
156 msg := &D{}
157 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
158 t.Fatalf("seed = %d, err = %v", seed, err)
159 }
160 littlefuzz := make([]byte, len(dAtA))
161 copy(littlefuzz, dAtA)
162 for i := range dAtA {
163 dAtA[i] = byte(popr.Intn(256))
164 }
165 if err := p.VerboseEqual(msg); err != nil {
166 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
167 }
168 if !p.Equal(msg) {
169 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
170 }
171 if len(littlefuzz) > 0 {
172 fuzzamount := 100
173 for i := 0; i < fuzzamount; i++ {
174 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
175 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
176 }
177
178 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
179 }
180 }
181
182 func TestDMarshalTo(t *testing.T) {
183 seed := time.Now().UnixNano()
184 popr := math_rand.New(math_rand.NewSource(seed))
185 p := NewPopulatedD(popr, false)
186 size := p.Size()
187 dAtA := make([]byte, size)
188 for i := range dAtA {
189 dAtA[i] = byte(popr.Intn(256))
190 }
191 _, err := p.MarshalTo(dAtA)
192 if err != nil {
193 t.Fatalf("seed = %d, err = %v", seed, err)
194 }
195 msg := &D{}
196 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
197 t.Fatalf("seed = %d, err = %v", seed, err)
198 }
199 for i := range dAtA {
200 dAtA[i] = byte(popr.Intn(256))
201 }
202 if err := p.VerboseEqual(msg); err != nil {
203 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
204 }
205 if !p.Equal(msg) {
206 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
207 }
208 }
209
210 func TestCProto(t *testing.T) {
211 seed := time.Now().UnixNano()
212 popr := math_rand.New(math_rand.NewSource(seed))
213 p := NewPopulatedC(popr, false)
214 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
215 if err != nil {
216 t.Fatalf("seed = %d, err = %v", seed, err)
217 }
218 msg := &C{}
219 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
220 t.Fatalf("seed = %d, err = %v", seed, err)
221 }
222 littlefuzz := make([]byte, len(dAtA))
223 copy(littlefuzz, dAtA)
224 for i := range dAtA {
225 dAtA[i] = byte(popr.Intn(256))
226 }
227 if err := p.VerboseEqual(msg); err != nil {
228 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
229 }
230 if !p.Equal(msg) {
231 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
232 }
233 if len(littlefuzz) > 0 {
234 fuzzamount := 100
235 for i := 0; i < fuzzamount; i++ {
236 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
237 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
238 }
239
240 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
241 }
242 }
243
244 func TestCMarshalTo(t *testing.T) {
245 seed := time.Now().UnixNano()
246 popr := math_rand.New(math_rand.NewSource(seed))
247 p := NewPopulatedC(popr, false)
248 size := p.Size()
249 dAtA := make([]byte, size)
250 for i := range dAtA {
251 dAtA[i] = byte(popr.Intn(256))
252 }
253 _, err := p.MarshalTo(dAtA)
254 if err != nil {
255 t.Fatalf("seed = %d, err = %v", seed, err)
256 }
257 msg := &C{}
258 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
259 t.Fatalf("seed = %d, err = %v", seed, err)
260 }
261 for i := range dAtA {
262 dAtA[i] = byte(popr.Intn(256))
263 }
264 if err := p.VerboseEqual(msg); err != nil {
265 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
266 }
267 if !p.Equal(msg) {
268 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
269 }
270 }
271
272 func TestUProto(t *testing.T) {
273 seed := time.Now().UnixNano()
274 popr := math_rand.New(math_rand.NewSource(seed))
275 p := NewPopulatedU(popr, false)
276 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
277 if err != nil {
278 t.Fatalf("seed = %d, err = %v", seed, err)
279 }
280 msg := &U{}
281 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
282 t.Fatalf("seed = %d, err = %v", seed, err)
283 }
284 littlefuzz := make([]byte, len(dAtA))
285 copy(littlefuzz, dAtA)
286 for i := range dAtA {
287 dAtA[i] = byte(popr.Intn(256))
288 }
289 if err := p.VerboseEqual(msg); err != nil {
290 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
291 }
292 if !p.Equal(msg) {
293 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
294 }
295 if len(littlefuzz) > 0 {
296 fuzzamount := 100
297 for i := 0; i < fuzzamount; i++ {
298 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
299 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
300 }
301
302 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
303 }
304 }
305
306 func TestUMarshalTo(t *testing.T) {
307 seed := time.Now().UnixNano()
308 popr := math_rand.New(math_rand.NewSource(seed))
309 p := NewPopulatedU(popr, false)
310 size := p.Size()
311 dAtA := make([]byte, size)
312 for i := range dAtA {
313 dAtA[i] = byte(popr.Intn(256))
314 }
315 _, err := p.MarshalTo(dAtA)
316 if err != nil {
317 t.Fatalf("seed = %d, err = %v", seed, err)
318 }
319 msg := &U{}
320 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
321 t.Fatalf("seed = %d, err = %v", seed, err)
322 }
323 for i := range dAtA {
324 dAtA[i] = byte(popr.Intn(256))
325 }
326 if err := p.VerboseEqual(msg); err != nil {
327 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
328 }
329 if !p.Equal(msg) {
330 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
331 }
332 }
333
334 func TestUnoMProto(t *testing.T) {
335 seed := time.Now().UnixNano()
336 popr := math_rand.New(math_rand.NewSource(seed))
337 p := NewPopulatedUnoM(popr, false)
338 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
339 if err != nil {
340 t.Fatalf("seed = %d, err = %v", seed, err)
341 }
342 msg := &UnoM{}
343 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
344 t.Fatalf("seed = %d, err = %v", seed, err)
345 }
346 littlefuzz := make([]byte, len(dAtA))
347 copy(littlefuzz, dAtA)
348 for i := range dAtA {
349 dAtA[i] = byte(popr.Intn(256))
350 }
351 if err := p.VerboseEqual(msg); err != nil {
352 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
353 }
354 if !p.Equal(msg) {
355 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
356 }
357 if len(littlefuzz) > 0 {
358 fuzzamount := 100
359 for i := 0; i < fuzzamount; i++ {
360 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
361 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
362 }
363
364 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
365 }
366 }
367
368 func TestOldAProto(t *testing.T) {
369 seed := time.Now().UnixNano()
370 popr := math_rand.New(math_rand.NewSource(seed))
371 p := NewPopulatedOldA(popr, false)
372 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
373 if err != nil {
374 t.Fatalf("seed = %d, err = %v", seed, err)
375 }
376 msg := &OldA{}
377 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
378 t.Fatalf("seed = %d, err = %v", seed, err)
379 }
380 littlefuzz := make([]byte, len(dAtA))
381 copy(littlefuzz, dAtA)
382 for i := range dAtA {
383 dAtA[i] = byte(popr.Intn(256))
384 }
385 if err := p.VerboseEqual(msg); err != nil {
386 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
387 }
388 if !p.Equal(msg) {
389 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
390 }
391 if len(littlefuzz) > 0 {
392 fuzzamount := 100
393 for i := 0; i < fuzzamount; i++ {
394 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
395 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
396 }
397
398 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
399 }
400 }
401
402 func TestOldAMarshalTo(t *testing.T) {
403 seed := time.Now().UnixNano()
404 popr := math_rand.New(math_rand.NewSource(seed))
405 p := NewPopulatedOldA(popr, false)
406 size := p.Size()
407 dAtA := make([]byte, size)
408 for i := range dAtA {
409 dAtA[i] = byte(popr.Intn(256))
410 }
411 _, err := p.MarshalTo(dAtA)
412 if err != nil {
413 t.Fatalf("seed = %d, err = %v", seed, err)
414 }
415 msg := &OldA{}
416 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
417 t.Fatalf("seed = %d, err = %v", seed, err)
418 }
419 for i := range dAtA {
420 dAtA[i] = byte(popr.Intn(256))
421 }
422 if err := p.VerboseEqual(msg); err != nil {
423 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
424 }
425 if !p.Equal(msg) {
426 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
427 }
428 }
429
430 func TestOldBProto(t *testing.T) {
431 seed := time.Now().UnixNano()
432 popr := math_rand.New(math_rand.NewSource(seed))
433 p := NewPopulatedOldB(popr, false)
434 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
435 if err != nil {
436 t.Fatalf("seed = %d, err = %v", seed, err)
437 }
438 msg := &OldB{}
439 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
440 t.Fatalf("seed = %d, err = %v", seed, err)
441 }
442 littlefuzz := make([]byte, len(dAtA))
443 copy(littlefuzz, dAtA)
444 for i := range dAtA {
445 dAtA[i] = byte(popr.Intn(256))
446 }
447 if err := p.VerboseEqual(msg); err != nil {
448 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
449 }
450 if !p.Equal(msg) {
451 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
452 }
453 if len(littlefuzz) > 0 {
454 fuzzamount := 100
455 for i := 0; i < fuzzamount; i++ {
456 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
457 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
458 }
459
460 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
461 }
462 }
463
464 func TestOldBMarshalTo(t *testing.T) {
465 seed := time.Now().UnixNano()
466 popr := math_rand.New(math_rand.NewSource(seed))
467 p := NewPopulatedOldB(popr, false)
468 size := p.Size()
469 dAtA := make([]byte, size)
470 for i := range dAtA {
471 dAtA[i] = byte(popr.Intn(256))
472 }
473 _, err := p.MarshalTo(dAtA)
474 if err != nil {
475 t.Fatalf("seed = %d, err = %v", seed, err)
476 }
477 msg := &OldB{}
478 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
479 t.Fatalf("seed = %d, err = %v", seed, err)
480 }
481 for i := range dAtA {
482 dAtA[i] = byte(popr.Intn(256))
483 }
484 if err := p.VerboseEqual(msg); err != nil {
485 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
486 }
487 if !p.Equal(msg) {
488 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
489 }
490 }
491
492 func TestOldCProto(t *testing.T) {
493 seed := time.Now().UnixNano()
494 popr := math_rand.New(math_rand.NewSource(seed))
495 p := NewPopulatedOldC(popr, false)
496 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
497 if err != nil {
498 t.Fatalf("seed = %d, err = %v", seed, err)
499 }
500 msg := &OldC{}
501 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
502 t.Fatalf("seed = %d, err = %v", seed, err)
503 }
504 littlefuzz := make([]byte, len(dAtA))
505 copy(littlefuzz, dAtA)
506 for i := range dAtA {
507 dAtA[i] = byte(popr.Intn(256))
508 }
509 if err := p.VerboseEqual(msg); err != nil {
510 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
511 }
512 if !p.Equal(msg) {
513 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
514 }
515 if len(littlefuzz) > 0 {
516 fuzzamount := 100
517 for i := 0; i < fuzzamount; i++ {
518 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
519 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
520 }
521
522 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
523 }
524 }
525
526 func TestOldCMarshalTo(t *testing.T) {
527 seed := time.Now().UnixNano()
528 popr := math_rand.New(math_rand.NewSource(seed))
529 p := NewPopulatedOldC(popr, false)
530 size := p.Size()
531 dAtA := make([]byte, size)
532 for i := range dAtA {
533 dAtA[i] = byte(popr.Intn(256))
534 }
535 _, err := p.MarshalTo(dAtA)
536 if err != nil {
537 t.Fatalf("seed = %d, err = %v", seed, err)
538 }
539 msg := &OldC{}
540 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
541 t.Fatalf("seed = %d, err = %v", seed, err)
542 }
543 for i := range dAtA {
544 dAtA[i] = byte(popr.Intn(256))
545 }
546 if err := p.VerboseEqual(msg); err != nil {
547 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
548 }
549 if !p.Equal(msg) {
550 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
551 }
552 }
553
554 func TestOldUProto(t *testing.T) {
555 seed := time.Now().UnixNano()
556 popr := math_rand.New(math_rand.NewSource(seed))
557 p := NewPopulatedOldU(popr, false)
558 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
559 if err != nil {
560 t.Fatalf("seed = %d, err = %v", seed, err)
561 }
562 msg := &OldU{}
563 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
564 t.Fatalf("seed = %d, err = %v", seed, err)
565 }
566 littlefuzz := make([]byte, len(dAtA))
567 copy(littlefuzz, dAtA)
568 for i := range dAtA {
569 dAtA[i] = byte(popr.Intn(256))
570 }
571 if err := p.VerboseEqual(msg); err != nil {
572 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
573 }
574 if !p.Equal(msg) {
575 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
576 }
577 if len(littlefuzz) > 0 {
578 fuzzamount := 100
579 for i := 0; i < fuzzamount; i++ {
580 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
581 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
582 }
583
584 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
585 }
586 }
587
588 func TestOldUMarshalTo(t *testing.T) {
589 seed := time.Now().UnixNano()
590 popr := math_rand.New(math_rand.NewSource(seed))
591 p := NewPopulatedOldU(popr, false)
592 size := p.Size()
593 dAtA := make([]byte, size)
594 for i := range dAtA {
595 dAtA[i] = byte(popr.Intn(256))
596 }
597 _, err := p.MarshalTo(dAtA)
598 if err != nil {
599 t.Fatalf("seed = %d, err = %v", seed, err)
600 }
601 msg := &OldU{}
602 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
603 t.Fatalf("seed = %d, err = %v", seed, err)
604 }
605 for i := range dAtA {
606 dAtA[i] = byte(popr.Intn(256))
607 }
608 if err := p.VerboseEqual(msg); err != nil {
609 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
610 }
611 if !p.Equal(msg) {
612 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
613 }
614 }
615
616 func TestOldUnoMProto(t *testing.T) {
617 seed := time.Now().UnixNano()
618 popr := math_rand.New(math_rand.NewSource(seed))
619 p := NewPopulatedOldUnoM(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 := &OldUnoM{}
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 TestAJSON(t *testing.T) {
651 seed := time.Now().UnixNano()
652 popr := math_rand.New(math_rand.NewSource(seed))
653 p := NewPopulatedA(popr, true)
654 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
655 jsondata, err := marshaler.MarshalToString(p)
656 if err != nil {
657 t.Fatalf("seed = %d, err = %v", seed, err)
658 }
659 msg := &A{}
660 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
661 if err != nil {
662 t.Fatalf("seed = %d, err = %v", seed, err)
663 }
664 if err := p.VerboseEqual(msg); err != nil {
665 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
666 }
667 if !p.Equal(msg) {
668 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
669 }
670 }
671 func TestBJSON(t *testing.T) {
672 seed := time.Now().UnixNano()
673 popr := math_rand.New(math_rand.NewSource(seed))
674 p := NewPopulatedB(popr, true)
675 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
676 jsondata, err := marshaler.MarshalToString(p)
677 if err != nil {
678 t.Fatalf("seed = %d, err = %v", seed, err)
679 }
680 msg := &B{}
681 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
682 if err != nil {
683 t.Fatalf("seed = %d, err = %v", seed, err)
684 }
685 if err := p.VerboseEqual(msg); err != nil {
686 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
687 }
688 if !p.Equal(msg) {
689 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
690 }
691 }
692 func TestDJSON(t *testing.T) {
693 seed := time.Now().UnixNano()
694 popr := math_rand.New(math_rand.NewSource(seed))
695 p := NewPopulatedD(popr, true)
696 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
697 jsondata, err := marshaler.MarshalToString(p)
698 if err != nil {
699 t.Fatalf("seed = %d, err = %v", seed, err)
700 }
701 msg := &D{}
702 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
703 if err != nil {
704 t.Fatalf("seed = %d, err = %v", seed, err)
705 }
706 if err := p.VerboseEqual(msg); err != nil {
707 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
708 }
709 if !p.Equal(msg) {
710 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
711 }
712 }
713 func TestCJSON(t *testing.T) {
714 seed := time.Now().UnixNano()
715 popr := math_rand.New(math_rand.NewSource(seed))
716 p := NewPopulatedC(popr, true)
717 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
718 jsondata, err := marshaler.MarshalToString(p)
719 if err != nil {
720 t.Fatalf("seed = %d, err = %v", seed, err)
721 }
722 msg := &C{}
723 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
724 if err != nil {
725 t.Fatalf("seed = %d, err = %v", seed, err)
726 }
727 if err := p.VerboseEqual(msg); err != nil {
728 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
729 }
730 if !p.Equal(msg) {
731 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
732 }
733 }
734 func TestUJSON(t *testing.T) {
735 seed := time.Now().UnixNano()
736 popr := math_rand.New(math_rand.NewSource(seed))
737 p := NewPopulatedU(popr, true)
738 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
739 jsondata, err := marshaler.MarshalToString(p)
740 if err != nil {
741 t.Fatalf("seed = %d, err = %v", seed, err)
742 }
743 msg := &U{}
744 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
745 if err != nil {
746 t.Fatalf("seed = %d, err = %v", seed, err)
747 }
748 if err := p.VerboseEqual(msg); err != nil {
749 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
750 }
751 if !p.Equal(msg) {
752 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
753 }
754 }
755 func TestUnoMJSON(t *testing.T) {
756 seed := time.Now().UnixNano()
757 popr := math_rand.New(math_rand.NewSource(seed))
758 p := NewPopulatedUnoM(popr, true)
759 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
760 jsondata, err := marshaler.MarshalToString(p)
761 if err != nil {
762 t.Fatalf("seed = %d, err = %v", seed, err)
763 }
764 msg := &UnoM{}
765 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
766 if err != nil {
767 t.Fatalf("seed = %d, err = %v", seed, err)
768 }
769 if err := p.VerboseEqual(msg); err != nil {
770 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
771 }
772 if !p.Equal(msg) {
773 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
774 }
775 }
776 func TestOldAJSON(t *testing.T) {
777 seed := time.Now().UnixNano()
778 popr := math_rand.New(math_rand.NewSource(seed))
779 p := NewPopulatedOldA(popr, true)
780 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
781 jsondata, err := marshaler.MarshalToString(p)
782 if err != nil {
783 t.Fatalf("seed = %d, err = %v", seed, err)
784 }
785 msg := &OldA{}
786 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
787 if err != nil {
788 t.Fatalf("seed = %d, err = %v", seed, err)
789 }
790 if err := p.VerboseEqual(msg); err != nil {
791 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
792 }
793 if !p.Equal(msg) {
794 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
795 }
796 }
797 func TestOldBJSON(t *testing.T) {
798 seed := time.Now().UnixNano()
799 popr := math_rand.New(math_rand.NewSource(seed))
800 p := NewPopulatedOldB(popr, true)
801 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
802 jsondata, err := marshaler.MarshalToString(p)
803 if err != nil {
804 t.Fatalf("seed = %d, err = %v", seed, err)
805 }
806 msg := &OldB{}
807 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
808 if err != nil {
809 t.Fatalf("seed = %d, err = %v", seed, err)
810 }
811 if err := p.VerboseEqual(msg); err != nil {
812 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
813 }
814 if !p.Equal(msg) {
815 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
816 }
817 }
818 func TestOldCJSON(t *testing.T) {
819 seed := time.Now().UnixNano()
820 popr := math_rand.New(math_rand.NewSource(seed))
821 p := NewPopulatedOldC(popr, true)
822 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
823 jsondata, err := marshaler.MarshalToString(p)
824 if err != nil {
825 t.Fatalf("seed = %d, err = %v", seed, err)
826 }
827 msg := &OldC{}
828 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
829 if err != nil {
830 t.Fatalf("seed = %d, err = %v", seed, err)
831 }
832 if err := p.VerboseEqual(msg); err != nil {
833 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
834 }
835 if !p.Equal(msg) {
836 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
837 }
838 }
839 func TestOldUJSON(t *testing.T) {
840 seed := time.Now().UnixNano()
841 popr := math_rand.New(math_rand.NewSource(seed))
842 p := NewPopulatedOldU(popr, true)
843 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
844 jsondata, err := marshaler.MarshalToString(p)
845 if err != nil {
846 t.Fatalf("seed = %d, err = %v", seed, err)
847 }
848 msg := &OldU{}
849 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
850 if err != nil {
851 t.Fatalf("seed = %d, err = %v", seed, err)
852 }
853 if err := p.VerboseEqual(msg); err != nil {
854 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
855 }
856 if !p.Equal(msg) {
857 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
858 }
859 }
860 func TestOldUnoMJSON(t *testing.T) {
861 seed := time.Now().UnixNano()
862 popr := math_rand.New(math_rand.NewSource(seed))
863 p := NewPopulatedOldUnoM(popr, true)
864 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
865 jsondata, err := marshaler.MarshalToString(p)
866 if err != nil {
867 t.Fatalf("seed = %d, err = %v", seed, err)
868 }
869 msg := &OldUnoM{}
870 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
871 if err != nil {
872 t.Fatalf("seed = %d, err = %v", seed, err)
873 }
874 if err := p.VerboseEqual(msg); err != nil {
875 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
876 }
877 if !p.Equal(msg) {
878 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
879 }
880 }
881 func TestAProtoText(t *testing.T) {
882 seed := time.Now().UnixNano()
883 popr := math_rand.New(math_rand.NewSource(seed))
884 p := NewPopulatedA(popr, true)
885 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
886 msg := &A{}
887 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
888 t.Fatalf("seed = %d, err = %v", seed, err)
889 }
890 if err := p.VerboseEqual(msg); err != nil {
891 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
892 }
893 if !p.Equal(msg) {
894 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
895 }
896 }
897
898 func TestAProtoCompactText(t *testing.T) {
899 seed := time.Now().UnixNano()
900 popr := math_rand.New(math_rand.NewSource(seed))
901 p := NewPopulatedA(popr, true)
902 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
903 msg := &A{}
904 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
905 t.Fatalf("seed = %d, err = %v", seed, err)
906 }
907 if err := p.VerboseEqual(msg); err != nil {
908 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
909 }
910 if !p.Equal(msg) {
911 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
912 }
913 }
914
915 func TestBProtoText(t *testing.T) {
916 seed := time.Now().UnixNano()
917 popr := math_rand.New(math_rand.NewSource(seed))
918 p := NewPopulatedB(popr, true)
919 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
920 msg := &B{}
921 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
922 t.Fatalf("seed = %d, err = %v", seed, err)
923 }
924 if err := p.VerboseEqual(msg); err != nil {
925 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
926 }
927 if !p.Equal(msg) {
928 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
929 }
930 }
931
932 func TestBProtoCompactText(t *testing.T) {
933 seed := time.Now().UnixNano()
934 popr := math_rand.New(math_rand.NewSource(seed))
935 p := NewPopulatedB(popr, true)
936 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
937 msg := &B{}
938 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
939 t.Fatalf("seed = %d, err = %v", seed, err)
940 }
941 if err := p.VerboseEqual(msg); err != nil {
942 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
943 }
944 if !p.Equal(msg) {
945 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
946 }
947 }
948
949 func TestDProtoText(t *testing.T) {
950 seed := time.Now().UnixNano()
951 popr := math_rand.New(math_rand.NewSource(seed))
952 p := NewPopulatedD(popr, true)
953 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
954 msg := &D{}
955 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
956 t.Fatalf("seed = %d, err = %v", seed, err)
957 }
958 if err := p.VerboseEqual(msg); err != nil {
959 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
960 }
961 if !p.Equal(msg) {
962 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
963 }
964 }
965
966 func TestDProtoCompactText(t *testing.T) {
967 seed := time.Now().UnixNano()
968 popr := math_rand.New(math_rand.NewSource(seed))
969 p := NewPopulatedD(popr, true)
970 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
971 msg := &D{}
972 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
973 t.Fatalf("seed = %d, err = %v", seed, err)
974 }
975 if err := p.VerboseEqual(msg); err != nil {
976 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
977 }
978 if !p.Equal(msg) {
979 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
980 }
981 }
982
983 func TestCProtoText(t *testing.T) {
984 seed := time.Now().UnixNano()
985 popr := math_rand.New(math_rand.NewSource(seed))
986 p := NewPopulatedC(popr, true)
987 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
988 msg := &C{}
989 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
990 t.Fatalf("seed = %d, err = %v", seed, err)
991 }
992 if err := p.VerboseEqual(msg); err != nil {
993 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
994 }
995 if !p.Equal(msg) {
996 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
997 }
998 }
999
1000 func TestCProtoCompactText(t *testing.T) {
1001 seed := time.Now().UnixNano()
1002 popr := math_rand.New(math_rand.NewSource(seed))
1003 p := NewPopulatedC(popr, true)
1004 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1005 msg := &C{}
1006 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1007 t.Fatalf("seed = %d, err = %v", seed, err)
1008 }
1009 if err := p.VerboseEqual(msg); err != nil {
1010 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1011 }
1012 if !p.Equal(msg) {
1013 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1014 }
1015 }
1016
1017 func TestUProtoText(t *testing.T) {
1018 seed := time.Now().UnixNano()
1019 popr := math_rand.New(math_rand.NewSource(seed))
1020 p := NewPopulatedU(popr, true)
1021 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1022 msg := &U{}
1023 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1024 t.Fatalf("seed = %d, err = %v", seed, err)
1025 }
1026 if err := p.VerboseEqual(msg); err != nil {
1027 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1028 }
1029 if !p.Equal(msg) {
1030 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1031 }
1032 }
1033
1034 func TestUProtoCompactText(t *testing.T) {
1035 seed := time.Now().UnixNano()
1036 popr := math_rand.New(math_rand.NewSource(seed))
1037 p := NewPopulatedU(popr, true)
1038 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1039 msg := &U{}
1040 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1041 t.Fatalf("seed = %d, err = %v", seed, err)
1042 }
1043 if err := p.VerboseEqual(msg); err != nil {
1044 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1045 }
1046 if !p.Equal(msg) {
1047 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1048 }
1049 }
1050
1051 func TestUnoMProtoText(t *testing.T) {
1052 seed := time.Now().UnixNano()
1053 popr := math_rand.New(math_rand.NewSource(seed))
1054 p := NewPopulatedUnoM(popr, true)
1055 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1056 msg := &UnoM{}
1057 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1058 t.Fatalf("seed = %d, err = %v", seed, err)
1059 }
1060 if err := p.VerboseEqual(msg); err != nil {
1061 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1062 }
1063 if !p.Equal(msg) {
1064 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1065 }
1066 }
1067
1068 func TestUnoMProtoCompactText(t *testing.T) {
1069 seed := time.Now().UnixNano()
1070 popr := math_rand.New(math_rand.NewSource(seed))
1071 p := NewPopulatedUnoM(popr, true)
1072 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1073 msg := &UnoM{}
1074 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1075 t.Fatalf("seed = %d, err = %v", seed, err)
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 }
1084
1085 func TestOldAProtoText(t *testing.T) {
1086 seed := time.Now().UnixNano()
1087 popr := math_rand.New(math_rand.NewSource(seed))
1088 p := NewPopulatedOldA(popr, true)
1089 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1090 msg := &OldA{}
1091 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1092 t.Fatalf("seed = %d, err = %v", seed, err)
1093 }
1094 if err := p.VerboseEqual(msg); err != nil {
1095 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1096 }
1097 if !p.Equal(msg) {
1098 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1099 }
1100 }
1101
1102 func TestOldAProtoCompactText(t *testing.T) {
1103 seed := time.Now().UnixNano()
1104 popr := math_rand.New(math_rand.NewSource(seed))
1105 p := NewPopulatedOldA(popr, true)
1106 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1107 msg := &OldA{}
1108 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1109 t.Fatalf("seed = %d, err = %v", seed, err)
1110 }
1111 if err := p.VerboseEqual(msg); err != nil {
1112 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1113 }
1114 if !p.Equal(msg) {
1115 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1116 }
1117 }
1118
1119 func TestOldBProtoText(t *testing.T) {
1120 seed := time.Now().UnixNano()
1121 popr := math_rand.New(math_rand.NewSource(seed))
1122 p := NewPopulatedOldB(popr, true)
1123 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1124 msg := &OldB{}
1125 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1126 t.Fatalf("seed = %d, err = %v", seed, err)
1127 }
1128 if err := p.VerboseEqual(msg); err != nil {
1129 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1130 }
1131 if !p.Equal(msg) {
1132 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1133 }
1134 }
1135
1136 func TestOldBProtoCompactText(t *testing.T) {
1137 seed := time.Now().UnixNano()
1138 popr := math_rand.New(math_rand.NewSource(seed))
1139 p := NewPopulatedOldB(popr, true)
1140 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1141 msg := &OldB{}
1142 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1143 t.Fatalf("seed = %d, err = %v", seed, err)
1144 }
1145 if err := p.VerboseEqual(msg); err != nil {
1146 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1147 }
1148 if !p.Equal(msg) {
1149 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1150 }
1151 }
1152
1153 func TestOldCProtoText(t *testing.T) {
1154 seed := time.Now().UnixNano()
1155 popr := math_rand.New(math_rand.NewSource(seed))
1156 p := NewPopulatedOldC(popr, true)
1157 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1158 msg := &OldC{}
1159 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1160 t.Fatalf("seed = %d, err = %v", seed, err)
1161 }
1162 if err := p.VerboseEqual(msg); err != nil {
1163 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1164 }
1165 if !p.Equal(msg) {
1166 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1167 }
1168 }
1169
1170 func TestOldCProtoCompactText(t *testing.T) {
1171 seed := time.Now().UnixNano()
1172 popr := math_rand.New(math_rand.NewSource(seed))
1173 p := NewPopulatedOldC(popr, true)
1174 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1175 msg := &OldC{}
1176 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1177 t.Fatalf("seed = %d, err = %v", seed, err)
1178 }
1179 if err := p.VerboseEqual(msg); err != nil {
1180 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1181 }
1182 if !p.Equal(msg) {
1183 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1184 }
1185 }
1186
1187 func TestOldUProtoText(t *testing.T) {
1188 seed := time.Now().UnixNano()
1189 popr := math_rand.New(math_rand.NewSource(seed))
1190 p := NewPopulatedOldU(popr, true)
1191 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1192 msg := &OldU{}
1193 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1194 t.Fatalf("seed = %d, err = %v", seed, err)
1195 }
1196 if err := p.VerboseEqual(msg); err != nil {
1197 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1198 }
1199 if !p.Equal(msg) {
1200 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1201 }
1202 }
1203
1204 func TestOldUProtoCompactText(t *testing.T) {
1205 seed := time.Now().UnixNano()
1206 popr := math_rand.New(math_rand.NewSource(seed))
1207 p := NewPopulatedOldU(popr, true)
1208 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1209 msg := &OldU{}
1210 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1211 t.Fatalf("seed = %d, err = %v", seed, err)
1212 }
1213 if err := p.VerboseEqual(msg); err != nil {
1214 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1215 }
1216 if !p.Equal(msg) {
1217 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1218 }
1219 }
1220
1221 func TestOldUnoMProtoText(t *testing.T) {
1222 seed := time.Now().UnixNano()
1223 popr := math_rand.New(math_rand.NewSource(seed))
1224 p := NewPopulatedOldUnoM(popr, true)
1225 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1226 msg := &OldUnoM{}
1227 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1228 t.Fatalf("seed = %d, err = %v", seed, err)
1229 }
1230 if err := p.VerboseEqual(msg); err != nil {
1231 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1232 }
1233 if !p.Equal(msg) {
1234 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1235 }
1236 }
1237
1238 func TestOldUnoMProtoCompactText(t *testing.T) {
1239 seed := time.Now().UnixNano()
1240 popr := math_rand.New(math_rand.NewSource(seed))
1241 p := NewPopulatedOldUnoM(popr, true)
1242 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1243 msg := &OldUnoM{}
1244 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1245 t.Fatalf("seed = %d, err = %v", seed, err)
1246 }
1247 if err := p.VerboseEqual(msg); err != nil {
1248 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1249 }
1250 if !p.Equal(msg) {
1251 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1252 }
1253 }
1254
1255 func TestUnrecognizedDescription(t *testing.T) {
1256 UnrecognizedDescription()
1257 }
1258 func TestAVerboseEqual(t *testing.T) {
1259 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1260 p := NewPopulatedA(popr, false)
1261 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1262 if err != nil {
1263 panic(err)
1264 }
1265 msg := &A{}
1266 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1267 panic(err)
1268 }
1269 if err := p.VerboseEqual(msg); err != nil {
1270 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1271 }
1272 }
1273 func TestBVerboseEqual(t *testing.T) {
1274 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1275 p := NewPopulatedB(popr, false)
1276 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1277 if err != nil {
1278 panic(err)
1279 }
1280 msg := &B{}
1281 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1282 panic(err)
1283 }
1284 if err := p.VerboseEqual(msg); err != nil {
1285 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1286 }
1287 }
1288 func TestDVerboseEqual(t *testing.T) {
1289 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1290 p := NewPopulatedD(popr, false)
1291 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1292 if err != nil {
1293 panic(err)
1294 }
1295 msg := &D{}
1296 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1297 panic(err)
1298 }
1299 if err := p.VerboseEqual(msg); err != nil {
1300 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1301 }
1302 }
1303 func TestCVerboseEqual(t *testing.T) {
1304 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1305 p := NewPopulatedC(popr, false)
1306 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1307 if err != nil {
1308 panic(err)
1309 }
1310 msg := &C{}
1311 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1312 panic(err)
1313 }
1314 if err := p.VerboseEqual(msg); err != nil {
1315 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1316 }
1317 }
1318 func TestUVerboseEqual(t *testing.T) {
1319 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1320 p := NewPopulatedU(popr, false)
1321 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1322 if err != nil {
1323 panic(err)
1324 }
1325 msg := &U{}
1326 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1327 panic(err)
1328 }
1329 if err := p.VerboseEqual(msg); err != nil {
1330 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1331 }
1332 }
1333 func TestUnoMVerboseEqual(t *testing.T) {
1334 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1335 p := NewPopulatedUnoM(popr, false)
1336 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1337 if err != nil {
1338 panic(err)
1339 }
1340 msg := &UnoM{}
1341 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1342 panic(err)
1343 }
1344 if err := p.VerboseEqual(msg); err != nil {
1345 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1346 }
1347 }
1348 func TestOldAVerboseEqual(t *testing.T) {
1349 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1350 p := NewPopulatedOldA(popr, false)
1351 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1352 if err != nil {
1353 panic(err)
1354 }
1355 msg := &OldA{}
1356 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1357 panic(err)
1358 }
1359 if err := p.VerboseEqual(msg); err != nil {
1360 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1361 }
1362 }
1363 func TestOldBVerboseEqual(t *testing.T) {
1364 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1365 p := NewPopulatedOldB(popr, false)
1366 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1367 if err != nil {
1368 panic(err)
1369 }
1370 msg := &OldB{}
1371 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1372 panic(err)
1373 }
1374 if err := p.VerboseEqual(msg); err != nil {
1375 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1376 }
1377 }
1378 func TestOldCVerboseEqual(t *testing.T) {
1379 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1380 p := NewPopulatedOldC(popr, false)
1381 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1382 if err != nil {
1383 panic(err)
1384 }
1385 msg := &OldC{}
1386 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1387 panic(err)
1388 }
1389 if err := p.VerboseEqual(msg); err != nil {
1390 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1391 }
1392 }
1393 func TestOldUVerboseEqual(t *testing.T) {
1394 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1395 p := NewPopulatedOldU(popr, false)
1396 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1397 if err != nil {
1398 panic(err)
1399 }
1400 msg := &OldU{}
1401 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1402 panic(err)
1403 }
1404 if err := p.VerboseEqual(msg); err != nil {
1405 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1406 }
1407 }
1408 func TestOldUnoMVerboseEqual(t *testing.T) {
1409 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1410 p := NewPopulatedOldUnoM(popr, false)
1411 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1412 if err != nil {
1413 panic(err)
1414 }
1415 msg := &OldUnoM{}
1416 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1417 panic(err)
1418 }
1419 if err := p.VerboseEqual(msg); err != nil {
1420 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1421 }
1422 }
1423 func TestAGoString(t *testing.T) {
1424 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1425 p := NewPopulatedA(popr, false)
1426 s1 := p.GoString()
1427 s2 := fmt.Sprintf("%#v", p)
1428 if s1 != s2 {
1429 t.Fatalf("GoString want %v got %v", s1, s2)
1430 }
1431 _, err := go_parser.ParseExpr(s1)
1432 if err != nil {
1433 t.Fatal(err)
1434 }
1435 }
1436 func TestBGoString(t *testing.T) {
1437 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1438 p := NewPopulatedB(popr, false)
1439 s1 := p.GoString()
1440 s2 := fmt.Sprintf("%#v", p)
1441 if s1 != s2 {
1442 t.Fatalf("GoString want %v got %v", s1, s2)
1443 }
1444 _, err := go_parser.ParseExpr(s1)
1445 if err != nil {
1446 t.Fatal(err)
1447 }
1448 }
1449 func TestDGoString(t *testing.T) {
1450 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1451 p := NewPopulatedD(popr, false)
1452 s1 := p.GoString()
1453 s2 := fmt.Sprintf("%#v", p)
1454 if s1 != s2 {
1455 t.Fatalf("GoString want %v got %v", s1, s2)
1456 }
1457 _, err := go_parser.ParseExpr(s1)
1458 if err != nil {
1459 t.Fatal(err)
1460 }
1461 }
1462 func TestCGoString(t *testing.T) {
1463 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1464 p := NewPopulatedC(popr, false)
1465 s1 := p.GoString()
1466 s2 := fmt.Sprintf("%#v", p)
1467 if s1 != s2 {
1468 t.Fatalf("GoString want %v got %v", s1, s2)
1469 }
1470 _, err := go_parser.ParseExpr(s1)
1471 if err != nil {
1472 t.Fatal(err)
1473 }
1474 }
1475 func TestUGoString(t *testing.T) {
1476 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1477 p := NewPopulatedU(popr, false)
1478 s1 := p.GoString()
1479 s2 := fmt.Sprintf("%#v", p)
1480 if s1 != s2 {
1481 t.Fatalf("GoString want %v got %v", s1, s2)
1482 }
1483 _, err := go_parser.ParseExpr(s1)
1484 if err != nil {
1485 t.Fatal(err)
1486 }
1487 }
1488 func TestUnoMGoString(t *testing.T) {
1489 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1490 p := NewPopulatedUnoM(popr, false)
1491 s1 := p.GoString()
1492 s2 := fmt.Sprintf("%#v", p)
1493 if s1 != s2 {
1494 t.Fatalf("GoString want %v got %v", s1, s2)
1495 }
1496 _, err := go_parser.ParseExpr(s1)
1497 if err != nil {
1498 t.Fatal(err)
1499 }
1500 }
1501 func TestOldAGoString(t *testing.T) {
1502 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1503 p := NewPopulatedOldA(popr, false)
1504 s1 := p.GoString()
1505 s2 := fmt.Sprintf("%#v", p)
1506 if s1 != s2 {
1507 t.Fatalf("GoString want %v got %v", s1, s2)
1508 }
1509 _, err := go_parser.ParseExpr(s1)
1510 if err != nil {
1511 t.Fatal(err)
1512 }
1513 }
1514 func TestOldBGoString(t *testing.T) {
1515 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1516 p := NewPopulatedOldB(popr, false)
1517 s1 := p.GoString()
1518 s2 := fmt.Sprintf("%#v", p)
1519 if s1 != s2 {
1520 t.Fatalf("GoString want %v got %v", s1, s2)
1521 }
1522 _, err := go_parser.ParseExpr(s1)
1523 if err != nil {
1524 t.Fatal(err)
1525 }
1526 }
1527 func TestOldCGoString(t *testing.T) {
1528 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1529 p := NewPopulatedOldC(popr, false)
1530 s1 := p.GoString()
1531 s2 := fmt.Sprintf("%#v", p)
1532 if s1 != s2 {
1533 t.Fatalf("GoString want %v got %v", s1, s2)
1534 }
1535 _, err := go_parser.ParseExpr(s1)
1536 if err != nil {
1537 t.Fatal(err)
1538 }
1539 }
1540 func TestOldUGoString(t *testing.T) {
1541 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1542 p := NewPopulatedOldU(popr, false)
1543 s1 := p.GoString()
1544 s2 := fmt.Sprintf("%#v", p)
1545 if s1 != s2 {
1546 t.Fatalf("GoString want %v got %v", s1, s2)
1547 }
1548 _, err := go_parser.ParseExpr(s1)
1549 if err != nil {
1550 t.Fatal(err)
1551 }
1552 }
1553 func TestOldUnoMGoString(t *testing.T) {
1554 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1555 p := NewPopulatedOldUnoM(popr, false)
1556 s1 := p.GoString()
1557 s2 := fmt.Sprintf("%#v", p)
1558 if s1 != s2 {
1559 t.Fatalf("GoString want %v got %v", s1, s2)
1560 }
1561 _, err := go_parser.ParseExpr(s1)
1562 if err != nil {
1563 t.Fatal(err)
1564 }
1565 }
1566 func TestASize(t *testing.T) {
1567 seed := time.Now().UnixNano()
1568 popr := math_rand.New(math_rand.NewSource(seed))
1569 p := NewPopulatedA(popr, true)
1570 size2 := github_com_gogo_protobuf_proto.Size(p)
1571 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1572 if err != nil {
1573 t.Fatalf("seed = %d, err = %v", seed, err)
1574 }
1575 size := p.Size()
1576 if len(dAtA) != size {
1577 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1578 }
1579 if size2 != size {
1580 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1581 }
1582 size3 := github_com_gogo_protobuf_proto.Size(p)
1583 if size3 != size {
1584 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1585 }
1586 }
1587
1588 func TestBSize(t *testing.T) {
1589 seed := time.Now().UnixNano()
1590 popr := math_rand.New(math_rand.NewSource(seed))
1591 p := NewPopulatedB(popr, true)
1592 size2 := github_com_gogo_protobuf_proto.Size(p)
1593 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1594 if err != nil {
1595 t.Fatalf("seed = %d, err = %v", seed, err)
1596 }
1597 size := p.Size()
1598 if len(dAtA) != size {
1599 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1600 }
1601 if size2 != size {
1602 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1603 }
1604 size3 := github_com_gogo_protobuf_proto.Size(p)
1605 if size3 != size {
1606 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1607 }
1608 }
1609
1610 func TestDSize(t *testing.T) {
1611 seed := time.Now().UnixNano()
1612 popr := math_rand.New(math_rand.NewSource(seed))
1613 p := NewPopulatedD(popr, true)
1614 size2 := github_com_gogo_protobuf_proto.Size(p)
1615 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1616 if err != nil {
1617 t.Fatalf("seed = %d, err = %v", seed, err)
1618 }
1619 size := p.Size()
1620 if len(dAtA) != size {
1621 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1622 }
1623 if size2 != size {
1624 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1625 }
1626 size3 := github_com_gogo_protobuf_proto.Size(p)
1627 if size3 != size {
1628 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1629 }
1630 }
1631
1632 func TestCSize(t *testing.T) {
1633 seed := time.Now().UnixNano()
1634 popr := math_rand.New(math_rand.NewSource(seed))
1635 p := NewPopulatedC(popr, true)
1636 size2 := github_com_gogo_protobuf_proto.Size(p)
1637 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1638 if err != nil {
1639 t.Fatalf("seed = %d, err = %v", seed, err)
1640 }
1641 size := p.Size()
1642 if len(dAtA) != size {
1643 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1644 }
1645 if size2 != size {
1646 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1647 }
1648 size3 := github_com_gogo_protobuf_proto.Size(p)
1649 if size3 != size {
1650 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1651 }
1652 }
1653
1654 func TestUSize(t *testing.T) {
1655 seed := time.Now().UnixNano()
1656 popr := math_rand.New(math_rand.NewSource(seed))
1657 p := NewPopulatedU(popr, true)
1658 size2 := github_com_gogo_protobuf_proto.Size(p)
1659 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1660 if err != nil {
1661 t.Fatalf("seed = %d, err = %v", seed, err)
1662 }
1663 size := p.Size()
1664 if len(dAtA) != size {
1665 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1666 }
1667 if size2 != size {
1668 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1669 }
1670 size3 := github_com_gogo_protobuf_proto.Size(p)
1671 if size3 != size {
1672 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1673 }
1674 }
1675
1676 func TestOldASize(t *testing.T) {
1677 seed := time.Now().UnixNano()
1678 popr := math_rand.New(math_rand.NewSource(seed))
1679 p := NewPopulatedOldA(popr, true)
1680 size2 := github_com_gogo_protobuf_proto.Size(p)
1681 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1682 if err != nil {
1683 t.Fatalf("seed = %d, err = %v", seed, err)
1684 }
1685 size := p.Size()
1686 if len(dAtA) != size {
1687 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1688 }
1689 if size2 != size {
1690 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1691 }
1692 size3 := github_com_gogo_protobuf_proto.Size(p)
1693 if size3 != size {
1694 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1695 }
1696 }
1697
1698 func TestOldBSize(t *testing.T) {
1699 seed := time.Now().UnixNano()
1700 popr := math_rand.New(math_rand.NewSource(seed))
1701 p := NewPopulatedOldB(popr, true)
1702 size2 := github_com_gogo_protobuf_proto.Size(p)
1703 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1704 if err != nil {
1705 t.Fatalf("seed = %d, err = %v", seed, err)
1706 }
1707 size := p.Size()
1708 if len(dAtA) != size {
1709 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1710 }
1711 if size2 != size {
1712 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1713 }
1714 size3 := github_com_gogo_protobuf_proto.Size(p)
1715 if size3 != size {
1716 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1717 }
1718 }
1719
1720 func TestOldCSize(t *testing.T) {
1721 seed := time.Now().UnixNano()
1722 popr := math_rand.New(math_rand.NewSource(seed))
1723 p := NewPopulatedOldC(popr, true)
1724 size2 := github_com_gogo_protobuf_proto.Size(p)
1725 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1726 if err != nil {
1727 t.Fatalf("seed = %d, err = %v", seed, err)
1728 }
1729 size := p.Size()
1730 if len(dAtA) != size {
1731 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1732 }
1733 if size2 != size {
1734 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1735 }
1736 size3 := github_com_gogo_protobuf_proto.Size(p)
1737 if size3 != size {
1738 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1739 }
1740 }
1741
1742 func TestOldUSize(t *testing.T) {
1743 seed := time.Now().UnixNano()
1744 popr := math_rand.New(math_rand.NewSource(seed))
1745 p := NewPopulatedOldU(popr, true)
1746 size2 := github_com_gogo_protobuf_proto.Size(p)
1747 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1748 if err != nil {
1749 t.Fatalf("seed = %d, err = %v", seed, err)
1750 }
1751 size := p.Size()
1752 if len(dAtA) != size {
1753 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1754 }
1755 if size2 != size {
1756 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1757 }
1758 size3 := github_com_gogo_protobuf_proto.Size(p)
1759 if size3 != size {
1760 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1761 }
1762 }
1763
1764 func TestAStringer(t *testing.T) {
1765 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1766 p := NewPopulatedA(popr, false)
1767 s1 := p.String()
1768 s2 := fmt.Sprintf("%v", p)
1769 if s1 != s2 {
1770 t.Fatalf("String want %v got %v", s1, s2)
1771 }
1772 }
1773 func TestBStringer(t *testing.T) {
1774 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1775 p := NewPopulatedB(popr, false)
1776 s1 := p.String()
1777 s2 := fmt.Sprintf("%v", p)
1778 if s1 != s2 {
1779 t.Fatalf("String want %v got %v", s1, s2)
1780 }
1781 }
1782 func TestDStringer(t *testing.T) {
1783 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1784 p := NewPopulatedD(popr, false)
1785 s1 := p.String()
1786 s2 := fmt.Sprintf("%v", p)
1787 if s1 != s2 {
1788 t.Fatalf("String want %v got %v", s1, s2)
1789 }
1790 }
1791 func TestCStringer(t *testing.T) {
1792 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1793 p := NewPopulatedC(popr, false)
1794 s1 := p.String()
1795 s2 := fmt.Sprintf("%v", p)
1796 if s1 != s2 {
1797 t.Fatalf("String want %v got %v", s1, s2)
1798 }
1799 }
1800 func TestUStringer(t *testing.T) {
1801 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1802 p := NewPopulatedU(popr, false)
1803 s1 := p.String()
1804 s2 := fmt.Sprintf("%v", p)
1805 if s1 != s2 {
1806 t.Fatalf("String want %v got %v", s1, s2)
1807 }
1808 }
1809 func TestUnoMStringer(t *testing.T) {
1810 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1811 p := NewPopulatedUnoM(popr, false)
1812 s1 := p.String()
1813 s2 := fmt.Sprintf("%v", p)
1814 if s1 != s2 {
1815 t.Fatalf("String want %v got %v", s1, s2)
1816 }
1817 }
1818 func TestOldAStringer(t *testing.T) {
1819 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1820 p := NewPopulatedOldA(popr, false)
1821 s1 := p.String()
1822 s2 := fmt.Sprintf("%v", p)
1823 if s1 != s2 {
1824 t.Fatalf("String want %v got %v", s1, s2)
1825 }
1826 }
1827 func TestOldBStringer(t *testing.T) {
1828 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1829 p := NewPopulatedOldB(popr, false)
1830 s1 := p.String()
1831 s2 := fmt.Sprintf("%v", p)
1832 if s1 != s2 {
1833 t.Fatalf("String want %v got %v", s1, s2)
1834 }
1835 }
1836 func TestOldCStringer(t *testing.T) {
1837 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1838 p := NewPopulatedOldC(popr, false)
1839 s1 := p.String()
1840 s2 := fmt.Sprintf("%v", p)
1841 if s1 != s2 {
1842 t.Fatalf("String want %v got %v", s1, s2)
1843 }
1844 }
1845 func TestOldUStringer(t *testing.T) {
1846 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1847 p := NewPopulatedOldU(popr, false)
1848 s1 := p.String()
1849 s2 := fmt.Sprintf("%v", p)
1850 if s1 != s2 {
1851 t.Fatalf("String want %v got %v", s1, s2)
1852 }
1853 }
1854 func TestOldUnoMStringer(t *testing.T) {
1855 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1856 p := NewPopulatedOldUnoM(popr, false)
1857 s1 := p.String()
1858 s2 := fmt.Sprintf("%v", p)
1859 if s1 != s2 {
1860 t.Fatalf("String want %v got %v", s1, s2)
1861 }
1862 }
1863
1864
1865
View as plain text