1
2
3
4 package test
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 math "math"
13 math_rand "math/rand"
14 testing "testing"
15 time "time"
16 )
17
18
19 var _ = proto.Marshal
20 var _ = fmt.Errorf
21 var _ = math.Inf
22
23 func TestNativeWithSizeCacheProto(t *testing.T) {
24 seed := time.Now().UnixNano()
25 popr := math_rand.New(math_rand.NewSource(seed))
26 p := NewPopulatedNativeWithSizeCache(popr, false)
27 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
28 if err != nil {
29 t.Fatalf("seed = %d, err = %v", seed, err)
30 }
31 msg := &NativeWithSizeCache{}
32 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
33 t.Fatalf("seed = %d, err = %v", seed, err)
34 }
35 littlefuzz := make([]byte, len(dAtA))
36 copy(littlefuzz, dAtA)
37 for i := range dAtA {
38 dAtA[i] = byte(popr.Intn(256))
39 }
40 if !p.Equal(msg) {
41 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
42 }
43 if len(littlefuzz) > 0 {
44 fuzzamount := 100
45 for i := 0; i < fuzzamount; i++ {
46 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
47 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
48 }
49
50 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
51 }
52 }
53
54 func TestStructWithSizeCacheProto(t *testing.T) {
55 seed := time.Now().UnixNano()
56 popr := math_rand.New(math_rand.NewSource(seed))
57 p := NewPopulatedStructWithSizeCache(popr, false)
58 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
59 if err != nil {
60 t.Fatalf("seed = %d, err = %v", seed, err)
61 }
62 msg := &StructWithSizeCache{}
63 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
64 t.Fatalf("seed = %d, err = %v", seed, err)
65 }
66 littlefuzz := make([]byte, len(dAtA))
67 copy(littlefuzz, dAtA)
68 for i := range dAtA {
69 dAtA[i] = byte(popr.Intn(256))
70 }
71 if !p.Equal(msg) {
72 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
73 }
74 if len(littlefuzz) > 0 {
75 fuzzamount := 100
76 for i := 0; i < fuzzamount; i++ {
77 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
78 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
79 }
80
81 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
82 }
83 }
84
85 func TestNativeWithoutSizeCacheProto(t *testing.T) {
86 seed := time.Now().UnixNano()
87 popr := math_rand.New(math_rand.NewSource(seed))
88 p := NewPopulatedNativeWithoutSizeCache(popr, false)
89 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
90 if err != nil {
91 t.Fatalf("seed = %d, err = %v", seed, err)
92 }
93 msg := &NativeWithoutSizeCache{}
94 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
95 t.Fatalf("seed = %d, err = %v", seed, err)
96 }
97 littlefuzz := make([]byte, len(dAtA))
98 copy(littlefuzz, dAtA)
99 for i := range dAtA {
100 dAtA[i] = byte(popr.Intn(256))
101 }
102 if !p.Equal(msg) {
103 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
104 }
105 if len(littlefuzz) > 0 {
106 fuzzamount := 100
107 for i := 0; i < fuzzamount; i++ {
108 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
109 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
110 }
111
112 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
113 }
114 }
115
116 func TestStructWithoutSizeCacheProto(t *testing.T) {
117 seed := time.Now().UnixNano()
118 popr := math_rand.New(math_rand.NewSource(seed))
119 p := NewPopulatedStructWithoutSizeCache(popr, false)
120 dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
121 if err != nil {
122 t.Fatalf("seed = %d, err = %v", seed, err)
123 }
124 msg := &StructWithoutSizeCache{}
125 if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
126 t.Fatalf("seed = %d, err = %v", seed, err)
127 }
128 littlefuzz := make([]byte, len(dAtA))
129 copy(littlefuzz, dAtA)
130 for i := range dAtA {
131 dAtA[i] = byte(popr.Intn(256))
132 }
133 if !p.Equal(msg) {
134 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
135 }
136 if len(littlefuzz) > 0 {
137 fuzzamount := 100
138 for i := 0; i < fuzzamount; i++ {
139 littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
140 littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
141 }
142
143 _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
144 }
145 }
146
147 func TestNativeWithSizeCacheJSON(t *testing.T) {
148 seed := time.Now().UnixNano()
149 popr := math_rand.New(math_rand.NewSource(seed))
150 p := NewPopulatedNativeWithSizeCache(popr, true)
151 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
152 jsondata, err := marshaler.MarshalToString(p)
153 if err != nil {
154 t.Fatalf("seed = %d, err = %v", seed, err)
155 }
156 msg := &NativeWithSizeCache{}
157 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
158 if err != nil {
159 t.Fatalf("seed = %d, err = %v", seed, err)
160 }
161 if !p.Equal(msg) {
162 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
163 }
164 }
165 func TestStructWithSizeCacheJSON(t *testing.T) {
166 seed := time.Now().UnixNano()
167 popr := math_rand.New(math_rand.NewSource(seed))
168 p := NewPopulatedStructWithSizeCache(popr, true)
169 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
170 jsondata, err := marshaler.MarshalToString(p)
171 if err != nil {
172 t.Fatalf("seed = %d, err = %v", seed, err)
173 }
174 msg := &StructWithSizeCache{}
175 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
176 if err != nil {
177 t.Fatalf("seed = %d, err = %v", seed, err)
178 }
179 if !p.Equal(msg) {
180 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
181 }
182 }
183 func TestNativeWithoutSizeCacheJSON(t *testing.T) {
184 seed := time.Now().UnixNano()
185 popr := math_rand.New(math_rand.NewSource(seed))
186 p := NewPopulatedNativeWithoutSizeCache(popr, true)
187 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
188 jsondata, err := marshaler.MarshalToString(p)
189 if err != nil {
190 t.Fatalf("seed = %d, err = %v", seed, err)
191 }
192 msg := &NativeWithoutSizeCache{}
193 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
194 if err != nil {
195 t.Fatalf("seed = %d, err = %v", seed, err)
196 }
197 if !p.Equal(msg) {
198 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
199 }
200 }
201 func TestStructWithoutSizeCacheJSON(t *testing.T) {
202 seed := time.Now().UnixNano()
203 popr := math_rand.New(math_rand.NewSource(seed))
204 p := NewPopulatedStructWithoutSizeCache(popr, true)
205 marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
206 jsondata, err := marshaler.MarshalToString(p)
207 if err != nil {
208 t.Fatalf("seed = %d, err = %v", seed, err)
209 }
210 msg := &StructWithoutSizeCache{}
211 err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
212 if err != nil {
213 t.Fatalf("seed = %d, err = %v", seed, err)
214 }
215 if !p.Equal(msg) {
216 t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
217 }
218 }
219 func TestNativeWithSizeCacheProtoText(t *testing.T) {
220 seed := time.Now().UnixNano()
221 popr := math_rand.New(math_rand.NewSource(seed))
222 p := NewPopulatedNativeWithSizeCache(popr, true)
223 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
224 msg := &NativeWithSizeCache{}
225 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
226 t.Fatalf("seed = %d, err = %v", seed, err)
227 }
228 if !p.Equal(msg) {
229 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
230 }
231 }
232
233 func TestNativeWithSizeCacheProtoCompactText(t *testing.T) {
234 seed := time.Now().UnixNano()
235 popr := math_rand.New(math_rand.NewSource(seed))
236 p := NewPopulatedNativeWithSizeCache(popr, true)
237 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
238 msg := &NativeWithSizeCache{}
239 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
240 t.Fatalf("seed = %d, err = %v", seed, err)
241 }
242 if !p.Equal(msg) {
243 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
244 }
245 }
246
247 func TestStructWithSizeCacheProtoText(t *testing.T) {
248 seed := time.Now().UnixNano()
249 popr := math_rand.New(math_rand.NewSource(seed))
250 p := NewPopulatedStructWithSizeCache(popr, true)
251 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
252 msg := &StructWithSizeCache{}
253 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
254 t.Fatalf("seed = %d, err = %v", seed, err)
255 }
256 if !p.Equal(msg) {
257 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
258 }
259 }
260
261 func TestStructWithSizeCacheProtoCompactText(t *testing.T) {
262 seed := time.Now().UnixNano()
263 popr := math_rand.New(math_rand.NewSource(seed))
264 p := NewPopulatedStructWithSizeCache(popr, true)
265 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
266 msg := &StructWithSizeCache{}
267 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
268 t.Fatalf("seed = %d, err = %v", seed, err)
269 }
270 if !p.Equal(msg) {
271 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
272 }
273 }
274
275 func TestNativeWithoutSizeCacheProtoText(t *testing.T) {
276 seed := time.Now().UnixNano()
277 popr := math_rand.New(math_rand.NewSource(seed))
278 p := NewPopulatedNativeWithoutSizeCache(popr, true)
279 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
280 msg := &NativeWithoutSizeCache{}
281 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
282 t.Fatalf("seed = %d, err = %v", seed, err)
283 }
284 if !p.Equal(msg) {
285 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
286 }
287 }
288
289 func TestNativeWithoutSizeCacheProtoCompactText(t *testing.T) {
290 seed := time.Now().UnixNano()
291 popr := math_rand.New(math_rand.NewSource(seed))
292 p := NewPopulatedNativeWithoutSizeCache(popr, true)
293 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
294 msg := &NativeWithoutSizeCache{}
295 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
296 t.Fatalf("seed = %d, err = %v", seed, err)
297 }
298 if !p.Equal(msg) {
299 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
300 }
301 }
302
303 func TestStructWithoutSizeCacheProtoText(t *testing.T) {
304 seed := time.Now().UnixNano()
305 popr := math_rand.New(math_rand.NewSource(seed))
306 p := NewPopulatedStructWithoutSizeCache(popr, true)
307 dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
308 msg := &StructWithoutSizeCache{}
309 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
310 t.Fatalf("seed = %d, err = %v", seed, err)
311 }
312 if !p.Equal(msg) {
313 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
314 }
315 }
316
317 func TestStructWithoutSizeCacheProtoCompactText(t *testing.T) {
318 seed := time.Now().UnixNano()
319 popr := math_rand.New(math_rand.NewSource(seed))
320 p := NewPopulatedStructWithoutSizeCache(popr, true)
321 dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
322 msg := &StructWithoutSizeCache{}
323 if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
324 t.Fatalf("seed = %d, err = %v", seed, err)
325 }
326 if !p.Equal(msg) {
327 t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
328 }
329 }
330
331
332
View as plain text