1
2
3
4 package stdtypes
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 go_parser "go/parser"
14 math "math"
15 math_rand "math/rand"
16 testing "testing"
17 time "time"
18 )
19
20
21 var _ = proto.Marshal
22 var _ = fmt.Errorf
23 var _ = math.Inf
24
25 func TestStdTypesProto(t *testing.T) {
26 seed := time.Now().UnixNano()
27 popr := math_rand.New(math_rand.NewSource(seed))
28 p := NewPopulatedStdTypes(popr, false)
29 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
30 if err != nil {
31 t.Fatalf("seed = %d, err = %v", seed, err)
32 }
33 msg := &StdTypes{}
34 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
35 t.Fatalf("seed = %d, err = %v", seed, err)
36 }
37 littlefuzz := make([]byte, len(dAtA))
38 copy(littlefuzz, dAtA)
39 for i := range dAtA {
40 dAtA[i] = byte(popr.Intn(256))
41 }
42 if err := p.VerboseEqual(msg); err != nil {
43 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
44 }
45 if !p.Equal(msg) {
46 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
47 }
48 if len(littlefuzz) > 0 {
49 fuzzamount := 100
50 for i := 0; i < fuzzamount; i++ {
51 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
52 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
53 }
54
55 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
56 }
57 }
58
59 func BenchmarkStdTypesProtoMarshal(b *testing.B) {
60 popr := math_rand.New(math_rand.NewSource(616))
61 total := 0
62 pops := make([]*StdTypes, 10000)
63 for i := 0; i < 10000; i++ {
64 pops[i] = NewPopulatedStdTypes(popr, false)
65 }
66 b.ResetTimer()
67 for i := 0; i < b.N; i++ {
68 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
69 if err != nil {
70 panic(err)
71 }
72 total += len(dAtA)
73 }
74 b.SetBytes(int64(total / b.N))
75 }
76
77 func BenchmarkStdTypesProtoUnmarshal(b *testing.B) {
78 popr := math_rand.New(math_rand.NewSource(616))
79 total := 0
80 datas := make([][]byte, 10000)
81 for i := 0; i < 10000; i++ {
82 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedStdTypes(popr, false))
83 if err != nil {
84 panic(err)
85 }
86 datas[i] = dAtA
87 }
88 msg := &StdTypes{}
89 b.ResetTimer()
90 for i := 0; i < b.N; i++ {
91 total += len(datas[i%10000])
92 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
93 panic(err)
94 }
95 }
96 b.SetBytes(int64(total / b.N))
97 }
98
99 func TestRepStdTypesProto(t *testing.T) {
100 seed := time.Now().UnixNano()
101 popr := math_rand.New(math_rand.NewSource(seed))
102 p := NewPopulatedRepStdTypes(popr, false)
103 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
104 if err != nil {
105 t.Fatalf("seed = %d, err = %v", seed, err)
106 }
107 msg := &RepStdTypes{}
108 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
109 t.Fatalf("seed = %d, err = %v", seed, err)
110 }
111 littlefuzz := make([]byte, len(dAtA))
112 copy(littlefuzz, dAtA)
113 for i := range dAtA {
114 dAtA[i] = byte(popr.Intn(256))
115 }
116 if err := p.VerboseEqual(msg); err != nil {
117 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
118 }
119 if !p.Equal(msg) {
120 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
121 }
122 if len(littlefuzz) > 0 {
123 fuzzamount := 100
124 for i := 0; i < fuzzamount; i++ {
125 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
126 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
127 }
128
129 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
130 }
131 }
132
133 func BenchmarkRepStdTypesProtoMarshal(b *testing.B) {
134 popr := math_rand.New(math_rand.NewSource(616))
135 total := 0
136 pops := make([]*RepStdTypes, 10000)
137 for i := 0; i < 10000; i++ {
138 pops[i] = NewPopulatedRepStdTypes(popr, false)
139 }
140 b.ResetTimer()
141 for i := 0; i < b.N; i++ {
142 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
143 if err != nil {
144 panic(err)
145 }
146 total += len(dAtA)
147 }
148 b.SetBytes(int64(total / b.N))
149 }
150
151 func BenchmarkRepStdTypesProtoUnmarshal(b *testing.B) {
152 popr := math_rand.New(math_rand.NewSource(616))
153 total := 0
154 datas := make([][]byte, 10000)
155 for i := 0; i < 10000; i++ {
156 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedRepStdTypes(popr, false))
157 if err != nil {
158 panic(err)
159 }
160 datas[i] = dAtA
161 }
162 msg := &RepStdTypes{}
163 b.ResetTimer()
164 for i := 0; i < b.N; i++ {
165 total += len(datas[i%10000])
166 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
167 panic(err)
168 }
169 }
170 b.SetBytes(int64(total / b.N))
171 }
172
173 func TestMapStdTypesProto(t *testing.T) {
174 seed := time.Now().UnixNano()
175 popr := math_rand.New(math_rand.NewSource(seed))
176 p := NewPopulatedMapStdTypes(popr, false)
177 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
178 if err != nil {
179 t.Fatalf("seed = %d, err = %v", seed, err)
180 }
181 msg := &MapStdTypes{}
182 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
183 t.Fatalf("seed = %d, err = %v", seed, err)
184 }
185 littlefuzz := make([]byte, len(dAtA))
186 copy(littlefuzz, dAtA)
187 for i := range dAtA {
188 dAtA[i] = byte(popr.Intn(256))
189 }
190 if err := p.VerboseEqual(msg); err != nil {
191 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
192 }
193 if !p.Equal(msg) {
194 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
195 }
196 if len(littlefuzz) > 0 {
197 fuzzamount := 100
198 for i := 0; i < fuzzamount; i++ {
199 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
200 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
201 }
202
203 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
204 }
205 }
206
207 func BenchmarkMapStdTypesProtoMarshal(b *testing.B) {
208 popr := math_rand.New(math_rand.NewSource(616))
209 total := 0
210 pops := make([]*MapStdTypes, 10000)
211 for i := 0; i < 10000; i++ {
212 pops[i] = NewPopulatedMapStdTypes(popr, false)
213 }
214 b.ResetTimer()
215 for i := 0; i < b.N; i++ {
216 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
217 if err != nil {
218 panic(err)
219 }
220 total += len(dAtA)
221 }
222 b.SetBytes(int64(total / b.N))
223 }
224
225 func BenchmarkMapStdTypesProtoUnmarshal(b *testing.B) {
226 popr := math_rand.New(math_rand.NewSource(616))
227 total := 0
228 datas := make([][]byte, 10000)
229 for i := 0; i < 10000; i++ {
230 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMapStdTypes(popr, false))
231 if err != nil {
232 panic(err)
233 }
234 datas[i] = dAtA
235 }
236 msg := &MapStdTypes{}
237 b.ResetTimer()
238 for i := 0; i < b.N; i++ {
239 total += len(datas[i%10000])
240 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
241 panic(err)
242 }
243 }
244 b.SetBytes(int64(total / b.N))
245 }
246
247 func TestOneofStdTypesProto(t *testing.T) {
248 seed := time.Now().UnixNano()
249 popr := math_rand.New(math_rand.NewSource(seed))
250 p := NewPopulatedOneofStdTypes(popr, false)
251 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
252 if err != nil {
253 t.Fatalf("seed = %d, err = %v", seed, err)
254 }
255 msg := &OneofStdTypes{}
256 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
257 t.Fatalf("seed = %d, err = %v", seed, err)
258 }
259 littlefuzz := make([]byte, len(dAtA))
260 copy(littlefuzz, dAtA)
261 for i := range dAtA {
262 dAtA[i] = byte(popr.Intn(256))
263 }
264 if err := p.VerboseEqual(msg); err != nil {
265 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
266 }
267 if !p.Equal(msg) {
268 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
269 }
270 if len(littlefuzz) > 0 {
271 fuzzamount := 100
272 for i := 0; i < fuzzamount; i++ {
273 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
274 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
275 }
276
277 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
278 }
279 }
280
281 func BenchmarkOneofStdTypesProtoMarshal(b *testing.B) {
282 popr := math_rand.New(math_rand.NewSource(616))
283 total := 0
284 pops := make([]*OneofStdTypes, 10000)
285 for i := 0; i < 10000; i++ {
286 pops[i] = NewPopulatedOneofStdTypes(popr, false)
287 }
288 b.ResetTimer()
289 for i := 0; i < b.N; i++ {
290 dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
291 if err != nil {
292 panic(err)
293 }
294 total += len(dAtA)
295 }
296 b.SetBytes(int64(total / b.N))
297 }
298
299 func BenchmarkOneofStdTypesProtoUnmarshal(b *testing.B) {
300 popr := math_rand.New(math_rand.NewSource(616))
301 total := 0
302 datas := make([][]byte, 10000)
303 for i := 0; i < 10000; i++ {
304 dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOneofStdTypes(popr, false))
305 if err != nil {
306 panic(err)
307 }
308 datas[i] = dAtA
309 }
310 msg := &OneofStdTypes{}
311 b.ResetTimer()
312 for i := 0; i < b.N; i++ {
313 total += len(datas[i%10000])
314 if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
315 panic(err)
316 }
317 }
318 b.SetBytes(int64(total / b.N))
319 }
320
321 func TestStdTypesJSON(t *testing.T) {
322 seed := time.Now().UnixNano()
323 popr := math_rand.New(math_rand.NewSource(seed))
324 p := NewPopulatedStdTypes(popr, true)
325 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
326 jsondata, err := marshaler.MarshalToString(p)
327 if err != nil {
328 t.Fatalf("seed = %d, err = %v", seed, err)
329 }
330 msg := &StdTypes{}
331 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
332 if err != nil {
333 t.Fatalf("seed = %d, err = %v", seed, err)
334 }
335 if err := p.VerboseEqual(msg); err != nil {
336 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
337 }
338 if !p.Equal(msg) {
339 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
340 }
341 }
342 func TestRepStdTypesJSON(t *testing.T) {
343 seed := time.Now().UnixNano()
344 popr := math_rand.New(math_rand.NewSource(seed))
345 p := NewPopulatedRepStdTypes(popr, true)
346 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
347 jsondata, err := marshaler.MarshalToString(p)
348 if err != nil {
349 t.Fatalf("seed = %d, err = %v", seed, err)
350 }
351 msg := &RepStdTypes{}
352 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
353 if err != nil {
354 t.Fatalf("seed = %d, err = %v", seed, err)
355 }
356 if err := p.VerboseEqual(msg); err != nil {
357 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
358 }
359 if !p.Equal(msg) {
360 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
361 }
362 }
363 func TestMapStdTypesJSON(t *testing.T) {
364 seed := time.Now().UnixNano()
365 popr := math_rand.New(math_rand.NewSource(seed))
366 p := NewPopulatedMapStdTypes(popr, true)
367 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
368 jsondata, err := marshaler.MarshalToString(p)
369 if err != nil {
370 t.Fatalf("seed = %d, err = %v", seed, err)
371 }
372 msg := &MapStdTypes{}
373 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
374 if err != nil {
375 t.Fatalf("seed = %d, err = %v", seed, err)
376 }
377 if err := p.VerboseEqual(msg); err != nil {
378 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
379 }
380 if !p.Equal(msg) {
381 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
382 }
383 }
384 func TestOneofStdTypesJSON(t *testing.T) {
385 seed := time.Now().UnixNano()
386 popr := math_rand.New(math_rand.NewSource(seed))
387 p := NewPopulatedOneofStdTypes(popr, true)
388 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
389 jsondata, err := marshaler.MarshalToString(p)
390 if err != nil {
391 t.Fatalf("seed = %d, err = %v", seed, err)
392 }
393 msg := &OneofStdTypes{}
394 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
395 if err != nil {
396 t.Fatalf("seed = %d, err = %v", seed, err)
397 }
398 if err := p.VerboseEqual(msg); err != nil {
399 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
400 }
401 if !p.Equal(msg) {
402 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
403 }
404 }
405 func TestStdTypesProtoText(t *testing.T) {
406 seed := time.Now().UnixNano()
407 popr := math_rand.New(math_rand.NewSource(seed))
408 p := NewPopulatedStdTypes(popr, true)
409 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
410 msg := &StdTypes{}
411 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
412 t.Fatalf("seed = %d, err = %v", seed, err)
413 }
414 if err := p.VerboseEqual(msg); err != nil {
415 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
416 }
417 if !p.Equal(msg) {
418 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
419 }
420 }
421
422 func TestStdTypesProtoCompactText(t *testing.T) {
423 seed := time.Now().UnixNano()
424 popr := math_rand.New(math_rand.NewSource(seed))
425 p := NewPopulatedStdTypes(popr, true)
426 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
427 msg := &StdTypes{}
428 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
429 t.Fatalf("seed = %d, err = %v", seed, err)
430 }
431 if err := p.VerboseEqual(msg); err != nil {
432 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
433 }
434 if !p.Equal(msg) {
435 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
436 }
437 }
438
439 func TestRepStdTypesProtoText(t *testing.T) {
440 seed := time.Now().UnixNano()
441 popr := math_rand.New(math_rand.NewSource(seed))
442 p := NewPopulatedRepStdTypes(popr, true)
443 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
444 msg := &RepStdTypes{}
445 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
446 t.Fatalf("seed = %d, err = %v", seed, err)
447 }
448 if err := p.VerboseEqual(msg); err != nil {
449 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
450 }
451 if !p.Equal(msg) {
452 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
453 }
454 }
455
456 func TestRepStdTypesProtoCompactText(t *testing.T) {
457 seed := time.Now().UnixNano()
458 popr := math_rand.New(math_rand.NewSource(seed))
459 p := NewPopulatedRepStdTypes(popr, true)
460 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
461 msg := &RepStdTypes{}
462 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
463 t.Fatalf("seed = %d, err = %v", seed, err)
464 }
465 if err := p.VerboseEqual(msg); err != nil {
466 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
467 }
468 if !p.Equal(msg) {
469 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
470 }
471 }
472
473 func TestMapStdTypesProtoText(t *testing.T) {
474 seed := time.Now().UnixNano()
475 popr := math_rand.New(math_rand.NewSource(seed))
476 p := NewPopulatedMapStdTypes(popr, true)
477 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
478 msg := &MapStdTypes{}
479 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
480 t.Fatalf("seed = %d, err = %v", seed, err)
481 }
482 if err := p.VerboseEqual(msg); err != nil {
483 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
484 }
485 if !p.Equal(msg) {
486 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
487 }
488 }
489
490 func TestMapStdTypesProtoCompactText(t *testing.T) {
491 seed := time.Now().UnixNano()
492 popr := math_rand.New(math_rand.NewSource(seed))
493 p := NewPopulatedMapStdTypes(popr, true)
494 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
495 msg := &MapStdTypes{}
496 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
497 t.Fatalf("seed = %d, err = %v", seed, err)
498 }
499 if err := p.VerboseEqual(msg); err != nil {
500 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
501 }
502 if !p.Equal(msg) {
503 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
504 }
505 }
506
507 func TestOneofStdTypesProtoText(t *testing.T) {
508 seed := time.Now().UnixNano()
509 popr := math_rand.New(math_rand.NewSource(seed))
510 p := NewPopulatedOneofStdTypes(popr, true)
511 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
512 msg := &OneofStdTypes{}
513 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
514 t.Fatalf("seed = %d, err = %v", seed, err)
515 }
516 if err := p.VerboseEqual(msg); err != nil {
517 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
518 }
519 if !p.Equal(msg) {
520 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
521 }
522 }
523
524 func TestOneofStdTypesProtoCompactText(t *testing.T) {
525 seed := time.Now().UnixNano()
526 popr := math_rand.New(math_rand.NewSource(seed))
527 p := NewPopulatedOneofStdTypes(popr, true)
528 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
529 msg := &OneofStdTypes{}
530 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
531 t.Fatalf("seed = %d, err = %v", seed, err)
532 }
533 if err := p.VerboseEqual(msg); err != nil {
534 t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
535 }
536 if !p.Equal(msg) {
537 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
538 }
539 }
540
541 func TestStdTypesVerboseEqual(t *testing.T) {
542 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
543 p := NewPopulatedStdTypes(popr, false)
544 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
545 if err != nil {
546 panic(err)
547 }
548 msg := &StdTypes{}
549 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
550 panic(err)
551 }
552 if err := p.VerboseEqual(msg); err != nil {
553 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
554 }
555 }
556 func TestRepStdTypesVerboseEqual(t *testing.T) {
557 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
558 p := NewPopulatedRepStdTypes(popr, false)
559 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
560 if err != nil {
561 panic(err)
562 }
563 msg := &RepStdTypes{}
564 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
565 panic(err)
566 }
567 if err := p.VerboseEqual(msg); err != nil {
568 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
569 }
570 }
571 func TestMapStdTypesVerboseEqual(t *testing.T) {
572 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
573 p := NewPopulatedMapStdTypes(popr, false)
574 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
575 if err != nil {
576 panic(err)
577 }
578 msg := &MapStdTypes{}
579 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
580 panic(err)
581 }
582 if err := p.VerboseEqual(msg); err != nil {
583 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
584 }
585 }
586 func TestOneofStdTypesVerboseEqual(t *testing.T) {
587 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
588 p := NewPopulatedOneofStdTypes(popr, false)
589 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
590 if err != nil {
591 panic(err)
592 }
593 msg := &OneofStdTypes{}
594 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
595 panic(err)
596 }
597 if err := p.VerboseEqual(msg); err != nil {
598 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
599 }
600 }
601 func TestStdTypesGoString(t *testing.T) {
602 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
603 p := NewPopulatedStdTypes(popr, false)
604 s1 := p.GoString()
605 s2 := fmt.Sprintf("%#v", p)
606 if s1 != s2 {
607 t.Fatalf("GoString want %v got %v", s1, s2)
608 }
609 _, err := go_parser.ParseExpr(s1)
610 if err != nil {
611 t.Fatal(err)
612 }
613 }
614 func TestRepStdTypesGoString(t *testing.T) {
615 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
616 p := NewPopulatedRepStdTypes(popr, false)
617 s1 := p.GoString()
618 s2 := fmt.Sprintf("%#v", p)
619 if s1 != s2 {
620 t.Fatalf("GoString want %v got %v", s1, s2)
621 }
622 _, err := go_parser.ParseExpr(s1)
623 if err != nil {
624 t.Fatal(err)
625 }
626 }
627 func TestMapStdTypesGoString(t *testing.T) {
628 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
629 p := NewPopulatedMapStdTypes(popr, false)
630 s1 := p.GoString()
631 s2 := fmt.Sprintf("%#v", p)
632 if s1 != s2 {
633 t.Fatalf("GoString want %v got %v", s1, s2)
634 }
635 _, err := go_parser.ParseExpr(s1)
636 if err != nil {
637 t.Fatal(err)
638 }
639 }
640 func TestOneofStdTypesGoString(t *testing.T) {
641 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
642 p := NewPopulatedOneofStdTypes(popr, false)
643 s1 := p.GoString()
644 s2 := fmt.Sprintf("%#v", p)
645 if s1 != s2 {
646 t.Fatalf("GoString want %v got %v", s1, s2)
647 }
648 _, err := go_parser.ParseExpr(s1)
649 if err != nil {
650 t.Fatal(err)
651 }
652 }
653 func TestStdTypesSize(t *testing.T) {
654 seed := time.Now().UnixNano()
655 popr := math_rand.New(math_rand.NewSource(seed))
656 p := NewPopulatedStdTypes(popr, true)
657 size2 := github_com_gogo_protobuf_proto.Size(p)
658 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
659 if err != nil {
660 t.Fatalf("seed = %d, err = %v", seed, err)
661 }
662 size := p.Size()
663 if len(dAtA) != size {
664 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
665 }
666 if size2 != size {
667 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
668 }
669 size3 := github_com_gogo_protobuf_proto.Size(p)
670 if size3 != size {
671 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
672 }
673 }
674
675 func BenchmarkStdTypesSize(b *testing.B) {
676 popr := math_rand.New(math_rand.NewSource(616))
677 total := 0
678 pops := make([]*StdTypes, 1000)
679 for i := 0; i < 1000; i++ {
680 pops[i] = NewPopulatedStdTypes(popr, false)
681 }
682 b.ResetTimer()
683 for i := 0; i < b.N; i++ {
684 total += pops[i%1000].Size()
685 }
686 b.SetBytes(int64(total / b.N))
687 }
688
689 func TestRepStdTypesSize(t *testing.T) {
690 seed := time.Now().UnixNano()
691 popr := math_rand.New(math_rand.NewSource(seed))
692 p := NewPopulatedRepStdTypes(popr, true)
693 size2 := github_com_gogo_protobuf_proto.Size(p)
694 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
695 if err != nil {
696 t.Fatalf("seed = %d, err = %v", seed, err)
697 }
698 size := p.Size()
699 if len(dAtA) != size {
700 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
701 }
702 if size2 != size {
703 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
704 }
705 size3 := github_com_gogo_protobuf_proto.Size(p)
706 if size3 != size {
707 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
708 }
709 }
710
711 func BenchmarkRepStdTypesSize(b *testing.B) {
712 popr := math_rand.New(math_rand.NewSource(616))
713 total := 0
714 pops := make([]*RepStdTypes, 1000)
715 for i := 0; i < 1000; i++ {
716 pops[i] = NewPopulatedRepStdTypes(popr, false)
717 }
718 b.ResetTimer()
719 for i := 0; i < b.N; i++ {
720 total += pops[i%1000].Size()
721 }
722 b.SetBytes(int64(total / b.N))
723 }
724
725 func TestMapStdTypesSize(t *testing.T) {
726 seed := time.Now().UnixNano()
727 popr := math_rand.New(math_rand.NewSource(seed))
728 p := NewPopulatedMapStdTypes(popr, true)
729 size2 := github_com_gogo_protobuf_proto.Size(p)
730 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
731 if err != nil {
732 t.Fatalf("seed = %d, err = %v", seed, err)
733 }
734 size := p.Size()
735 if len(dAtA) != size {
736 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
737 }
738 if size2 != size {
739 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
740 }
741 size3 := github_com_gogo_protobuf_proto.Size(p)
742 if size3 != size {
743 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
744 }
745 }
746
747 func BenchmarkMapStdTypesSize(b *testing.B) {
748 popr := math_rand.New(math_rand.NewSource(616))
749 total := 0
750 pops := make([]*MapStdTypes, 1000)
751 for i := 0; i < 1000; i++ {
752 pops[i] = NewPopulatedMapStdTypes(popr, false)
753 }
754 b.ResetTimer()
755 for i := 0; i < b.N; i++ {
756 total += pops[i%1000].Size()
757 }
758 b.SetBytes(int64(total / b.N))
759 }
760
761 func TestOneofStdTypesSize(t *testing.T) {
762 seed := time.Now().UnixNano()
763 popr := math_rand.New(math_rand.NewSource(seed))
764 p := NewPopulatedOneofStdTypes(popr, true)
765 size2 := github_com_gogo_protobuf_proto.Size(p)
766 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
767 if err != nil {
768 t.Fatalf("seed = %d, err = %v", seed, err)
769 }
770 size := p.Size()
771 if len(dAtA) != size {
772 t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
773 }
774 if size2 != size {
775 t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
776 }
777 size3 := github_com_gogo_protobuf_proto.Size(p)
778 if size3 != size {
779 t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
780 }
781 }
782
783 func BenchmarkOneofStdTypesSize(b *testing.B) {
784 popr := math_rand.New(math_rand.NewSource(616))
785 total := 0
786 pops := make([]*OneofStdTypes, 1000)
787 for i := 0; i < 1000; i++ {
788 pops[i] = NewPopulatedOneofStdTypes(popr, false)
789 }
790 b.ResetTimer()
791 for i := 0; i < b.N; i++ {
792 total += pops[i%1000].Size()
793 }
794 b.SetBytes(int64(total / b.N))
795 }
796
797
798
View as plain text