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 BenchmarkFloatingPointProtoMarshal(b *testing.B) {
59 popr := math_rand.New(math_rand.NewSource(616))
60 total := 0
61 pops := make([]*FloatingPoint, 10000)
62 for i := 0; i < 10000; i++ {
63 pops[i] = NewPopulatedFloatingPoint(popr, false)
64 }
65 b.ResetTimer()
66 for i := 0; i < b.N; i++ {
67 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
68 if err != nil {
69 panic(err)
70 }
71 total += len(dAtA)
72 }
73 b.SetBytes(int64(total / b.N))
74 }
75
76 func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) {
77 popr := math_rand.New(math_rand.NewSource(616))
78 total := 0
79 datas := make([][]byte, 10000)
80 for i := 0; i < 10000; i++ {
81 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false))
82 if err != nil {
83 panic(err)
84 }
85 datas[i] = dAtA
86 }
87 msg := &FloatingPoint{}
88 b.ResetTimer()
89 for i := 0; i < b.N; i++ {
90 total += len(datas[i%10000])
91 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
92 panic(err)
93 }
94 }
95 b.SetBytes(int64(total / b.N))
96 }
97
98 func TestCustomMapProto(t *testing.T) {
99 seed := time.Now().UnixNano()
100 popr := math_rand.New(math_rand.NewSource(seed))
101 p := NewPopulatedCustomMap(popr, false)
102 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
103 if err != nil {
104 t.Fatalf("seed = %d, err = %v", seed, err)
105 }
106 msg := &CustomMap{}
107 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
108 t.Fatalf("seed = %d, err = %v", seed, err)
109 }
110 littlefuzz := make([]byte, len(dAtA))
111 copy(littlefuzz, dAtA)
112 for i := range dAtA {
113 dAtA[i] = byte(popr.Intn(256))
114 }
115 if err := p.VerboseEqual(msg); err != nil {
116 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
117 }
118 if !p.Equal(msg) {
119 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
120 }
121 if len(littlefuzz) > 0 {
122 fuzzamount := 100
123 for i := 0; i < fuzzamount; i++ {
124 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
125 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
126 }
127
128 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
129 }
130 }
131
132 func BenchmarkCustomMapProtoMarshal(b *testing.B) {
133 popr := math_rand.New(math_rand.NewSource(616))
134 total := 0
135 pops := make([]*CustomMap, 10000)
136 for i := 0; i < 10000; i++ {
137 pops[i] = NewPopulatedCustomMap(popr, false)
138 }
139 b.ResetTimer()
140 for i := 0; i < b.N; i++ {
141 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
142 if err != nil {
143 panic(err)
144 }
145 total += len(dAtA)
146 }
147 b.SetBytes(int64(total / b.N))
148 }
149
150 func BenchmarkCustomMapProtoUnmarshal(b *testing.B) {
151 popr := math_rand.New(math_rand.NewSource(616))
152 total := 0
153 datas := make([][]byte, 10000)
154 for i := 0; i < 10000; i++ {
155 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomMap(popr, false))
156 if err != nil {
157 panic(err)
158 }
159 datas[i] = dAtA
160 }
161 msg := &CustomMap{}
162 b.ResetTimer()
163 for i := 0; i < b.N; i++ {
164 total += len(datas[i%10000])
165 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
166 panic(err)
167 }
168 }
169 b.SetBytes(int64(total / b.N))
170 }
171
172 func TestAllMapsProto(t *testing.T) {
173 seed := time.Now().UnixNano()
174 popr := math_rand.New(math_rand.NewSource(seed))
175 p := NewPopulatedAllMaps(popr, false)
176 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
177 if err != nil {
178 t.Fatalf("seed = %d, err = %v", seed, err)
179 }
180 msg := &AllMaps{}
181 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
182 t.Fatalf("seed = %d, err = %v", seed, err)
183 }
184 littlefuzz := make([]byte, len(dAtA))
185 copy(littlefuzz, dAtA)
186 for i := range dAtA {
187 dAtA[i] = byte(popr.Intn(256))
188 }
189 if err := p.VerboseEqual(msg); err != nil {
190 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
191 }
192 if !p.Equal(msg) {
193 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
194 }
195 if len(littlefuzz) > 0 {
196 fuzzamount := 100
197 for i := 0; i < fuzzamount; i++ {
198 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
199 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
200 }
201
202 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
203 }
204 }
205
206 func BenchmarkAllMapsProtoMarshal(b *testing.B) {
207 popr := math_rand.New(math_rand.NewSource(616))
208 total := 0
209 pops := make([]*AllMaps, 10000)
210 for i := 0; i < 10000; i++ {
211 pops[i] = NewPopulatedAllMaps(popr, false)
212 }
213 b.ResetTimer()
214 for i := 0; i < b.N; i++ {
215 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
216 if err != nil {
217 panic(err)
218 }
219 total += len(dAtA)
220 }
221 b.SetBytes(int64(total / b.N))
222 }
223
224 func BenchmarkAllMapsProtoUnmarshal(b *testing.B) {
225 popr := math_rand.New(math_rand.NewSource(616))
226 total := 0
227 datas := make([][]byte, 10000)
228 for i := 0; i < 10000; i++ {
229 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false))
230 if err != nil {
231 panic(err)
232 }
233 datas[i] = dAtA
234 }
235 msg := &AllMaps{}
236 b.ResetTimer()
237 for i := 0; i < b.N; i++ {
238 total += len(datas[i%10000])
239 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
240 panic(err)
241 }
242 }
243 b.SetBytes(int64(total / b.N))
244 }
245
246 func TestAllMapsOrderedProto(t *testing.T) {
247 seed := time.Now().UnixNano()
248 popr := math_rand.New(math_rand.NewSource(seed))
249 p := NewPopulatedAllMapsOrdered(popr, false)
250 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
251 if err != nil {
252 t.Fatalf("seed = %d, err = %v", seed, err)
253 }
254 msg := &AllMapsOrdered{}
255 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
256 t.Fatalf("seed = %d, err = %v", seed, err)
257 }
258 littlefuzz := make([]byte, len(dAtA))
259 copy(littlefuzz, dAtA)
260 for i := range dAtA {
261 dAtA[i] = byte(popr.Intn(256))
262 }
263 if err := p.VerboseEqual(msg); err != nil {
264 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
265 }
266 if !p.Equal(msg) {
267 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
268 }
269 if len(littlefuzz) > 0 {
270 fuzzamount := 100
271 for i := 0; i < fuzzamount; i++ {
272 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
273 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
274 }
275
276 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
277 }
278 }
279
280 func BenchmarkAllMapsOrderedProtoMarshal(b *testing.B) {
281 popr := math_rand.New(math_rand.NewSource(616))
282 total := 0
283 pops := make([]*AllMapsOrdered, 10000)
284 for i := 0; i < 10000; i++ {
285 pops[i] = NewPopulatedAllMapsOrdered(popr, false)
286 }
287 b.ResetTimer()
288 for i := 0; i < b.N; i++ {
289 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
290 if err != nil {
291 panic(err)
292 }
293 total += len(dAtA)
294 }
295 b.SetBytes(int64(total / b.N))
296 }
297
298 func BenchmarkAllMapsOrderedProtoUnmarshal(b *testing.B) {
299 popr := math_rand.New(math_rand.NewSource(616))
300 total := 0
301 datas := make([][]byte, 10000)
302 for i := 0; i < 10000; i++ {
303 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMapsOrdered(popr, false))
304 if err != nil {
305 panic(err)
306 }
307 datas[i] = dAtA
308 }
309 msg := &AllMapsOrdered{}
310 b.ResetTimer()
311 for i := 0; i < b.N; i++ {
312 total += len(datas[i%10000])
313 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
314 panic(err)
315 }
316 }
317 b.SetBytes(int64(total / b.N))
318 }
319
320 func TestFloatingPointJSON(t *testing.T) {
321 seed := time.Now().UnixNano()
322 popr := math_rand.New(math_rand.NewSource(seed))
323 p := NewPopulatedFloatingPoint(popr, true)
324 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
325 jsondata, err := marshaler.MarshalToString(p)
326 if err != nil {
327 t.Fatalf("seed = %d, err = %v", seed, err)
328 }
329 msg := &FloatingPoint{}
330 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
331 if err != nil {
332 t.Fatalf("seed = %d, err = %v", seed, err)
333 }
334 if err := p.VerboseEqual(msg); err != nil {
335 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
336 }
337 if !p.Equal(msg) {
338 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
339 }
340 }
341 func TestCustomMapJSON(t *testing.T) {
342 seed := time.Now().UnixNano()
343 popr := math_rand.New(math_rand.NewSource(seed))
344 p := NewPopulatedCustomMap(popr, true)
345 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
346 jsondata, err := marshaler.MarshalToString(p)
347 if err != nil {
348 t.Fatalf("seed = %d, err = %v", seed, err)
349 }
350 msg := &CustomMap{}
351 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
352 if err != nil {
353 t.Fatalf("seed = %d, err = %v", seed, err)
354 }
355 if err := p.VerboseEqual(msg); err != nil {
356 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
357 }
358 if !p.Equal(msg) {
359 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
360 }
361 }
362 func TestAllMapsJSON(t *testing.T) {
363 seed := time.Now().UnixNano()
364 popr := math_rand.New(math_rand.NewSource(seed))
365 p := NewPopulatedAllMaps(popr, true)
366 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
367 jsondata, err := marshaler.MarshalToString(p)
368 if err != nil {
369 t.Fatalf("seed = %d, err = %v", seed, err)
370 }
371 msg := &AllMaps{}
372 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
373 if err != nil {
374 t.Fatalf("seed = %d, err = %v", seed, err)
375 }
376 if err := p.VerboseEqual(msg); err != nil {
377 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
378 }
379 if !p.Equal(msg) {
380 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
381 }
382 }
383 func TestAllMapsOrderedJSON(t *testing.T) {
384 seed := time.Now().UnixNano()
385 popr := math_rand.New(math_rand.NewSource(seed))
386 p := NewPopulatedAllMapsOrdered(popr, true)
387 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
388 jsondata, err := marshaler.MarshalToString(p)
389 if err != nil {
390 t.Fatalf("seed = %d, err = %v", seed, err)
391 }
392 msg := &AllMapsOrdered{}
393 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
394 if err != nil {
395 t.Fatalf("seed = %d, err = %v", seed, err)
396 }
397 if err := p.VerboseEqual(msg); err != nil {
398 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
399 }
400 if !p.Equal(msg) {
401 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
402 }
403 }
404 func TestFloatingPointProtoText(t *testing.T) {
405 seed := time.Now().UnixNano()
406 popr := math_rand.New(math_rand.NewSource(seed))
407 p := NewPopulatedFloatingPoint(popr, true)
408 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
409 msg := &FloatingPoint{}
410 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
411 t.Fatalf("seed = %d, err = %v", seed, err)
412 }
413 if err := p.VerboseEqual(msg); err != nil {
414 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
415 }
416 if !p.Equal(msg) {
417 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
418 }
419 }
420
421 func TestFloatingPointProtoCompactText(t *testing.T) {
422 seed := time.Now().UnixNano()
423 popr := math_rand.New(math_rand.NewSource(seed))
424 p := NewPopulatedFloatingPoint(popr, true)
425 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
426 msg := &FloatingPoint{}
427 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
428 t.Fatalf("seed = %d, err = %v", seed, err)
429 }
430 if err := p.VerboseEqual(msg); err != nil {
431 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
432 }
433 if !p.Equal(msg) {
434 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
435 }
436 }
437
438 func TestCustomMapProtoText(t *testing.T) {
439 seed := time.Now().UnixNano()
440 popr := math_rand.New(math_rand.NewSource(seed))
441 p := NewPopulatedCustomMap(popr, true)
442 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
443 msg := &CustomMap{}
444 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
445 t.Fatalf("seed = %d, err = %v", seed, err)
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 }
454
455 func TestCustomMapProtoCompactText(t *testing.T) {
456 seed := time.Now().UnixNano()
457 popr := math_rand.New(math_rand.NewSource(seed))
458 p := NewPopulatedCustomMap(popr, true)
459 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
460 msg := &CustomMap{}
461 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
462 t.Fatalf("seed = %d, err = %v", seed, err)
463 }
464 if err := p.VerboseEqual(msg); err != nil {
465 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
466 }
467 if !p.Equal(msg) {
468 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
469 }
470 }
471
472 func TestAllMapsProtoText(t *testing.T) {
473 seed := time.Now().UnixNano()
474 popr := math_rand.New(math_rand.NewSource(seed))
475 p := NewPopulatedAllMaps(popr, true)
476 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
477 msg := &AllMaps{}
478 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
479 t.Fatalf("seed = %d, err = %v", seed, err)
480 }
481 if err := p.VerboseEqual(msg); err != nil {
482 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
483 }
484 if !p.Equal(msg) {
485 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
486 }
487 }
488
489 func TestAllMapsProtoCompactText(t *testing.T) {
490 seed := time.Now().UnixNano()
491 popr := math_rand.New(math_rand.NewSource(seed))
492 p := NewPopulatedAllMaps(popr, true)
493 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
494 msg := &AllMaps{}
495 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
496 t.Fatalf("seed = %d, err = %v", seed, err)
497 }
498 if err := p.VerboseEqual(msg); err != nil {
499 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
500 }
501 if !p.Equal(msg) {
502 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
503 }
504 }
505
506 func TestAllMapsOrderedProtoText(t *testing.T) {
507 seed := time.Now().UnixNano()
508 popr := math_rand.New(math_rand.NewSource(seed))
509 p := NewPopulatedAllMapsOrdered(popr, true)
510 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
511 msg := &AllMapsOrdered{}
512 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
513 t.Fatalf("seed = %d, err = %v", seed, err)
514 }
515 if err := p.VerboseEqual(msg); err != nil {
516 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
517 }
518 if !p.Equal(msg) {
519 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
520 }
521 }
522
523 func TestAllMapsOrderedProtoCompactText(t *testing.T) {
524 seed := time.Now().UnixNano()
525 popr := math_rand.New(math_rand.NewSource(seed))
526 p := NewPopulatedAllMapsOrdered(popr, true)
527 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
528 msg := &AllMapsOrdered{}
529 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
530 t.Fatalf("seed = %d, err = %v", seed, err)
531 }
532 if err := p.VerboseEqual(msg); err != nil {
533 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
534 }
535 if !p.Equal(msg) {
536 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
537 }
538 }
539
540 func TestMapsproto2Description(t *testing.T) {
541 Mapsproto2Description()
542 }
543 func TestFloatingPointVerboseEqual(t *testing.T) {
544 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
545 p := NewPopulatedFloatingPoint(popr, false)
546 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
547 if err != nil {
548 panic(err)
549 }
550 msg := &FloatingPoint{}
551 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
552 panic(err)
553 }
554 if err := p.VerboseEqual(msg); err != nil {
555 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
556 }
557 }
558 func TestCustomMapVerboseEqual(t *testing.T) {
559 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
560 p := NewPopulatedCustomMap(popr, false)
561 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
562 if err != nil {
563 panic(err)
564 }
565 msg := &CustomMap{}
566 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
567 panic(err)
568 }
569 if err := p.VerboseEqual(msg); err != nil {
570 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
571 }
572 }
573 func TestAllMapsVerboseEqual(t *testing.T) {
574 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
575 p := NewPopulatedAllMaps(popr, false)
576 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
577 if err != nil {
578 panic(err)
579 }
580 msg := &AllMaps{}
581 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
582 panic(err)
583 }
584 if err := p.VerboseEqual(msg); err != nil {
585 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
586 }
587 }
588 func TestAllMapsOrderedVerboseEqual(t *testing.T) {
589 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
590 p := NewPopulatedAllMapsOrdered(popr, false)
591 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
592 if err != nil {
593 panic(err)
594 }
595 msg := &AllMapsOrdered{}
596 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
597 panic(err)
598 }
599 if err := p.VerboseEqual(msg); err != nil {
600 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
601 }
602 }
603 func TestFloatingPointFace(t *testing.T) {
604 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
605 p := NewPopulatedFloatingPoint(popr, true)
606 msg := p.TestProto()
607 if !p.Equal(msg) {
608 t.Fatalf("%#v !Face Equal %#v", msg, p)
609 }
610 }
611 func TestCustomMapFace(t *testing.T) {
612 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
613 p := NewPopulatedCustomMap(popr, true)
614 msg := p.TestProto()
615 if !p.Equal(msg) {
616 t.Fatalf("%#v !Face Equal %#v", msg, p)
617 }
618 }
619 func TestAllMapsFace(t *testing.T) {
620 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
621 p := NewPopulatedAllMaps(popr, true)
622 msg := p.TestProto()
623 if !p.Equal(msg) {
624 t.Fatalf("%#v !Face Equal %#v", msg, p)
625 }
626 }
627 func TestAllMapsOrderedFace(t *testing.T) {
628 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
629 p := NewPopulatedAllMapsOrdered(popr, true)
630 msg := p.TestProto()
631 if !p.Equal(msg) {
632 t.Fatalf("%#v !Face Equal %#v", msg, p)
633 }
634 }
635 func TestFloatingPointGoString(t *testing.T) {
636 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
637 p := NewPopulatedFloatingPoint(popr, false)
638 s1 := p.GoString()
639 s2 := fmt.Sprintf("%#v", p)
640 if s1 != s2 {
641 t.Fatalf("GoString want %v got %v", s1, s2)
642 }
643 _, err := go_parser.ParseExpr(s1)
644 if err != nil {
645 t.Fatal(err)
646 }
647 }
648 func TestCustomMapGoString(t *testing.T) {
649 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
650 p := NewPopulatedCustomMap(popr, false)
651 s1 := p.GoString()
652 s2 := fmt.Sprintf("%#v", p)
653 if s1 != s2 {
654 t.Fatalf("GoString want %v got %v", s1, s2)
655 }
656 _, err := go_parser.ParseExpr(s1)
657 if err != nil {
658 t.Fatal(err)
659 }
660 }
661 func TestAllMapsGoString(t *testing.T) {
662 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
663 p := NewPopulatedAllMaps(popr, false)
664 s1 := p.GoString()
665 s2 := fmt.Sprintf("%#v", p)
666 if s1 != s2 {
667 t.Fatalf("GoString want %v got %v", s1, s2)
668 }
669 _, err := go_parser.ParseExpr(s1)
670 if err != nil {
671 t.Fatal(err)
672 }
673 }
674 func TestAllMapsOrderedGoString(t *testing.T) {
675 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
676 p := NewPopulatedAllMapsOrdered(popr, false)
677 s1 := p.GoString()
678 s2 := fmt.Sprintf("%#v", p)
679 if s1 != s2 {
680 t.Fatalf("GoString want %v got %v", s1, s2)
681 }
682 _, err := go_parser.ParseExpr(s1)
683 if err != nil {
684 t.Fatal(err)
685 }
686 }
687 func TestFloatingPointSize(t *testing.T) {
688 seed := time.Now().UnixNano()
689 popr := math_rand.New(math_rand.NewSource(seed))
690 p := NewPopulatedFloatingPoint(popr, true)
691 size2 := github_com_gogo_protobuf_proto.Size(p)
692 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
693 if err != nil {
694 t.Fatalf("seed = %d, err = %v", seed, err)
695 }
696 size := p.Size()
697 if len(dAtA) != size {
698 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
699 }
700 if size2 != size {
701 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
702 }
703 size3 := github_com_gogo_protobuf_proto.Size(p)
704 if size3 != size {
705 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
706 }
707 }
708
709 func BenchmarkFloatingPointSize(b *testing.B) {
710 popr := math_rand.New(math_rand.NewSource(616))
711 total := 0
712 pops := make([]*FloatingPoint, 1000)
713 for i := 0; i < 1000; i++ {
714 pops[i] = NewPopulatedFloatingPoint(popr, false)
715 }
716 b.ResetTimer()
717 for i := 0; i < b.N; i++ {
718 total += pops[i%1000].Size()
719 }
720 b.SetBytes(int64(total / b.N))
721 }
722
723 func TestCustomMapSize(t *testing.T) {
724 seed := time.Now().UnixNano()
725 popr := math_rand.New(math_rand.NewSource(seed))
726 p := NewPopulatedCustomMap(popr, true)
727 size2 := github_com_gogo_protobuf_proto.Size(p)
728 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
729 if err != nil {
730 t.Fatalf("seed = %d, err = %v", seed, err)
731 }
732 size := p.Size()
733 if len(dAtA) != size {
734 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
735 }
736 if size2 != size {
737 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
738 }
739 size3 := github_com_gogo_protobuf_proto.Size(p)
740 if size3 != size {
741 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
742 }
743 }
744
745 func BenchmarkCustomMapSize(b *testing.B) {
746 popr := math_rand.New(math_rand.NewSource(616))
747 total := 0
748 pops := make([]*CustomMap, 1000)
749 for i := 0; i < 1000; i++ {
750 pops[i] = NewPopulatedCustomMap(popr, false)
751 }
752 b.ResetTimer()
753 for i := 0; i < b.N; i++ {
754 total += pops[i%1000].Size()
755 }
756 b.SetBytes(int64(total / b.N))
757 }
758
759 func TestAllMapsSize(t *testing.T) {
760 seed := time.Now().UnixNano()
761 popr := math_rand.New(math_rand.NewSource(seed))
762 p := NewPopulatedAllMaps(popr, true)
763 size2 := github_com_gogo_protobuf_proto.Size(p)
764 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
765 if err != nil {
766 t.Fatalf("seed = %d, err = %v", seed, err)
767 }
768 size := p.Size()
769 if len(dAtA) != size {
770 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
771 }
772 if size2 != size {
773 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
774 }
775 size3 := github_com_gogo_protobuf_proto.Size(p)
776 if size3 != size {
777 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
778 }
779 }
780
781 func BenchmarkAllMapsSize(b *testing.B) {
782 popr := math_rand.New(math_rand.NewSource(616))
783 total := 0
784 pops := make([]*AllMaps, 1000)
785 for i := 0; i < 1000; i++ {
786 pops[i] = NewPopulatedAllMaps(popr, false)
787 }
788 b.ResetTimer()
789 for i := 0; i < b.N; i++ {
790 total += pops[i%1000].Size()
791 }
792 b.SetBytes(int64(total / b.N))
793 }
794
795 func TestAllMapsOrderedSize(t *testing.T) {
796 seed := time.Now().UnixNano()
797 popr := math_rand.New(math_rand.NewSource(seed))
798 p := NewPopulatedAllMapsOrdered(popr, true)
799 size2 := github_com_gogo_protobuf_proto.Size(p)
800 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
801 if err != nil {
802 t.Fatalf("seed = %d, err = %v", seed, err)
803 }
804 size := p.Size()
805 if len(dAtA) != size {
806 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
807 }
808 if size2 != size {
809 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
810 }
811 size3 := github_com_gogo_protobuf_proto.Size(p)
812 if size3 != size {
813 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
814 }
815 }
816
817 func BenchmarkAllMapsOrderedSize(b *testing.B) {
818 popr := math_rand.New(math_rand.NewSource(616))
819 total := 0
820 pops := make([]*AllMapsOrdered, 1000)
821 for i := 0; i < 1000; i++ {
822 pops[i] = NewPopulatedAllMapsOrdered(popr, false)
823 }
824 b.ResetTimer()
825 for i := 0; i < b.N; i++ {
826 total += pops[i%1000].Size()
827 }
828 b.SetBytes(int64(total / b.N))
829 }
830
831 func TestFloatingPointStringer(t *testing.T) {
832 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
833 p := NewPopulatedFloatingPoint(popr, false)
834 s1 := p.String()
835 s2 := fmt.Sprintf("%v", p)
836 if s1 != s2 {
837 t.Fatalf("String want %v got %v", s1, s2)
838 }
839 }
840 func TestCustomMapStringer(t *testing.T) {
841 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
842 p := NewPopulatedCustomMap(popr, false)
843 s1 := p.String()
844 s2 := fmt.Sprintf("%v", p)
845 if s1 != s2 {
846 t.Fatalf("String want %v got %v", s1, s2)
847 }
848 }
849 func TestAllMapsStringer(t *testing.T) {
850 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
851 p := NewPopulatedAllMaps(popr, false)
852 s1 := p.String()
853 s2 := fmt.Sprintf("%v", p)
854 if s1 != s2 {
855 t.Fatalf("String want %v got %v", s1, s2)
856 }
857 }
858 func TestAllMapsOrderedStringer(t *testing.T) {
859 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
860 p := NewPopulatedAllMapsOrdered(popr, false)
861 s1 := p.String()
862 s2 := fmt.Sprintf("%v", p)
863 if s1 != s2 {
864 t.Fatalf("String want %v got %v", s1, s2)
865 }
866 }
867
868
869
View as plain text