1
2
3
4 package proto2_maps
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 TestFloatingPointProto(t *testing.T) {
25 seed := time.Now().UnixNano()
26 popr := math_rand.New(math_rand.NewSource(seed))
27 p := NewPopulatedFloatingPoint(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 := &FloatingPoint{}
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 TestFloatingPointMarshalTo(t *testing.T) {
59 seed := time.Now().UnixNano()
60 popr := math_rand.New(math_rand.NewSource(seed))
61 p := NewPopulatedFloatingPoint(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 := &FloatingPoint{}
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 BenchmarkFloatingPointProtoMarshal(b *testing.B) {
87 popr := math_rand.New(math_rand.NewSource(616))
88 total := 0
89 pops := make([]*FloatingPoint, 10000)
90 for i := 0; i < 10000; i++ {
91 pops[i] = NewPopulatedFloatingPoint(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 BenchmarkFloatingPointProtoUnmarshal(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(NewPopulatedFloatingPoint(popr, false))
110 if err != nil {
111 panic(err)
112 }
113 datas[i] = dAtA
114 }
115 msg := &FloatingPoint{}
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 TestCustomMapProto(t *testing.T) {
127 seed := time.Now().UnixNano()
128 popr := math_rand.New(math_rand.NewSource(seed))
129 p := NewPopulatedCustomMap(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 := &CustomMap{}
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 TestCustomMapMarshalTo(t *testing.T) {
161 seed := time.Now().UnixNano()
162 popr := math_rand.New(math_rand.NewSource(seed))
163 p := NewPopulatedCustomMap(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 := &CustomMap{}
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 BenchmarkCustomMapProtoMarshal(b *testing.B) {
189 popr := math_rand.New(math_rand.NewSource(616))
190 total := 0
191 pops := make([]*CustomMap, 10000)
192 for i := 0; i < 10000; i++ {
193 pops[i] = NewPopulatedCustomMap(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 BenchmarkCustomMapProtoUnmarshal(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(NewPopulatedCustomMap(popr, false))
212 if err != nil {
213 panic(err)
214 }
215 datas[i] = dAtA
216 }
217 msg := &CustomMap{}
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 TestAllMapsProto(t *testing.T) {
229 seed := time.Now().UnixNano()
230 popr := math_rand.New(math_rand.NewSource(seed))
231 p := NewPopulatedAllMaps(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 := &AllMaps{}
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 TestAllMapsMarshalTo(t *testing.T) {
263 seed := time.Now().UnixNano()
264 popr := math_rand.New(math_rand.NewSource(seed))
265 p := NewPopulatedAllMaps(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 := &AllMaps{}
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 BenchmarkAllMapsProtoMarshal(b *testing.B) {
291 popr := math_rand.New(math_rand.NewSource(616))
292 total := 0
293 pops := make([]*AllMaps, 10000)
294 for i := 0; i < 10000; i++ {
295 pops[i] = NewPopulatedAllMaps(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 BenchmarkAllMapsProtoUnmarshal(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(NewPopulatedAllMaps(popr, false))
314 if err != nil {
315 panic(err)
316 }
317 datas[i] = dAtA
318 }
319 msg := &AllMaps{}
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 TestAllMapsOrderedProto(t *testing.T) {
331 seed := time.Now().UnixNano()
332 popr := math_rand.New(math_rand.NewSource(seed))
333 p := NewPopulatedAllMapsOrdered(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 := &AllMapsOrdered{}
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 TestAllMapsOrderedMarshalTo(t *testing.T) {
365 seed := time.Now().UnixNano()
366 popr := math_rand.New(math_rand.NewSource(seed))
367 p := NewPopulatedAllMapsOrdered(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 := &AllMapsOrdered{}
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 BenchmarkAllMapsOrderedProtoMarshal(b *testing.B) {
393 popr := math_rand.New(math_rand.NewSource(616))
394 total := 0
395 pops := make([]*AllMapsOrdered, 10000)
396 for i := 0; i < 10000; i++ {
397 pops[i] = NewPopulatedAllMapsOrdered(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 BenchmarkAllMapsOrderedProtoUnmarshal(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(NewPopulatedAllMapsOrdered(popr, false))
416 if err != nil {
417 panic(err)
418 }
419 datas[i] = dAtA
420 }
421 msg := &AllMapsOrdered{}
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 TestFloatingPointJSON(t *testing.T) {
433 seed := time.Now().UnixNano()
434 popr := math_rand.New(math_rand.NewSource(seed))
435 p := NewPopulatedFloatingPoint(popr, true)
436 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
437 jsondata, err := marshaler.MarshalToString(p)
438 if err != nil {
439 t.Fatalf("seed = %d, err = %v", seed, err)
440 }
441 msg := &FloatingPoint{}
442 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
443 if err != nil {
444 t.Fatalf("seed = %d, err = %v", seed, err)
445 }
446 if err := p.VerboseEqual(msg); err != nil {
447 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
448 }
449 if !p.Equal(msg) {
450 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
451 }
452 }
453 func TestCustomMapJSON(t *testing.T) {
454 seed := time.Now().UnixNano()
455 popr := math_rand.New(math_rand.NewSource(seed))
456 p := NewPopulatedCustomMap(popr, true)
457 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
458 jsondata, err := marshaler.MarshalToString(p)
459 if err != nil {
460 t.Fatalf("seed = %d, err = %v", seed, err)
461 }
462 msg := &CustomMap{}
463 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
464 if err != nil {
465 t.Fatalf("seed = %d, err = %v", seed, err)
466 }
467 if err := p.VerboseEqual(msg); err != nil {
468 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
469 }
470 if !p.Equal(msg) {
471 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
472 }
473 }
474 func TestAllMapsJSON(t *testing.T) {
475 seed := time.Now().UnixNano()
476 popr := math_rand.New(math_rand.NewSource(seed))
477 p := NewPopulatedAllMaps(popr, true)
478 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
479 jsondata, err := marshaler.MarshalToString(p)
480 if err != nil {
481 t.Fatalf("seed = %d, err = %v", seed, err)
482 }
483 msg := &AllMaps{}
484 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
485 if err != nil {
486 t.Fatalf("seed = %d, err = %v", seed, err)
487 }
488 if err := p.VerboseEqual(msg); err != nil {
489 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
490 }
491 if !p.Equal(msg) {
492 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
493 }
494 }
495 func TestAllMapsOrderedJSON(t *testing.T) {
496 seed := time.Now().UnixNano()
497 popr := math_rand.New(math_rand.NewSource(seed))
498 p := NewPopulatedAllMapsOrdered(popr, true)
499 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
500 jsondata, err := marshaler.MarshalToString(p)
501 if err != nil {
502 t.Fatalf("seed = %d, err = %v", seed, err)
503 }
504 msg := &AllMapsOrdered{}
505 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
506 if err != nil {
507 t.Fatalf("seed = %d, err = %v", seed, err)
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 !Json Equal %#v", seed, msg, p)
514 }
515 }
516 func TestFloatingPointProtoText(t *testing.T) {
517 seed := time.Now().UnixNano()
518 popr := math_rand.New(math_rand.NewSource(seed))
519 p := NewPopulatedFloatingPoint(popr, true)
520 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
521 msg := &FloatingPoint{}
522 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
523 t.Fatalf("seed = %d, err = %v", seed, err)
524 }
525 if err := p.VerboseEqual(msg); err != nil {
526 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
527 }
528 if !p.Equal(msg) {
529 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
530 }
531 }
532
533 func TestFloatingPointProtoCompactText(t *testing.T) {
534 seed := time.Now().UnixNano()
535 popr := math_rand.New(math_rand.NewSource(seed))
536 p := NewPopulatedFloatingPoint(popr, true)
537 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
538 msg := &FloatingPoint{}
539 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
540 t.Fatalf("seed = %d, err = %v", seed, err)
541 }
542 if err := p.VerboseEqual(msg); err != nil {
543 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
544 }
545 if !p.Equal(msg) {
546 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
547 }
548 }
549
550 func TestCustomMapProtoText(t *testing.T) {
551 seed := time.Now().UnixNano()
552 popr := math_rand.New(math_rand.NewSource(seed))
553 p := NewPopulatedCustomMap(popr, true)
554 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
555 msg := &CustomMap{}
556 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
557 t.Fatalf("seed = %d, err = %v", seed, err)
558 }
559 if err := p.VerboseEqual(msg); err != nil {
560 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
561 }
562 if !p.Equal(msg) {
563 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
564 }
565 }
566
567 func TestCustomMapProtoCompactText(t *testing.T) {
568 seed := time.Now().UnixNano()
569 popr := math_rand.New(math_rand.NewSource(seed))
570 p := NewPopulatedCustomMap(popr, true)
571 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
572 msg := &CustomMap{}
573 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
574 t.Fatalf("seed = %d, err = %v", seed, err)
575 }
576 if err := p.VerboseEqual(msg); err != nil {
577 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
578 }
579 if !p.Equal(msg) {
580 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
581 }
582 }
583
584 func TestAllMapsProtoText(t *testing.T) {
585 seed := time.Now().UnixNano()
586 popr := math_rand.New(math_rand.NewSource(seed))
587 p := NewPopulatedAllMaps(popr, true)
588 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
589 msg := &AllMaps{}
590 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
591 t.Fatalf("seed = %d, err = %v", seed, err)
592 }
593 if err := p.VerboseEqual(msg); err != nil {
594 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
595 }
596 if !p.Equal(msg) {
597 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
598 }
599 }
600
601 func TestAllMapsProtoCompactText(t *testing.T) {
602 seed := time.Now().UnixNano()
603 popr := math_rand.New(math_rand.NewSource(seed))
604 p := NewPopulatedAllMaps(popr, true)
605 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
606 msg := &AllMaps{}
607 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
608 t.Fatalf("seed = %d, err = %v", seed, err)
609 }
610 if err := p.VerboseEqual(msg); err != nil {
611 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
612 }
613 if !p.Equal(msg) {
614 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
615 }
616 }
617
618 func TestAllMapsOrderedProtoText(t *testing.T) {
619 seed := time.Now().UnixNano()
620 popr := math_rand.New(math_rand.NewSource(seed))
621 p := NewPopulatedAllMapsOrdered(popr, true)
622 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
623 msg := &AllMapsOrdered{}
624 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
625 t.Fatalf("seed = %d, err = %v", seed, err)
626 }
627 if err := p.VerboseEqual(msg); err != nil {
628 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
629 }
630 if !p.Equal(msg) {
631 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
632 }
633 }
634
635 func TestAllMapsOrderedProtoCompactText(t *testing.T) {
636 seed := time.Now().UnixNano()
637 popr := math_rand.New(math_rand.NewSource(seed))
638 p := NewPopulatedAllMapsOrdered(popr, true)
639 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
640 msg := &AllMapsOrdered{}
641 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
642 t.Fatalf("seed = %d, err = %v", seed, err)
643 }
644 if err := p.VerboseEqual(msg); err != nil {
645 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
646 }
647 if !p.Equal(msg) {
648 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
649 }
650 }
651
652 func TestMapsproto2Description(t *testing.T) {
653 Mapsproto2Description()
654 }
655 func TestFloatingPointVerboseEqual(t *testing.T) {
656 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
657 p := NewPopulatedFloatingPoint(popr, false)
658 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
659 if err != nil {
660 panic(err)
661 }
662 msg := &FloatingPoint{}
663 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
664 panic(err)
665 }
666 if err := p.VerboseEqual(msg); err != nil {
667 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
668 }
669 }
670 func TestCustomMapVerboseEqual(t *testing.T) {
671 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
672 p := NewPopulatedCustomMap(popr, false)
673 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
674 if err != nil {
675 panic(err)
676 }
677 msg := &CustomMap{}
678 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
679 panic(err)
680 }
681 if err := p.VerboseEqual(msg); err != nil {
682 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
683 }
684 }
685 func TestAllMapsVerboseEqual(t *testing.T) {
686 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
687 p := NewPopulatedAllMaps(popr, false)
688 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
689 if err != nil {
690 panic(err)
691 }
692 msg := &AllMaps{}
693 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
694 panic(err)
695 }
696 if err := p.VerboseEqual(msg); err != nil {
697 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
698 }
699 }
700 func TestAllMapsOrderedVerboseEqual(t *testing.T) {
701 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
702 p := NewPopulatedAllMapsOrdered(popr, false)
703 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
704 if err != nil {
705 panic(err)
706 }
707 msg := &AllMapsOrdered{}
708 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
709 panic(err)
710 }
711 if err := p.VerboseEqual(msg); err != nil {
712 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
713 }
714 }
715 func TestFloatingPointFace(t *testing.T) {
716 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
717 p := NewPopulatedFloatingPoint(popr, true)
718 msg := p.TestProto()
719 if !p.Equal(msg) {
720 t.Fatalf("%#v !Face Equal %#v", msg, p)
721 }
722 }
723 func TestCustomMapFace(t *testing.T) {
724 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
725 p := NewPopulatedCustomMap(popr, true)
726 msg := p.TestProto()
727 if !p.Equal(msg) {
728 t.Fatalf("%#v !Face Equal %#v", msg, p)
729 }
730 }
731 func TestAllMapsFace(t *testing.T) {
732 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
733 p := NewPopulatedAllMaps(popr, true)
734 msg := p.TestProto()
735 if !p.Equal(msg) {
736 t.Fatalf("%#v !Face Equal %#v", msg, p)
737 }
738 }
739 func TestAllMapsOrderedFace(t *testing.T) {
740 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
741 p := NewPopulatedAllMapsOrdered(popr, true)
742 msg := p.TestProto()
743 if !p.Equal(msg) {
744 t.Fatalf("%#v !Face Equal %#v", msg, p)
745 }
746 }
747 func TestFloatingPointGoString(t *testing.T) {
748 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
749 p := NewPopulatedFloatingPoint(popr, false)
750 s1 := p.GoString()
751 s2 := fmt.Sprintf("%#v", p)
752 if s1 != s2 {
753 t.Fatalf("GoString want %v got %v", s1, s2)
754 }
755 _, err := go_parser.ParseExpr(s1)
756 if err != nil {
757 t.Fatal(err)
758 }
759 }
760 func TestCustomMapGoString(t *testing.T) {
761 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
762 p := NewPopulatedCustomMap(popr, false)
763 s1 := p.GoString()
764 s2 := fmt.Sprintf("%#v", p)
765 if s1 != s2 {
766 t.Fatalf("GoString want %v got %v", s1, s2)
767 }
768 _, err := go_parser.ParseExpr(s1)
769 if err != nil {
770 t.Fatal(err)
771 }
772 }
773 func TestAllMapsGoString(t *testing.T) {
774 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
775 p := NewPopulatedAllMaps(popr, false)
776 s1 := p.GoString()
777 s2 := fmt.Sprintf("%#v", p)
778 if s1 != s2 {
779 t.Fatalf("GoString want %v got %v", s1, s2)
780 }
781 _, err := go_parser.ParseExpr(s1)
782 if err != nil {
783 t.Fatal(err)
784 }
785 }
786 func TestAllMapsOrderedGoString(t *testing.T) {
787 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
788 p := NewPopulatedAllMapsOrdered(popr, false)
789 s1 := p.GoString()
790 s2 := fmt.Sprintf("%#v", p)
791 if s1 != s2 {
792 t.Fatalf("GoString want %v got %v", s1, s2)
793 }
794 _, err := go_parser.ParseExpr(s1)
795 if err != nil {
796 t.Fatal(err)
797 }
798 }
799 func TestFloatingPointSize(t *testing.T) {
800 seed := time.Now().UnixNano()
801 popr := math_rand.New(math_rand.NewSource(seed))
802 p := NewPopulatedFloatingPoint(popr, true)
803 size2 := github_com_gogo_protobuf_proto.Size(p)
804 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
805 if err != nil {
806 t.Fatalf("seed = %d, err = %v", seed, err)
807 }
808 size := p.Size()
809 if len(dAtA) != size {
810 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
811 }
812 if size2 != size {
813 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
814 }
815 size3 := github_com_gogo_protobuf_proto.Size(p)
816 if size3 != size {
817 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
818 }
819 }
820
821 func BenchmarkFloatingPointSize(b *testing.B) {
822 popr := math_rand.New(math_rand.NewSource(616))
823 total := 0
824 pops := make([]*FloatingPoint, 1000)
825 for i := 0; i < 1000; i++ {
826 pops[i] = NewPopulatedFloatingPoint(popr, false)
827 }
828 b.ResetTimer()
829 for i := 0; i < b.N; i++ {
830 total += pops[i%1000].Size()
831 }
832 b.SetBytes(int64(total / b.N))
833 }
834
835 func TestCustomMapSize(t *testing.T) {
836 seed := time.Now().UnixNano()
837 popr := math_rand.New(math_rand.NewSource(seed))
838 p := NewPopulatedCustomMap(popr, true)
839 size2 := github_com_gogo_protobuf_proto.Size(p)
840 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
841 if err != nil {
842 t.Fatalf("seed = %d, err = %v", seed, err)
843 }
844 size := p.Size()
845 if len(dAtA) != size {
846 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
847 }
848 if size2 != size {
849 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
850 }
851 size3 := github_com_gogo_protobuf_proto.Size(p)
852 if size3 != size {
853 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
854 }
855 }
856
857 func BenchmarkCustomMapSize(b *testing.B) {
858 popr := math_rand.New(math_rand.NewSource(616))
859 total := 0
860 pops := make([]*CustomMap, 1000)
861 for i := 0; i < 1000; i++ {
862 pops[i] = NewPopulatedCustomMap(popr, false)
863 }
864 b.ResetTimer()
865 for i := 0; i < b.N; i++ {
866 total += pops[i%1000].Size()
867 }
868 b.SetBytes(int64(total / b.N))
869 }
870
871 func TestAllMapsSize(t *testing.T) {
872 seed := time.Now().UnixNano()
873 popr := math_rand.New(math_rand.NewSource(seed))
874 p := NewPopulatedAllMaps(popr, true)
875 size2 := github_com_gogo_protobuf_proto.Size(p)
876 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
877 if err != nil {
878 t.Fatalf("seed = %d, err = %v", seed, err)
879 }
880 size := p.Size()
881 if len(dAtA) != size {
882 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
883 }
884 if size2 != size {
885 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
886 }
887 size3 := github_com_gogo_protobuf_proto.Size(p)
888 if size3 != size {
889 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
890 }
891 }
892
893 func BenchmarkAllMapsSize(b *testing.B) {
894 popr := math_rand.New(math_rand.NewSource(616))
895 total := 0
896 pops := make([]*AllMaps, 1000)
897 for i := 0; i < 1000; i++ {
898 pops[i] = NewPopulatedAllMaps(popr, false)
899 }
900 b.ResetTimer()
901 for i := 0; i < b.N; i++ {
902 total += pops[i%1000].Size()
903 }
904 b.SetBytes(int64(total / b.N))
905 }
906
907 func TestAllMapsOrderedSize(t *testing.T) {
908 seed := time.Now().UnixNano()
909 popr := math_rand.New(math_rand.NewSource(seed))
910 p := NewPopulatedAllMapsOrdered(popr, true)
911 size2 := github_com_gogo_protobuf_proto.Size(p)
912 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
913 if err != nil {
914 t.Fatalf("seed = %d, err = %v", seed, err)
915 }
916 size := p.Size()
917 if len(dAtA) != size {
918 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
919 }
920 if size2 != size {
921 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
922 }
923 size3 := github_com_gogo_protobuf_proto.Size(p)
924 if size3 != size {
925 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
926 }
927 }
928
929 func BenchmarkAllMapsOrderedSize(b *testing.B) {
930 popr := math_rand.New(math_rand.NewSource(616))
931 total := 0
932 pops := make([]*AllMapsOrdered, 1000)
933 for i := 0; i < 1000; i++ {
934 pops[i] = NewPopulatedAllMapsOrdered(popr, false)
935 }
936 b.ResetTimer()
937 for i := 0; i < b.N; i++ {
938 total += pops[i%1000].Size()
939 }
940 b.SetBytes(int64(total / b.N))
941 }
942
943 func TestFloatingPointStringer(t *testing.T) {
944 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
945 p := NewPopulatedFloatingPoint(popr, false)
946 s1 := p.String()
947 s2 := fmt.Sprintf("%v", p)
948 if s1 != s2 {
949 t.Fatalf("String want %v got %v", s1, s2)
950 }
951 }
952 func TestCustomMapStringer(t *testing.T) {
953 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
954 p := NewPopulatedCustomMap(popr, false)
955 s1 := p.String()
956 s2 := fmt.Sprintf("%v", p)
957 if s1 != s2 {
958 t.Fatalf("String want %v got %v", s1, s2)
959 }
960 }
961 func TestAllMapsStringer(t *testing.T) {
962 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
963 p := NewPopulatedAllMaps(popr, false)
964 s1 := p.String()
965 s2 := fmt.Sprintf("%v", p)
966 if s1 != s2 {
967 t.Fatalf("String want %v got %v", s1, s2)
968 }
969 }
970 func TestAllMapsOrderedStringer(t *testing.T) {
971 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
972 p := NewPopulatedAllMapsOrdered(popr, false)
973 s1 := p.String()
974 s2 := fmt.Sprintf("%v", p)
975 if s1 != s2 {
976 t.Fatalf("String want %v got %v", s1, s2)
977 }
978 }
979
980
981
View as plain text