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 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 BenchmarkAProtoMarshal(b *testing.B) {
87 popr := math_rand.New(math_rand.NewSource(616))
88 total := 0
89 pops := make([]*A, 10000)
90 for i := 0; i < 10000; i++ {
91 pops[i] = NewPopulatedA(popr, false)
92 }
93 b.ResetTimer()
94 for i := 0; i < b.N; i++ {
95 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
96 if err != nil {
97 panic(err)
98 }
99 total += len(dAtA)
100 }
101 b.SetBytes(int64(total / b.N))
102 }
103
104 func BenchmarkAProtoUnmarshal(b *testing.B) {
105 popr := math_rand.New(math_rand.NewSource(616))
106 total := 0
107 datas := make([][]byte, 10000)
108 for i := 0; i < 10000; i++ {
109 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedA(popr, false))
110 if err != nil {
111 panic(err)
112 }
113 datas[i] = dAtA
114 }
115 msg := &A{}
116 b.ResetTimer()
117 for i := 0; i < b.N; i++ {
118 total += len(datas[i%10000])
119 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
120 panic(err)
121 }
122 }
123 b.SetBytes(int64(total / b.N))
124 }
125
126 func TestBProto(t *testing.T) {
127 seed := time.Now().UnixNano()
128 popr := math_rand.New(math_rand.NewSource(seed))
129 p := NewPopulatedB(popr, false)
130 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
131 if err != nil {
132 t.Fatalf("seed = %d, err = %v", seed, err)
133 }
134 msg := &B{}
135 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
136 t.Fatalf("seed = %d, err = %v", seed, err)
137 }
138 littlefuzz := make([]byte, len(dAtA))
139 copy(littlefuzz, dAtA)
140 for i := range dAtA {
141 dAtA[i] = byte(popr.Intn(256))
142 }
143 if err := p.VerboseEqual(msg); err != nil {
144 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
145 }
146 if !p.Equal(msg) {
147 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
148 }
149 if len(littlefuzz) > 0 {
150 fuzzamount := 100
151 for i := 0; i < fuzzamount; i++ {
152 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
153 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
154 }
155
156 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
157 }
158 }
159
160 func TestBMarshalTo(t *testing.T) {
161 seed := time.Now().UnixNano()
162 popr := math_rand.New(math_rand.NewSource(seed))
163 p := NewPopulatedB(popr, false)
164 size := p.Size()
165 dAtA := make([]byte, size)
166 for i := range dAtA {
167 dAtA[i] = byte(popr.Intn(256))
168 }
169 _, err := p.MarshalTo(dAtA)
170 if err != nil {
171 t.Fatalf("seed = %d, err = %v", seed, err)
172 }
173 msg := &B{}
174 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
175 t.Fatalf("seed = %d, err = %v", seed, err)
176 }
177 for i := range dAtA {
178 dAtA[i] = byte(popr.Intn(256))
179 }
180 if err := p.VerboseEqual(msg); err != nil {
181 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
182 }
183 if !p.Equal(msg) {
184 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
185 }
186 }
187
188 func BenchmarkBProtoMarshal(b *testing.B) {
189 popr := math_rand.New(math_rand.NewSource(616))
190 total := 0
191 pops := make([]*B, 10000)
192 for i := 0; i < 10000; i++ {
193 pops[i] = NewPopulatedB(popr, false)
194 }
195 b.ResetTimer()
196 for i := 0; i < b.N; i++ {
197 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
198 if err != nil {
199 panic(err)
200 }
201 total += len(dAtA)
202 }
203 b.SetBytes(int64(total / b.N))
204 }
205
206 func BenchmarkBProtoUnmarshal(b *testing.B) {
207 popr := math_rand.New(math_rand.NewSource(616))
208 total := 0
209 datas := make([][]byte, 10000)
210 for i := 0; i < 10000; i++ {
211 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedB(popr, false))
212 if err != nil {
213 panic(err)
214 }
215 datas[i] = dAtA
216 }
217 msg := &B{}
218 b.ResetTimer()
219 for i := 0; i < b.N; i++ {
220 total += len(datas[i%10000])
221 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
222 panic(err)
223 }
224 }
225 b.SetBytes(int64(total / b.N))
226 }
227
228 func TestCProto(t *testing.T) {
229 seed := time.Now().UnixNano()
230 popr := math_rand.New(math_rand.NewSource(seed))
231 p := NewPopulatedC(popr, false)
232 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
233 if err != nil {
234 t.Fatalf("seed = %d, err = %v", seed, err)
235 }
236 msg := &C{}
237 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
238 t.Fatalf("seed = %d, err = %v", seed, err)
239 }
240 littlefuzz := make([]byte, len(dAtA))
241 copy(littlefuzz, dAtA)
242 for i := range dAtA {
243 dAtA[i] = byte(popr.Intn(256))
244 }
245 if err := p.VerboseEqual(msg); err != nil {
246 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
247 }
248 if !p.Equal(msg) {
249 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
250 }
251 if len(littlefuzz) > 0 {
252 fuzzamount := 100
253 for i := 0; i < fuzzamount; i++ {
254 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
255 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
256 }
257
258 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
259 }
260 }
261
262 func TestCMarshalTo(t *testing.T) {
263 seed := time.Now().UnixNano()
264 popr := math_rand.New(math_rand.NewSource(seed))
265 p := NewPopulatedC(popr, false)
266 size := p.Size()
267 dAtA := make([]byte, size)
268 for i := range dAtA {
269 dAtA[i] = byte(popr.Intn(256))
270 }
271 _, err := p.MarshalTo(dAtA)
272 if err != nil {
273 t.Fatalf("seed = %d, err = %v", seed, err)
274 }
275 msg := &C{}
276 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
277 t.Fatalf("seed = %d, err = %v", seed, err)
278 }
279 for i := range dAtA {
280 dAtA[i] = byte(popr.Intn(256))
281 }
282 if err := p.VerboseEqual(msg); err != nil {
283 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
284 }
285 if !p.Equal(msg) {
286 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
287 }
288 }
289
290 func BenchmarkCProtoMarshal(b *testing.B) {
291 popr := math_rand.New(math_rand.NewSource(616))
292 total := 0
293 pops := make([]*C, 10000)
294 for i := 0; i < 10000; i++ {
295 pops[i] = NewPopulatedC(popr, false)
296 }
297 b.ResetTimer()
298 for i := 0; i < b.N; i++ {
299 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
300 if err != nil {
301 panic(err)
302 }
303 total += len(dAtA)
304 }
305 b.SetBytes(int64(total / b.N))
306 }
307
308 func BenchmarkCProtoUnmarshal(b *testing.B) {
309 popr := math_rand.New(math_rand.NewSource(616))
310 total := 0
311 datas := make([][]byte, 10000)
312 for i := 0; i < 10000; i++ {
313 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedC(popr, false))
314 if err != nil {
315 panic(err)
316 }
317 datas[i] = dAtA
318 }
319 msg := &C{}
320 b.ResetTimer()
321 for i := 0; i < b.N; i++ {
322 total += len(datas[i%10000])
323 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
324 panic(err)
325 }
326 }
327 b.SetBytes(int64(total / b.N))
328 }
329
330 func TestUProto(t *testing.T) {
331 seed := time.Now().UnixNano()
332 popr := math_rand.New(math_rand.NewSource(seed))
333 p := NewPopulatedU(popr, false)
334 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
335 if err != nil {
336 t.Fatalf("seed = %d, err = %v", seed, err)
337 }
338 msg := &U{}
339 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
340 t.Fatalf("seed = %d, err = %v", seed, err)
341 }
342 littlefuzz := make([]byte, len(dAtA))
343 copy(littlefuzz, dAtA)
344 for i := range dAtA {
345 dAtA[i] = byte(popr.Intn(256))
346 }
347 if err := p.VerboseEqual(msg); err != nil {
348 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
349 }
350 if !p.Equal(msg) {
351 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
352 }
353 if len(littlefuzz) > 0 {
354 fuzzamount := 100
355 for i := 0; i < fuzzamount; i++ {
356 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
357 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
358 }
359
360 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
361 }
362 }
363
364 func TestUMarshalTo(t *testing.T) {
365 seed := time.Now().UnixNano()
366 popr := math_rand.New(math_rand.NewSource(seed))
367 p := NewPopulatedU(popr, false)
368 size := p.Size()
369 dAtA := make([]byte, size)
370 for i := range dAtA {
371 dAtA[i] = byte(popr.Intn(256))
372 }
373 _, err := p.MarshalTo(dAtA)
374 if err != nil {
375 t.Fatalf("seed = %d, err = %v", seed, err)
376 }
377 msg := &U{}
378 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
379 t.Fatalf("seed = %d, err = %v", seed, err)
380 }
381 for i := range dAtA {
382 dAtA[i] = byte(popr.Intn(256))
383 }
384 if err := p.VerboseEqual(msg); err != nil {
385 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
386 }
387 if !p.Equal(msg) {
388 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
389 }
390 }
391
392 func BenchmarkUProtoMarshal(b *testing.B) {
393 popr := math_rand.New(math_rand.NewSource(616))
394 total := 0
395 pops := make([]*U, 10000)
396 for i := 0; i < 10000; i++ {
397 pops[i] = NewPopulatedU(popr, false)
398 }
399 b.ResetTimer()
400 for i := 0; i < b.N; i++ {
401 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
402 if err != nil {
403 panic(err)
404 }
405 total += len(dAtA)
406 }
407 b.SetBytes(int64(total / b.N))
408 }
409
410 func BenchmarkUProtoUnmarshal(b *testing.B) {
411 popr := math_rand.New(math_rand.NewSource(616))
412 total := 0
413 datas := make([][]byte, 10000)
414 for i := 0; i < 10000; i++ {
415 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedU(popr, false))
416 if err != nil {
417 panic(err)
418 }
419 datas[i] = dAtA
420 }
421 msg := &U{}
422 b.ResetTimer()
423 for i := 0; i < b.N; i++ {
424 total += len(datas[i%10000])
425 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
426 panic(err)
427 }
428 }
429 b.SetBytes(int64(total / b.N))
430 }
431
432 func TestEProto(t *testing.T) {
433 seed := time.Now().UnixNano()
434 popr := math_rand.New(math_rand.NewSource(seed))
435 p := NewPopulatedE(popr, false)
436 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
437 if err != nil {
438 t.Fatalf("seed = %d, err = %v", seed, err)
439 }
440 msg := &E{}
441 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
442 t.Fatalf("seed = %d, err = %v", seed, err)
443 }
444 littlefuzz := make([]byte, len(dAtA))
445 copy(littlefuzz, dAtA)
446 for i := range dAtA {
447 dAtA[i] = byte(popr.Intn(256))
448 }
449 if err := p.VerboseEqual(msg); err != nil {
450 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
451 }
452 if !p.Equal(msg) {
453 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
454 }
455 if len(littlefuzz) > 0 {
456 fuzzamount := 100
457 for i := 0; i < fuzzamount; i++ {
458 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
459 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
460 }
461
462 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
463 }
464 }
465
466 func TestEMarshalTo(t *testing.T) {
467 seed := time.Now().UnixNano()
468 popr := math_rand.New(math_rand.NewSource(seed))
469 p := NewPopulatedE(popr, false)
470 size := p.Size()
471 dAtA := make([]byte, size)
472 for i := range dAtA {
473 dAtA[i] = byte(popr.Intn(256))
474 }
475 _, err := p.MarshalTo(dAtA)
476 if err != nil {
477 t.Fatalf("seed = %d, err = %v", seed, err)
478 }
479 msg := &E{}
480 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
481 t.Fatalf("seed = %d, err = %v", seed, err)
482 }
483 for i := range dAtA {
484 dAtA[i] = byte(popr.Intn(256))
485 }
486 if err := p.VerboseEqual(msg); err != nil {
487 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
488 }
489 if !p.Equal(msg) {
490 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
491 }
492 }
493
494 func BenchmarkEProtoMarshal(b *testing.B) {
495 popr := math_rand.New(math_rand.NewSource(616))
496 total := 0
497 pops := make([]*E, 10000)
498 for i := 0; i < 10000; i++ {
499 pops[i] = NewPopulatedE(popr, false)
500 }
501 b.ResetTimer()
502 for i := 0; i < b.N; i++ {
503 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
504 if err != nil {
505 panic(err)
506 }
507 total += len(dAtA)
508 }
509 b.SetBytes(int64(total / b.N))
510 }
511
512 func BenchmarkEProtoUnmarshal(b *testing.B) {
513 popr := math_rand.New(math_rand.NewSource(616))
514 total := 0
515 datas := make([][]byte, 10000)
516 for i := 0; i < 10000; i++ {
517 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedE(popr, false))
518 if err != nil {
519 panic(err)
520 }
521 datas[i] = dAtA
522 }
523 msg := &E{}
524 b.ResetTimer()
525 for i := 0; i < b.N; i++ {
526 total += len(datas[i%10000])
527 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
528 panic(err)
529 }
530 }
531 b.SetBytes(int64(total / b.N))
532 }
533
534 func TestRProto(t *testing.T) {
535 seed := time.Now().UnixNano()
536 popr := math_rand.New(math_rand.NewSource(seed))
537 p := NewPopulatedR(popr, false)
538 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
539 if err != nil {
540 t.Fatalf("seed = %d, err = %v", seed, err)
541 }
542 msg := &R{}
543 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
544 t.Fatalf("seed = %d, err = %v", seed, err)
545 }
546 littlefuzz := make([]byte, len(dAtA))
547 copy(littlefuzz, dAtA)
548 for i := range dAtA {
549 dAtA[i] = byte(popr.Intn(256))
550 }
551 if err := p.VerboseEqual(msg); err != nil {
552 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
553 }
554 if !p.Equal(msg) {
555 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
556 }
557 if len(littlefuzz) > 0 {
558 fuzzamount := 100
559 for i := 0; i < fuzzamount; i++ {
560 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
561 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
562 }
563
564 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
565 }
566 }
567
568 func TestRMarshalTo(t *testing.T) {
569 seed := time.Now().UnixNano()
570 popr := math_rand.New(math_rand.NewSource(seed))
571 p := NewPopulatedR(popr, false)
572 size := p.Size()
573 dAtA := make([]byte, size)
574 for i := range dAtA {
575 dAtA[i] = byte(popr.Intn(256))
576 }
577 _, err := p.MarshalTo(dAtA)
578 if err != nil {
579 t.Fatalf("seed = %d, err = %v", seed, err)
580 }
581 msg := &R{}
582 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
583 t.Fatalf("seed = %d, err = %v", seed, err)
584 }
585 for i := range dAtA {
586 dAtA[i] = byte(popr.Intn(256))
587 }
588 if err := p.VerboseEqual(msg); err != nil {
589 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
590 }
591 if !p.Equal(msg) {
592 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
593 }
594 }
595
596 func BenchmarkRProtoMarshal(b *testing.B) {
597 popr := math_rand.New(math_rand.NewSource(616))
598 total := 0
599 pops := make([]*R, 10000)
600 for i := 0; i < 10000; i++ {
601 pops[i] = NewPopulatedR(popr, false)
602 }
603 b.ResetTimer()
604 for i := 0; i < b.N; i++ {
605 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
606 if err != nil {
607 panic(err)
608 }
609 total += len(dAtA)
610 }
611 b.SetBytes(int64(total / b.N))
612 }
613
614 func BenchmarkRProtoUnmarshal(b *testing.B) {
615 popr := math_rand.New(math_rand.NewSource(616))
616 total := 0
617 datas := make([][]byte, 10000)
618 for i := 0; i < 10000; i++ {
619 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedR(popr, false))
620 if err != nil {
621 panic(err)
622 }
623 datas[i] = dAtA
624 }
625 msg := &R{}
626 b.ResetTimer()
627 for i := 0; i < b.N; i++ {
628 total += len(datas[i%10000])
629 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
630 panic(err)
631 }
632 }
633 b.SetBytes(int64(total / b.N))
634 }
635
636 func TestCastTypeProto(t *testing.T) {
637 seed := time.Now().UnixNano()
638 popr := math_rand.New(math_rand.NewSource(seed))
639 p := NewPopulatedCastType(popr, false)
640 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
641 if err != nil {
642 t.Fatalf("seed = %d, err = %v", seed, err)
643 }
644 msg := &CastType{}
645 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
646 t.Fatalf("seed = %d, err = %v", seed, err)
647 }
648 littlefuzz := make([]byte, len(dAtA))
649 copy(littlefuzz, dAtA)
650 for i := range dAtA {
651 dAtA[i] = byte(popr.Intn(256))
652 }
653 if err := p.VerboseEqual(msg); err != nil {
654 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
655 }
656 if !p.Equal(msg) {
657 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
658 }
659 if len(littlefuzz) > 0 {
660 fuzzamount := 100
661 for i := 0; i < fuzzamount; i++ {
662 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
663 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
664 }
665
666 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
667 }
668 }
669
670 func TestCastTypeMarshalTo(t *testing.T) {
671 seed := time.Now().UnixNano()
672 popr := math_rand.New(math_rand.NewSource(seed))
673 p := NewPopulatedCastType(popr, false)
674 size := p.Size()
675 dAtA := make([]byte, size)
676 for i := range dAtA {
677 dAtA[i] = byte(popr.Intn(256))
678 }
679 _, err := p.MarshalTo(dAtA)
680 if err != nil {
681 t.Fatalf("seed = %d, err = %v", seed, err)
682 }
683 msg := &CastType{}
684 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
685 t.Fatalf("seed = %d, err = %v", seed, err)
686 }
687 for i := range dAtA {
688 dAtA[i] = byte(popr.Intn(256))
689 }
690 if err := p.VerboseEqual(msg); err != nil {
691 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
692 }
693 if !p.Equal(msg) {
694 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
695 }
696 }
697
698 func BenchmarkCastTypeProtoMarshal(b *testing.B) {
699 popr := math_rand.New(math_rand.NewSource(616))
700 total := 0
701 pops := make([]*CastType, 10000)
702 for i := 0; i < 10000; i++ {
703 pops[i] = NewPopulatedCastType(popr, false)
704 }
705 b.ResetTimer()
706 for i := 0; i < b.N; i++ {
707 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
708 if err != nil {
709 panic(err)
710 }
711 total += len(dAtA)
712 }
713 b.SetBytes(int64(total / b.N))
714 }
715
716 func BenchmarkCastTypeProtoUnmarshal(b *testing.B) {
717 popr := math_rand.New(math_rand.NewSource(616))
718 total := 0
719 datas := make([][]byte, 10000)
720 for i := 0; i < 10000; i++ {
721 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastType(popr, false))
722 if err != nil {
723 panic(err)
724 }
725 datas[i] = dAtA
726 }
727 msg := &CastType{}
728 b.ResetTimer()
729 for i := 0; i < b.N; i++ {
730 total += len(datas[i%10000])
731 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
732 panic(err)
733 }
734 }
735 b.SetBytes(int64(total / b.N))
736 }
737
738 func TestAJSON(t *testing.T) {
739 seed := time.Now().UnixNano()
740 popr := math_rand.New(math_rand.NewSource(seed))
741 p := NewPopulatedA(popr, true)
742 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
743 jsondata, err := marshaler.MarshalToString(p)
744 if err != nil {
745 t.Fatalf("seed = %d, err = %v", seed, err)
746 }
747 msg := &A{}
748 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
749 if err != nil {
750 t.Fatalf("seed = %d, err = %v", seed, err)
751 }
752 if err := p.VerboseEqual(msg); err != nil {
753 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
754 }
755 if !p.Equal(msg) {
756 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
757 }
758 }
759 func TestBJSON(t *testing.T) {
760 seed := time.Now().UnixNano()
761 popr := math_rand.New(math_rand.NewSource(seed))
762 p := NewPopulatedB(popr, true)
763 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
764 jsondata, err := marshaler.MarshalToString(p)
765 if err != nil {
766 t.Fatalf("seed = %d, err = %v", seed, err)
767 }
768 msg := &B{}
769 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
770 if err != nil {
771 t.Fatalf("seed = %d, err = %v", seed, err)
772 }
773 if err := p.VerboseEqual(msg); err != nil {
774 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
775 }
776 if !p.Equal(msg) {
777 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
778 }
779 }
780 func TestCJSON(t *testing.T) {
781 seed := time.Now().UnixNano()
782 popr := math_rand.New(math_rand.NewSource(seed))
783 p := NewPopulatedC(popr, true)
784 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
785 jsondata, err := marshaler.MarshalToString(p)
786 if err != nil {
787 t.Fatalf("seed = %d, err = %v", seed, err)
788 }
789 msg := &C{}
790 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
791 if err != nil {
792 t.Fatalf("seed = %d, err = %v", seed, err)
793 }
794 if err := p.VerboseEqual(msg); err != nil {
795 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
796 }
797 if !p.Equal(msg) {
798 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
799 }
800 }
801 func TestUJSON(t *testing.T) {
802 seed := time.Now().UnixNano()
803 popr := math_rand.New(math_rand.NewSource(seed))
804 p := NewPopulatedU(popr, true)
805 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
806 jsondata, err := marshaler.MarshalToString(p)
807 if err != nil {
808 t.Fatalf("seed = %d, err = %v", seed, err)
809 }
810 msg := &U{}
811 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
812 if err != nil {
813 t.Fatalf("seed = %d, err = %v", seed, err)
814 }
815 if err := p.VerboseEqual(msg); err != nil {
816 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
817 }
818 if !p.Equal(msg) {
819 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
820 }
821 }
822 func TestEJSON(t *testing.T) {
823 seed := time.Now().UnixNano()
824 popr := math_rand.New(math_rand.NewSource(seed))
825 p := NewPopulatedE(popr, true)
826 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
827 jsondata, err := marshaler.MarshalToString(p)
828 if err != nil {
829 t.Fatalf("seed = %d, err = %v", seed, err)
830 }
831 msg := &E{}
832 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
833 if err != nil {
834 t.Fatalf("seed = %d, err = %v", seed, err)
835 }
836 if err := p.VerboseEqual(msg); err != nil {
837 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
838 }
839 if !p.Equal(msg) {
840 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
841 }
842 }
843 func TestRJSON(t *testing.T) {
844 seed := time.Now().UnixNano()
845 popr := math_rand.New(math_rand.NewSource(seed))
846 p := NewPopulatedR(popr, true)
847 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
848 jsondata, err := marshaler.MarshalToString(p)
849 if err != nil {
850 t.Fatalf("seed = %d, err = %v", seed, err)
851 }
852 msg := &R{}
853 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
854 if err != nil {
855 t.Fatalf("seed = %d, err = %v", seed, err)
856 }
857 if err := p.VerboseEqual(msg); err != nil {
858 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
859 }
860 if !p.Equal(msg) {
861 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
862 }
863 }
864 func TestCastTypeJSON(t *testing.T) {
865 seed := time.Now().UnixNano()
866 popr := math_rand.New(math_rand.NewSource(seed))
867 p := NewPopulatedCastType(popr, true)
868 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
869 jsondata, err := marshaler.MarshalToString(p)
870 if err != nil {
871 t.Fatalf("seed = %d, err = %v", seed, err)
872 }
873 msg := &CastType{}
874 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
875 if err != nil {
876 t.Fatalf("seed = %d, err = %v", seed, err)
877 }
878 if err := p.VerboseEqual(msg); err != nil {
879 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
880 }
881 if !p.Equal(msg) {
882 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
883 }
884 }
885 func TestAProtoText(t *testing.T) {
886 seed := time.Now().UnixNano()
887 popr := math_rand.New(math_rand.NewSource(seed))
888 p := NewPopulatedA(popr, true)
889 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
890 msg := &A{}
891 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
892 t.Fatalf("seed = %d, err = %v", seed, err)
893 }
894 if err := p.VerboseEqual(msg); err != nil {
895 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
896 }
897 if !p.Equal(msg) {
898 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
899 }
900 }
901
902 func TestAProtoCompactText(t *testing.T) {
903 seed := time.Now().UnixNano()
904 popr := math_rand.New(math_rand.NewSource(seed))
905 p := NewPopulatedA(popr, true)
906 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
907 msg := &A{}
908 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
909 t.Fatalf("seed = %d, err = %v", seed, err)
910 }
911 if err := p.VerboseEqual(msg); err != nil {
912 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
913 }
914 if !p.Equal(msg) {
915 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
916 }
917 }
918
919 func TestBProtoText(t *testing.T) {
920 seed := time.Now().UnixNano()
921 popr := math_rand.New(math_rand.NewSource(seed))
922 p := NewPopulatedB(popr, true)
923 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
924 msg := &B{}
925 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
926 t.Fatalf("seed = %d, err = %v", seed, err)
927 }
928 if err := p.VerboseEqual(msg); err != nil {
929 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
930 }
931 if !p.Equal(msg) {
932 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
933 }
934 }
935
936 func TestBProtoCompactText(t *testing.T) {
937 seed := time.Now().UnixNano()
938 popr := math_rand.New(math_rand.NewSource(seed))
939 p := NewPopulatedB(popr, true)
940 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
941 msg := &B{}
942 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
943 t.Fatalf("seed = %d, err = %v", seed, err)
944 }
945 if err := p.VerboseEqual(msg); err != nil {
946 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
947 }
948 if !p.Equal(msg) {
949 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
950 }
951 }
952
953 func TestCProtoText(t *testing.T) {
954 seed := time.Now().UnixNano()
955 popr := math_rand.New(math_rand.NewSource(seed))
956 p := NewPopulatedC(popr, true)
957 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
958 msg := &C{}
959 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
960 t.Fatalf("seed = %d, err = %v", seed, err)
961 }
962 if err := p.VerboseEqual(msg); err != nil {
963 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
964 }
965 if !p.Equal(msg) {
966 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
967 }
968 }
969
970 func TestCProtoCompactText(t *testing.T) {
971 seed := time.Now().UnixNano()
972 popr := math_rand.New(math_rand.NewSource(seed))
973 p := NewPopulatedC(popr, true)
974 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
975 msg := &C{}
976 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
977 t.Fatalf("seed = %d, err = %v", seed, err)
978 }
979 if err := p.VerboseEqual(msg); err != nil {
980 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
981 }
982 if !p.Equal(msg) {
983 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
984 }
985 }
986
987 func TestUProtoText(t *testing.T) {
988 seed := time.Now().UnixNano()
989 popr := math_rand.New(math_rand.NewSource(seed))
990 p := NewPopulatedU(popr, true)
991 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
992 msg := &U{}
993 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
994 t.Fatalf("seed = %d, err = %v", seed, err)
995 }
996 if err := p.VerboseEqual(msg); err != nil {
997 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
998 }
999 if !p.Equal(msg) {
1000 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1001 }
1002 }
1003
1004 func TestUProtoCompactText(t *testing.T) {
1005 seed := time.Now().UnixNano()
1006 popr := math_rand.New(math_rand.NewSource(seed))
1007 p := NewPopulatedU(popr, true)
1008 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1009 msg := &U{}
1010 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1011 t.Fatalf("seed = %d, err = %v", seed, err)
1012 }
1013 if err := p.VerboseEqual(msg); err != nil {
1014 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1015 }
1016 if !p.Equal(msg) {
1017 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1018 }
1019 }
1020
1021 func TestEProtoText(t *testing.T) {
1022 seed := time.Now().UnixNano()
1023 popr := math_rand.New(math_rand.NewSource(seed))
1024 p := NewPopulatedE(popr, true)
1025 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1026 msg := &E{}
1027 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1028 t.Fatalf("seed = %d, err = %v", seed, err)
1029 }
1030 if err := p.VerboseEqual(msg); err != nil {
1031 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1032 }
1033 if !p.Equal(msg) {
1034 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1035 }
1036 }
1037
1038 func TestEProtoCompactText(t *testing.T) {
1039 seed := time.Now().UnixNano()
1040 popr := math_rand.New(math_rand.NewSource(seed))
1041 p := NewPopulatedE(popr, true)
1042 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1043 msg := &E{}
1044 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1045 t.Fatalf("seed = %d, err = %v", seed, err)
1046 }
1047 if err := p.VerboseEqual(msg); err != nil {
1048 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1049 }
1050 if !p.Equal(msg) {
1051 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1052 }
1053 }
1054
1055 func TestRProtoText(t *testing.T) {
1056 seed := time.Now().UnixNano()
1057 popr := math_rand.New(math_rand.NewSource(seed))
1058 p := NewPopulatedR(popr, true)
1059 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1060 msg := &R{}
1061 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1062 t.Fatalf("seed = %d, err = %v", seed, err)
1063 }
1064 if err := p.VerboseEqual(msg); err != nil {
1065 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1066 }
1067 if !p.Equal(msg) {
1068 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1069 }
1070 }
1071
1072 func TestRProtoCompactText(t *testing.T) {
1073 seed := time.Now().UnixNano()
1074 popr := math_rand.New(math_rand.NewSource(seed))
1075 p := NewPopulatedR(popr, true)
1076 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1077 msg := &R{}
1078 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1079 t.Fatalf("seed = %d, err = %v", seed, err)
1080 }
1081 if err := p.VerboseEqual(msg); err != nil {
1082 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1083 }
1084 if !p.Equal(msg) {
1085 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1086 }
1087 }
1088
1089 func TestCastTypeProtoText(t *testing.T) {
1090 seed := time.Now().UnixNano()
1091 popr := math_rand.New(math_rand.NewSource(seed))
1092 p := NewPopulatedCastType(popr, true)
1093 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
1094 msg := &CastType{}
1095 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1096 t.Fatalf("seed = %d, err = %v", seed, err)
1097 }
1098 if err := p.VerboseEqual(msg); err != nil {
1099 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1100 }
1101 if !p.Equal(msg) {
1102 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1103 }
1104 }
1105
1106 func TestCastTypeProtoCompactText(t *testing.T) {
1107 seed := time.Now().UnixNano()
1108 popr := math_rand.New(math_rand.NewSource(seed))
1109 p := NewPopulatedCastType(popr, true)
1110 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
1111 msg := &CastType{}
1112 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
1113 t.Fatalf("seed = %d, err = %v", seed, err)
1114 }
1115 if err := p.VerboseEqual(msg); err != nil {
1116 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
1117 }
1118 if !p.Equal(msg) {
1119 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
1120 }
1121 }
1122
1123 func TestExampleDescription(t *testing.T) {
1124 ExampleDescription()
1125 }
1126 func TestAVerboseEqual(t *testing.T) {
1127 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1128 p := NewPopulatedA(popr, false)
1129 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1130 if err != nil {
1131 panic(err)
1132 }
1133 msg := &A{}
1134 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1135 panic(err)
1136 }
1137 if err := p.VerboseEqual(msg); err != nil {
1138 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1139 }
1140 }
1141 func TestBVerboseEqual(t *testing.T) {
1142 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1143 p := NewPopulatedB(popr, false)
1144 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1145 if err != nil {
1146 panic(err)
1147 }
1148 msg := &B{}
1149 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1150 panic(err)
1151 }
1152 if err := p.VerboseEqual(msg); err != nil {
1153 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1154 }
1155 }
1156 func TestCVerboseEqual(t *testing.T) {
1157 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1158 p := NewPopulatedC(popr, false)
1159 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1160 if err != nil {
1161 panic(err)
1162 }
1163 msg := &C{}
1164 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1165 panic(err)
1166 }
1167 if err := p.VerboseEqual(msg); err != nil {
1168 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1169 }
1170 }
1171 func TestUVerboseEqual(t *testing.T) {
1172 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1173 p := NewPopulatedU(popr, false)
1174 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1175 if err != nil {
1176 panic(err)
1177 }
1178 msg := &U{}
1179 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1180 panic(err)
1181 }
1182 if err := p.VerboseEqual(msg); err != nil {
1183 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1184 }
1185 }
1186 func TestEVerboseEqual(t *testing.T) {
1187 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1188 p := NewPopulatedE(popr, false)
1189 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1190 if err != nil {
1191 panic(err)
1192 }
1193 msg := &E{}
1194 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1195 panic(err)
1196 }
1197 if err := p.VerboseEqual(msg); err != nil {
1198 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1199 }
1200 }
1201 func TestRVerboseEqual(t *testing.T) {
1202 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1203 p := NewPopulatedR(popr, false)
1204 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1205 if err != nil {
1206 panic(err)
1207 }
1208 msg := &R{}
1209 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1210 panic(err)
1211 }
1212 if err := p.VerboseEqual(msg); err != nil {
1213 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1214 }
1215 }
1216 func TestCastTypeVerboseEqual(t *testing.T) {
1217 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1218 p := NewPopulatedCastType(popr, false)
1219 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1220 if err != nil {
1221 panic(err)
1222 }
1223 msg := &CastType{}
1224 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
1225 panic(err)
1226 }
1227 if err := p.VerboseEqual(msg); err != nil {
1228 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
1229 }
1230 }
1231 func TestAFace(t *testing.T) {
1232 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1233 p := NewPopulatedA(popr, true)
1234 msg := p.TestProto()
1235 if !p.Equal(msg) {
1236 t.Fatalf("%#v !Face Equal %#v", msg, p)
1237 }
1238 }
1239 func TestAGoString(t *testing.T) {
1240 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1241 p := NewPopulatedA(popr, false)
1242 s1 := p.GoString()
1243 s2 := fmt.Sprintf("%#v", p)
1244 if s1 != s2 {
1245 t.Fatalf("GoString want %v got %v", s1, s2)
1246 }
1247 _, err := go_parser.ParseExpr(s1)
1248 if err != nil {
1249 t.Fatal(err)
1250 }
1251 }
1252 func TestBGoString(t *testing.T) {
1253 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1254 p := NewPopulatedB(popr, false)
1255 s1 := p.GoString()
1256 s2 := fmt.Sprintf("%#v", p)
1257 if s1 != s2 {
1258 t.Fatalf("GoString want %v got %v", s1, s2)
1259 }
1260 _, err := go_parser.ParseExpr(s1)
1261 if err != nil {
1262 t.Fatal(err)
1263 }
1264 }
1265 func TestCGoString(t *testing.T) {
1266 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1267 p := NewPopulatedC(popr, false)
1268 s1 := p.GoString()
1269 s2 := fmt.Sprintf("%#v", p)
1270 if s1 != s2 {
1271 t.Fatalf("GoString want %v got %v", s1, s2)
1272 }
1273 _, err := go_parser.ParseExpr(s1)
1274 if err != nil {
1275 t.Fatal(err)
1276 }
1277 }
1278 func TestUGoString(t *testing.T) {
1279 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1280 p := NewPopulatedU(popr, false)
1281 s1 := p.GoString()
1282 s2 := fmt.Sprintf("%#v", p)
1283 if s1 != s2 {
1284 t.Fatalf("GoString want %v got %v", s1, s2)
1285 }
1286 _, err := go_parser.ParseExpr(s1)
1287 if err != nil {
1288 t.Fatal(err)
1289 }
1290 }
1291 func TestEGoString(t *testing.T) {
1292 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1293 p := NewPopulatedE(popr, false)
1294 s1 := p.GoString()
1295 s2 := fmt.Sprintf("%#v", p)
1296 if s1 != s2 {
1297 t.Fatalf("GoString want %v got %v", s1, s2)
1298 }
1299 _, err := go_parser.ParseExpr(s1)
1300 if err != nil {
1301 t.Fatal(err)
1302 }
1303 }
1304 func TestRGoString(t *testing.T) {
1305 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1306 p := NewPopulatedR(popr, false)
1307 s1 := p.GoString()
1308 s2 := fmt.Sprintf("%#v", p)
1309 if s1 != s2 {
1310 t.Fatalf("GoString want %v got %v", s1, s2)
1311 }
1312 _, err := go_parser.ParseExpr(s1)
1313 if err != nil {
1314 t.Fatal(err)
1315 }
1316 }
1317 func TestCastTypeGoString(t *testing.T) {
1318 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1319 p := NewPopulatedCastType(popr, false)
1320 s1 := p.GoString()
1321 s2 := fmt.Sprintf("%#v", p)
1322 if s1 != s2 {
1323 t.Fatalf("GoString want %v got %v", s1, s2)
1324 }
1325 _, err := go_parser.ParseExpr(s1)
1326 if err != nil {
1327 t.Fatal(err)
1328 }
1329 }
1330 func TestASize(t *testing.T) {
1331 seed := time.Now().UnixNano()
1332 popr := math_rand.New(math_rand.NewSource(seed))
1333 p := NewPopulatedA(popr, true)
1334 size2 := github_com_gogo_protobuf_proto.Size(p)
1335 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1336 if err != nil {
1337 t.Fatalf("seed = %d, err = %v", seed, err)
1338 }
1339 size := p.Size()
1340 if len(dAtA) != size {
1341 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1342 }
1343 if size2 != size {
1344 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1345 }
1346 size3 := github_com_gogo_protobuf_proto.Size(p)
1347 if size3 != size {
1348 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1349 }
1350 }
1351
1352 func BenchmarkASize(b *testing.B) {
1353 popr := math_rand.New(math_rand.NewSource(616))
1354 total := 0
1355 pops := make([]*A, 1000)
1356 for i := 0; i < 1000; i++ {
1357 pops[i] = NewPopulatedA(popr, false)
1358 }
1359 b.ResetTimer()
1360 for i := 0; i < b.N; i++ {
1361 total += pops[i%1000].Size()
1362 }
1363 b.SetBytes(int64(total / b.N))
1364 }
1365
1366 func TestBSize(t *testing.T) {
1367 seed := time.Now().UnixNano()
1368 popr := math_rand.New(math_rand.NewSource(seed))
1369 p := NewPopulatedB(popr, true)
1370 size2 := github_com_gogo_protobuf_proto.Size(p)
1371 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1372 if err != nil {
1373 t.Fatalf("seed = %d, err = %v", seed, err)
1374 }
1375 size := p.Size()
1376 if len(dAtA) != size {
1377 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1378 }
1379 if size2 != size {
1380 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1381 }
1382 size3 := github_com_gogo_protobuf_proto.Size(p)
1383 if size3 != size {
1384 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1385 }
1386 }
1387
1388 func BenchmarkBSize(b *testing.B) {
1389 popr := math_rand.New(math_rand.NewSource(616))
1390 total := 0
1391 pops := make([]*B, 1000)
1392 for i := 0; i < 1000; i++ {
1393 pops[i] = NewPopulatedB(popr, false)
1394 }
1395 b.ResetTimer()
1396 for i := 0; i < b.N; i++ {
1397 total += pops[i%1000].Size()
1398 }
1399 b.SetBytes(int64(total / b.N))
1400 }
1401
1402 func TestCSize(t *testing.T) {
1403 seed := time.Now().UnixNano()
1404 popr := math_rand.New(math_rand.NewSource(seed))
1405 p := NewPopulatedC(popr, true)
1406 size2 := github_com_gogo_protobuf_proto.Size(p)
1407 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1408 if err != nil {
1409 t.Fatalf("seed = %d, err = %v", seed, err)
1410 }
1411 size := p.Size()
1412 if len(dAtA) != size {
1413 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1414 }
1415 if size2 != size {
1416 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1417 }
1418 size3 := github_com_gogo_protobuf_proto.Size(p)
1419 if size3 != size {
1420 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1421 }
1422 }
1423
1424 func BenchmarkCSize(b *testing.B) {
1425 popr := math_rand.New(math_rand.NewSource(616))
1426 total := 0
1427 pops := make([]*C, 1000)
1428 for i := 0; i < 1000; i++ {
1429 pops[i] = NewPopulatedC(popr, false)
1430 }
1431 b.ResetTimer()
1432 for i := 0; i < b.N; i++ {
1433 total += pops[i%1000].Size()
1434 }
1435 b.SetBytes(int64(total / b.N))
1436 }
1437
1438 func TestUSize(t *testing.T) {
1439 seed := time.Now().UnixNano()
1440 popr := math_rand.New(math_rand.NewSource(seed))
1441 p := NewPopulatedU(popr, true)
1442 size2 := github_com_gogo_protobuf_proto.Size(p)
1443 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1444 if err != nil {
1445 t.Fatalf("seed = %d, err = %v", seed, err)
1446 }
1447 size := p.Size()
1448 if len(dAtA) != size {
1449 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1450 }
1451 if size2 != size {
1452 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1453 }
1454 size3 := github_com_gogo_protobuf_proto.Size(p)
1455 if size3 != size {
1456 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1457 }
1458 }
1459
1460 func BenchmarkUSize(b *testing.B) {
1461 popr := math_rand.New(math_rand.NewSource(616))
1462 total := 0
1463 pops := make([]*U, 1000)
1464 for i := 0; i < 1000; i++ {
1465 pops[i] = NewPopulatedU(popr, false)
1466 }
1467 b.ResetTimer()
1468 for i := 0; i < b.N; i++ {
1469 total += pops[i%1000].Size()
1470 }
1471 b.SetBytes(int64(total / b.N))
1472 }
1473
1474 func TestESize(t *testing.T) {
1475 seed := time.Now().UnixNano()
1476 popr := math_rand.New(math_rand.NewSource(seed))
1477 p := NewPopulatedE(popr, true)
1478 size2 := github_com_gogo_protobuf_proto.Size(p)
1479 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1480 if err != nil {
1481 t.Fatalf("seed = %d, err = %v", seed, err)
1482 }
1483 size := p.Size()
1484 if len(dAtA) != size {
1485 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1486 }
1487 if size2 != size {
1488 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1489 }
1490 size3 := github_com_gogo_protobuf_proto.Size(p)
1491 if size3 != size {
1492 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1493 }
1494 }
1495
1496 func BenchmarkESize(b *testing.B) {
1497 popr := math_rand.New(math_rand.NewSource(616))
1498 total := 0
1499 pops := make([]*E, 1000)
1500 for i := 0; i < 1000; i++ {
1501 pops[i] = NewPopulatedE(popr, false)
1502 }
1503 b.ResetTimer()
1504 for i := 0; i < b.N; i++ {
1505 total += pops[i%1000].Size()
1506 }
1507 b.SetBytes(int64(total / b.N))
1508 }
1509
1510 func TestRSize(t *testing.T) {
1511 seed := time.Now().UnixNano()
1512 popr := math_rand.New(math_rand.NewSource(seed))
1513 p := NewPopulatedR(popr, true)
1514 size2 := github_com_gogo_protobuf_proto.Size(p)
1515 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1516 if err != nil {
1517 t.Fatalf("seed = %d, err = %v", seed, err)
1518 }
1519 size := p.Size()
1520 if len(dAtA) != size {
1521 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1522 }
1523 if size2 != size {
1524 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1525 }
1526 size3 := github_com_gogo_protobuf_proto.Size(p)
1527 if size3 != size {
1528 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1529 }
1530 }
1531
1532 func BenchmarkRSize(b *testing.B) {
1533 popr := math_rand.New(math_rand.NewSource(616))
1534 total := 0
1535 pops := make([]*R, 1000)
1536 for i := 0; i < 1000; i++ {
1537 pops[i] = NewPopulatedR(popr, false)
1538 }
1539 b.ResetTimer()
1540 for i := 0; i < b.N; i++ {
1541 total += pops[i%1000].Size()
1542 }
1543 b.SetBytes(int64(total / b.N))
1544 }
1545
1546 func TestCastTypeSize(t *testing.T) {
1547 seed := time.Now().UnixNano()
1548 popr := math_rand.New(math_rand.NewSource(seed))
1549 p := NewPopulatedCastType(popr, true)
1550 size2 := github_com_gogo_protobuf_proto.Size(p)
1551 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
1552 if err != nil {
1553 t.Fatalf("seed = %d, err = %v", seed, err)
1554 }
1555 size := p.Size()
1556 if len(dAtA) != size {
1557 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
1558 }
1559 if size2 != size {
1560 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
1561 }
1562 size3 := github_com_gogo_protobuf_proto.Size(p)
1563 if size3 != size {
1564 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
1565 }
1566 }
1567
1568 func BenchmarkCastTypeSize(b *testing.B) {
1569 popr := math_rand.New(math_rand.NewSource(616))
1570 total := 0
1571 pops := make([]*CastType, 1000)
1572 for i := 0; i < 1000; i++ {
1573 pops[i] = NewPopulatedCastType(popr, false)
1574 }
1575 b.ResetTimer()
1576 for i := 0; i < b.N; i++ {
1577 total += pops[i%1000].Size()
1578 }
1579 b.SetBytes(int64(total / b.N))
1580 }
1581
1582 func TestAStringer(t *testing.T) {
1583 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1584 p := NewPopulatedA(popr, false)
1585 s1 := p.String()
1586 s2 := fmt.Sprintf("%v", p)
1587 if s1 != s2 {
1588 t.Fatalf("String want %v got %v", s1, s2)
1589 }
1590 }
1591 func TestBStringer(t *testing.T) {
1592 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1593 p := NewPopulatedB(popr, false)
1594 s1 := p.String()
1595 s2 := fmt.Sprintf("%v", p)
1596 if s1 != s2 {
1597 t.Fatalf("String want %v got %v", s1, s2)
1598 }
1599 }
1600 func TestCStringer(t *testing.T) {
1601 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1602 p := NewPopulatedC(popr, false)
1603 s1 := p.String()
1604 s2 := fmt.Sprintf("%v", p)
1605 if s1 != s2 {
1606 t.Fatalf("String want %v got %v", s1, s2)
1607 }
1608 }
1609 func TestUStringer(t *testing.T) {
1610 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1611 p := NewPopulatedU(popr, false)
1612 s1 := p.String()
1613 s2 := fmt.Sprintf("%v", p)
1614 if s1 != s2 {
1615 t.Fatalf("String want %v got %v", s1, s2)
1616 }
1617 }
1618 func TestEStringer(t *testing.T) {
1619 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1620 p := NewPopulatedE(popr, false)
1621 s1 := p.String()
1622 s2 := fmt.Sprintf("%v", p)
1623 if s1 != s2 {
1624 t.Fatalf("String want %v got %v", s1, s2)
1625 }
1626 }
1627 func TestRStringer(t *testing.T) {
1628 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1629 p := NewPopulatedR(popr, false)
1630 s1 := p.String()
1631 s2 := fmt.Sprintf("%v", p)
1632 if s1 != s2 {
1633 t.Fatalf("String want %v got %v", s1, s2)
1634 }
1635 }
1636 func TestCastTypeStringer(t *testing.T) {
1637 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1638 p := NewPopulatedCastType(popr, false)
1639 s1 := p.String()
1640 s2 := fmt.Sprintf("%v", p)
1641 if s1 != s2 {
1642 t.Fatalf("String want %v got %v", s1, s2)
1643 }
1644 }
1645 func TestUOnlyOne(t *testing.T) {
1646 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
1647 p := NewPopulatedU(popr, true)
1648 v := p.GetValue()
1649 msg := &U{}
1650 if !msg.SetValue(v) {
1651 t.Fatalf("OnlyOne: Could not set Value")
1652 }
1653 if !p.Equal(msg) {
1654 t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
1655 }
1656 }
1657
1658
1659
View as plain text