1
2
3
4 package unmarshalmerge
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 unsafe "unsafe"
18 )
19
20
21 var _ = proto.Marshal
22 var _ = fmt.Errorf
23 var _ = math.Inf
24
25 func TestBigProto(t *testing.T) {
26 seed := time.Now().UnixNano()
27 popr := math_rand.New(math_rand.NewSource(seed))
28 p := NewPopulatedBig(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 := &Big{}
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 BenchmarkBigProtoMarshal(b *testing.B) {
60 popr := math_rand.New(math_rand.NewSource(616))
61 total := 0
62 pops := make([]*Big, 10000)
63 for i := 0; i < 10000; i++ {
64 pops[i] = NewPopulatedBig(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 BenchmarkBigProtoUnmarshal(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(NewPopulatedBig(popr, false))
83 if err != nil {
84 panic(err)
85 }
86 datas[i] = dAtA
87 }
88 msg := &Big{}
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 TestBigUnsafeProto(t *testing.T) {
100 seed := time.Now().UnixNano()
101 popr := math_rand.New(math_rand.NewSource(seed))
102 p := NewPopulatedBigUnsafe(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 := &BigUnsafe{}
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 BenchmarkBigUnsafeProtoMarshal(b *testing.B) {
134 popr := math_rand.New(math_rand.NewSource(616))
135 total := 0
136 pops := make([]*BigUnsafe, 10000)
137 for i := 0; i < 10000; i++ {
138 pops[i] = NewPopulatedBigUnsafe(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 BenchmarkBigUnsafeProtoUnmarshal(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(NewPopulatedBigUnsafe(popr, false))
157 if err != nil {
158 panic(err)
159 }
160 datas[i] = dAtA
161 }
162 msg := &BigUnsafe{}
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 TestSubProto(t *testing.T) {
174 seed := time.Now().UnixNano()
175 popr := math_rand.New(math_rand.NewSource(seed))
176 p := NewPopulatedSub(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 := &Sub{}
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 BenchmarkSubProtoMarshal(b *testing.B) {
208 popr := math_rand.New(math_rand.NewSource(616))
209 total := 0
210 pops := make([]*Sub, 10000)
211 for i := 0; i < 10000; i++ {
212 pops[i] = NewPopulatedSub(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 BenchmarkSubProtoUnmarshal(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(NewPopulatedSub(popr, false))
231 if err != nil {
232 panic(err)
233 }
234 datas[i] = dAtA
235 }
236 msg := &Sub{}
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 TestIntMergeProto(t *testing.T) {
248 seed := time.Now().UnixNano()
249 popr := math_rand.New(math_rand.NewSource(seed))
250 p := NewPopulatedIntMerge(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 := &IntMerge{}
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 BenchmarkIntMergeProtoMarshal(b *testing.B) {
282 popr := math_rand.New(math_rand.NewSource(616))
283 total := 0
284 pops := make([]*IntMerge, 10000)
285 for i := 0; i < 10000; i++ {
286 pops[i] = NewPopulatedIntMerge(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 BenchmarkIntMergeProtoUnmarshal(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(NewPopulatedIntMerge(popr, false))
305 if err != nil {
306 panic(err)
307 }
308 datas[i] = dAtA
309 }
310 msg := &IntMerge{}
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 TestBigJSON(t *testing.T) {
322 seed := time.Now().UnixNano()
323 popr := math_rand.New(math_rand.NewSource(seed))
324 p := NewPopulatedBig(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 := &Big{}
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 TestBigUnsafeJSON(t *testing.T) {
343 seed := time.Now().UnixNano()
344 popr := math_rand.New(math_rand.NewSource(seed))
345 p := NewPopulatedBigUnsafe(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 := &BigUnsafe{}
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 TestSubJSON(t *testing.T) {
364 seed := time.Now().UnixNano()
365 popr := math_rand.New(math_rand.NewSource(seed))
366 p := NewPopulatedSub(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 := &Sub{}
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 TestIntMergeJSON(t *testing.T) {
385 seed := time.Now().UnixNano()
386 popr := math_rand.New(math_rand.NewSource(seed))
387 p := NewPopulatedIntMerge(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 := &IntMerge{}
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 TestBigProtoText(t *testing.T) {
406 seed := time.Now().UnixNano()
407 popr := math_rand.New(math_rand.NewSource(seed))
408 p := NewPopulatedBig(popr, true)
409 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
410 msg := &Big{}
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 TestBigProtoCompactText(t *testing.T) {
423 seed := time.Now().UnixNano()
424 popr := math_rand.New(math_rand.NewSource(seed))
425 p := NewPopulatedBig(popr, true)
426 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
427 msg := &Big{}
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 TestBigUnsafeProtoText(t *testing.T) {
440 seed := time.Now().UnixNano()
441 popr := math_rand.New(math_rand.NewSource(seed))
442 p := NewPopulatedBigUnsafe(popr, true)
443 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
444 msg := &BigUnsafe{}
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 TestBigUnsafeProtoCompactText(t *testing.T) {
457 seed := time.Now().UnixNano()
458 popr := math_rand.New(math_rand.NewSource(seed))
459 p := NewPopulatedBigUnsafe(popr, true)
460 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
461 msg := &BigUnsafe{}
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 TestSubProtoText(t *testing.T) {
474 seed := time.Now().UnixNano()
475 popr := math_rand.New(math_rand.NewSource(seed))
476 p := NewPopulatedSub(popr, true)
477 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
478 msg := &Sub{}
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 TestSubProtoCompactText(t *testing.T) {
491 seed := time.Now().UnixNano()
492 popr := math_rand.New(math_rand.NewSource(seed))
493 p := NewPopulatedSub(popr, true)
494 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
495 msg := &Sub{}
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 TestIntMergeProtoText(t *testing.T) {
508 seed := time.Now().UnixNano()
509 popr := math_rand.New(math_rand.NewSource(seed))
510 p := NewPopulatedIntMerge(popr, true)
511 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
512 msg := &IntMerge{}
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 TestIntMergeProtoCompactText(t *testing.T) {
525 seed := time.Now().UnixNano()
526 popr := math_rand.New(math_rand.NewSource(seed))
527 p := NewPopulatedIntMerge(popr, true)
528 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
529 msg := &IntMerge{}
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 TestBigVerboseEqual(t *testing.T) {
542 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
543 p := NewPopulatedBig(popr, false)
544 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
545 if err != nil {
546 panic(err)
547 }
548 msg := &Big{}
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 TestBigUnsafeVerboseEqual(t *testing.T) {
557 var bigendian uint32 = 0x01020304
558 if *(*byte)(unsafe.Pointer(&bigendian)) == 1 {
559 t.Skip("unsafe does not work on big endian architectures")
560 }
561 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
562 p := NewPopulatedBigUnsafe(popr, false)
563 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
564 if err != nil {
565 panic(err)
566 }
567 msg := &BigUnsafe{}
568 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
569 panic(err)
570 }
571 if err := p.VerboseEqual(msg); err != nil {
572 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
573 }
574 }
575 func TestSubVerboseEqual(t *testing.T) {
576 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
577 p := NewPopulatedSub(popr, false)
578 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
579 if err != nil {
580 panic(err)
581 }
582 msg := &Sub{}
583 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
584 panic(err)
585 }
586 if err := p.VerboseEqual(msg); err != nil {
587 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
588 }
589 }
590 func TestIntMergeVerboseEqual(t *testing.T) {
591 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
592 p := NewPopulatedIntMerge(popr, false)
593 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
594 if err != nil {
595 panic(err)
596 }
597 msg := &IntMerge{}
598 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
599 panic(err)
600 }
601 if err := p.VerboseEqual(msg); err != nil {
602 t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
603 }
604 }
605 func TestBigGoString(t *testing.T) {
606 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
607 p := NewPopulatedBig(popr, false)
608 s1 := p.GoString()
609 s2 := fmt.Sprintf("%#v", p)
610 if s1 != s2 {
611 t.Fatalf("GoString want %v got %v", s1, s2)
612 }
613 _, err := go_parser.ParseExpr(s1)
614 if err != nil {
615 t.Fatal(err)
616 }
617 }
618 func TestBigUnsafeGoString(t *testing.T) {
619 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
620 p := NewPopulatedBigUnsafe(popr, false)
621 s1 := p.GoString()
622 s2 := fmt.Sprintf("%#v", p)
623 if s1 != s2 {
624 t.Fatalf("GoString want %v got %v", s1, s2)
625 }
626 _, err := go_parser.ParseExpr(s1)
627 if err != nil {
628 t.Fatal(err)
629 }
630 }
631 func TestSubGoString(t *testing.T) {
632 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
633 p := NewPopulatedSub(popr, false)
634 s1 := p.GoString()
635 s2 := fmt.Sprintf("%#v", p)
636 if s1 != s2 {
637 t.Fatalf("GoString want %v got %v", s1, s2)
638 }
639 _, err := go_parser.ParseExpr(s1)
640 if err != nil {
641 t.Fatal(err)
642 }
643 }
644 func TestIntMergeGoString(t *testing.T) {
645 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
646 p := NewPopulatedIntMerge(popr, false)
647 s1 := p.GoString()
648 s2 := fmt.Sprintf("%#v", p)
649 if s1 != s2 {
650 t.Fatalf("GoString want %v got %v", s1, s2)
651 }
652 _, err := go_parser.ParseExpr(s1)
653 if err != nil {
654 t.Fatal(err)
655 }
656 }
657 func TestBigStringer(t *testing.T) {
658 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
659 p := NewPopulatedBig(popr, false)
660 s1 := p.String()
661 s2 := fmt.Sprintf("%v", p)
662 if s1 != s2 {
663 t.Fatalf("String want %v got %v", s1, s2)
664 }
665 }
666 func TestBigUnsafeStringer(t *testing.T) {
667 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
668 p := NewPopulatedBigUnsafe(popr, false)
669 s1 := p.String()
670 s2 := fmt.Sprintf("%v", p)
671 if s1 != s2 {
672 t.Fatalf("String want %v got %v", s1, s2)
673 }
674 }
675 func TestSubStringer(t *testing.T) {
676 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
677 p := NewPopulatedSub(popr, false)
678 s1 := p.String()
679 s2 := fmt.Sprintf("%v", p)
680 if s1 != s2 {
681 t.Fatalf("String want %v got %v", s1, s2)
682 }
683 }
684 func TestIntMergeStringer(t *testing.T) {
685 popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
686 p := NewPopulatedIntMerge(popr, false)
687 s1 := p.String()
688 s2 := fmt.Sprintf("%v", p)
689 if s1 != s2 {
690 t.Fatalf("String want %v got %v", s1, s2)
691 }
692 }
693
694
695
View as plain text