1
2
3
4 package issue260
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 _ "github.com/gogo/protobuf/types"
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 TestDroppedProto(t *testing.T) {
25 seed := time.Now().UnixNano()
26 popr := math_rand.New(math_rand.NewSource(seed))
27 p := NewPopulatedDropped(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 := &Dropped{}
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 TestDroppedMarshalTo(t *testing.T) {
59 seed := time.Now().UnixNano()
60 popr := math_rand.New(math_rand.NewSource(seed))
61 p := NewPopulatedDropped(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 := &Dropped{}
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 BenchmarkDroppedProtoMarshal(b *testing.B) {
87 popr := math_rand.New(math_rand.NewSource(616))
88 total := 0
89 pops := make([]*Dropped, 10000)
90 for i := 0; i < 10000; i++ {
91 pops[i] = NewPopulatedDropped(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 BenchmarkDroppedProtoUnmarshal(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(NewPopulatedDropped(popr, false))
110 if err != nil {
111 panic(err)
112 }
113 datas[i] = dAtA
114 }
115 msg := &Dropped{}
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 TestDroppedWithoutGettersProto(t *testing.T) {
127 seed := time.Now().UnixNano()
128 popr := math_rand.New(math_rand.NewSource(seed))
129 p := NewPopulatedDroppedWithoutGetters(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 := &DroppedWithoutGetters{}
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 TestDroppedWithoutGettersMarshalTo(t *testing.T) {
161 seed := time.Now().UnixNano()
162 popr := math_rand.New(math_rand.NewSource(seed))
163 p := NewPopulatedDroppedWithoutGetters(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 := &DroppedWithoutGetters{}
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 BenchmarkDroppedWithoutGettersProtoMarshal(b *testing.B) {
189 popr := math_rand.New(math_rand.NewSource(616))
190 total := 0
191 pops := make([]*DroppedWithoutGetters, 10000)
192 for i := 0; i < 10000; i++ {
193 pops[i] = NewPopulatedDroppedWithoutGetters(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 BenchmarkDroppedWithoutGettersProtoUnmarshal(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(NewPopulatedDroppedWithoutGetters(popr, false))
212 if err != nil {
213 panic(err)
214 }
215 datas[i] = dAtA
216 }
217 msg := &DroppedWithoutGetters{}
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 TestKeptProto(t *testing.T) {
229 seed := time.Now().UnixNano()
230 popr := math_rand.New(math_rand.NewSource(seed))
231 p := NewPopulatedKept(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 := &Kept{}
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 TestKeptMarshalTo(t *testing.T) {
263 seed := time.Now().UnixNano()
264 popr := math_rand.New(math_rand.NewSource(seed))
265 p := NewPopulatedKept(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 := &Kept{}
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 BenchmarkKeptProtoMarshal(b *testing.B) {
291 popr := math_rand.New(math_rand.NewSource(616))
292 total := 0
293 pops := make([]*Kept, 10000)
294 for i := 0; i < 10000; i++ {
295 pops[i] = NewPopulatedKept(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 BenchmarkKeptProtoUnmarshal(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(NewPopulatedKept(popr, false))
314 if err != nil {
315 panic(err)
316 }
317 datas[i] = dAtA
318 }
319 msg := &Kept{}
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 TestDroppedJSON(t *testing.T) {
331 seed := time.Now().UnixNano()
332 popr := math_rand.New(math_rand.NewSource(seed))
333 p := NewPopulatedDropped(popr, true)
334 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
335 jsondata, err := marshaler.MarshalToString(p)
336 if err != nil {
337 t.Fatalf("seed = %d, err = %v", seed, err)
338 }
339 msg := &Dropped{}
340 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
341 if err != nil {
342 t.Fatalf("seed = %d, err = %v", seed, err)
343 }
344 if err := p.VerboseEqual(msg); err != nil {
345 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
346 }
347 if !p.Equal(msg) {
348 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
349 }
350 }
351 func TestDroppedWithoutGettersJSON(t *testing.T) {
352 seed := time.Now().UnixNano()
353 popr := math_rand.New(math_rand.NewSource(seed))
354 p := NewPopulatedDroppedWithoutGetters(popr, true)
355 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
356 jsondata, err := marshaler.MarshalToString(p)
357 if err != nil {
358 t.Fatalf("seed = %d, err = %v", seed, err)
359 }
360 msg := &DroppedWithoutGetters{}
361 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
362 if err != nil {
363 t.Fatalf("seed = %d, err = %v", seed, err)
364 }
365 if err := p.VerboseEqual(msg); err != nil {
366 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
367 }
368 if !p.Equal(msg) {
369 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
370 }
371 }
372 func TestKeptJSON(t *testing.T) {
373 seed := time.Now().UnixNano()
374 popr := math_rand.New(math_rand.NewSource(seed))
375 p := NewPopulatedKept(popr, true)
376 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
377 jsondata, err := marshaler.MarshalToString(p)
378 if err != nil {
379 t.Fatalf("seed = %d, err = %v", seed, err)
380 }
381 msg := &Kept{}
382 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
383 if err != nil {
384 t.Fatalf("seed = %d, err = %v", seed, err)
385 }
386 if err := p.VerboseEqual(msg); err != nil {
387 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
388 }
389 if !p.Equal(msg) {
390 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
391 }
392 }
393 func TestDroppedProtoText(t *testing.T) {
394 seed := time.Now().UnixNano()
395 popr := math_rand.New(math_rand.NewSource(seed))
396 p := NewPopulatedDropped(popr, true)
397 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
398 msg := &Dropped{}
399 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
400 t.Fatalf("seed = %d, err = %v", seed, err)
401 }
402 if err := p.VerboseEqual(msg); err != nil {
403 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
404 }
405 if !p.Equal(msg) {
406 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
407 }
408 }
409
410 func TestDroppedProtoCompactText(t *testing.T) {
411 seed := time.Now().UnixNano()
412 popr := math_rand.New(math_rand.NewSource(seed))
413 p := NewPopulatedDropped(popr, true)
414 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
415 msg := &Dropped{}
416 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
417 t.Fatalf("seed = %d, err = %v", seed, err)
418 }
419 if err := p.VerboseEqual(msg); err != nil {
420 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
421 }
422 if !p.Equal(msg) {
423 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
424 }
425 }
426
427 func TestDroppedWithoutGettersProtoText(t *testing.T) {
428 seed := time.Now().UnixNano()
429 popr := math_rand.New(math_rand.NewSource(seed))
430 p := NewPopulatedDroppedWithoutGetters(popr, true)
431 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
432 msg := &DroppedWithoutGetters{}
433 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
434 t.Fatalf("seed = %d, err = %v", seed, err)
435 }
436 if err := p.VerboseEqual(msg); err != nil {
437 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
438 }
439 if !p.Equal(msg) {
440 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
441 }
442 }
443
444 func TestDroppedWithoutGettersProtoCompactText(t *testing.T) {
445 seed := time.Now().UnixNano()
446 popr := math_rand.New(math_rand.NewSource(seed))
447 p := NewPopulatedDroppedWithoutGetters(popr, true)
448 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
449 msg := &DroppedWithoutGetters{}
450 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
451 t.Fatalf("seed = %d, err = %v", seed, err)
452 }
453 if err := p.VerboseEqual(msg); err != nil {
454 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
455 }
456 if !p.Equal(msg) {
457 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
458 }
459 }
460
461 func TestKeptProtoText(t *testing.T) {
462 seed := time.Now().UnixNano()
463 popr := math_rand.New(math_rand.NewSource(seed))
464 p := NewPopulatedKept(popr, true)
465 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
466 msg := &Kept{}
467 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
468 t.Fatalf("seed = %d, err = %v", seed, err)
469 }
470 if err := p.VerboseEqual(msg); err != nil {
471 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
472 }
473 if !p.Equal(msg) {
474 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
475 }
476 }
477
478 func TestKeptProtoCompactText(t *testing.T) {
479 seed := time.Now().UnixNano()
480 popr := math_rand.New(math_rand.NewSource(seed))
481 p := NewPopulatedKept(popr, true)
482 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
483 msg := &Kept{}
484 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
485 t.Fatalf("seed = %d, err = %v", seed, err)
486 }
487 if err := p.VerboseEqual(msg); err != nil {
488 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
489 }
490 if !p.Equal(msg) {
491 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
492 }
493 }
494
495 func TestDroppedVerboseEqual(t *testing.T) {
496 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
497 p := NewPopulatedDropped(popr, false)
498 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
499 if err != nil {
500 panic(err)
501 }
502 msg := &Dropped{}
503 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
504 panic(err)
505 }
506 if err := p.VerboseEqual(msg); err != nil {
507 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
508 }
509 }
510 func TestDroppedWithoutGettersVerboseEqual(t *testing.T) {
511 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
512 p := NewPopulatedDroppedWithoutGetters(popr, false)
513 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
514 if err != nil {
515 panic(err)
516 }
517 msg := &DroppedWithoutGetters{}
518 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
519 panic(err)
520 }
521 if err := p.VerboseEqual(msg); err != nil {
522 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
523 }
524 }
525 func TestKeptVerboseEqual(t *testing.T) {
526 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
527 p := NewPopulatedKept(popr, false)
528 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
529 if err != nil {
530 panic(err)
531 }
532 msg := &Kept{}
533 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
534 panic(err)
535 }
536 if err := p.VerboseEqual(msg); err != nil {
537 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
538 }
539 }
540 func TestDroppedSize(t *testing.T) {
541 seed := time.Now().UnixNano()
542 popr := math_rand.New(math_rand.NewSource(seed))
543 p := NewPopulatedDropped(popr, true)
544 size2 := github_com_gogo_protobuf_proto.Size(p)
545 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
546 if err != nil {
547 t.Fatalf("seed = %d, err = %v", seed, err)
548 }
549 size := p.Size()
550 if len(dAtA) != size {
551 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
552 }
553 if size2 != size {
554 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
555 }
556 size3 := github_com_gogo_protobuf_proto.Size(p)
557 if size3 != size {
558 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
559 }
560 }
561
562 func BenchmarkDroppedSize(b *testing.B) {
563 popr := math_rand.New(math_rand.NewSource(616))
564 total := 0
565 pops := make([]*Dropped, 1000)
566 for i := 0; i < 1000; i++ {
567 pops[i] = NewPopulatedDropped(popr, false)
568 }
569 b.ResetTimer()
570 for i := 0; i < b.N; i++ {
571 total += pops[i%1000].Size()
572 }
573 b.SetBytes(int64(total / b.N))
574 }
575
576 func TestDroppedWithoutGettersSize(t *testing.T) {
577 seed := time.Now().UnixNano()
578 popr := math_rand.New(math_rand.NewSource(seed))
579 p := NewPopulatedDroppedWithoutGetters(popr, true)
580 size2 := github_com_gogo_protobuf_proto.Size(p)
581 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
582 if err != nil {
583 t.Fatalf("seed = %d, err = %v", seed, err)
584 }
585 size := p.Size()
586 if len(dAtA) != size {
587 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
588 }
589 if size2 != size {
590 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
591 }
592 size3 := github_com_gogo_protobuf_proto.Size(p)
593 if size3 != size {
594 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
595 }
596 }
597
598 func BenchmarkDroppedWithoutGettersSize(b *testing.B) {
599 popr := math_rand.New(math_rand.NewSource(616))
600 total := 0
601 pops := make([]*DroppedWithoutGetters, 1000)
602 for i := 0; i < 1000; i++ {
603 pops[i] = NewPopulatedDroppedWithoutGetters(popr, false)
604 }
605 b.ResetTimer()
606 for i := 0; i < b.N; i++ {
607 total += pops[i%1000].Size()
608 }
609 b.SetBytes(int64(total / b.N))
610 }
611
612 func TestKeptSize(t *testing.T) {
613 seed := time.Now().UnixNano()
614 popr := math_rand.New(math_rand.NewSource(seed))
615 p := NewPopulatedKept(popr, true)
616 size2 := github_com_gogo_protobuf_proto.Size(p)
617 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
618 if err != nil {
619 t.Fatalf("seed = %d, err = %v", seed, err)
620 }
621 size := p.Size()
622 if len(dAtA) != size {
623 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
624 }
625 if size2 != size {
626 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
627 }
628 size3 := github_com_gogo_protobuf_proto.Size(p)
629 if size3 != size {
630 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
631 }
632 }
633
634 func BenchmarkKeptSize(b *testing.B) {
635 popr := math_rand.New(math_rand.NewSource(616))
636 total := 0
637 pops := make([]*Kept, 1000)
638 for i := 0; i < 1000; i++ {
639 pops[i] = NewPopulatedKept(popr, false)
640 }
641 b.ResetTimer()
642 for i := 0; i < b.N; i++ {
643 total += pops[i%1000].Size()
644 }
645 b.SetBytes(int64(total / b.N))
646 }
647
648
649
View as plain text