Line data Source code
1 : /* Attempts to test all the datatypes supported by ProtoBuf when used as callback fields.
2 : * Note that normally there would be no reason to use callback fields for this,
3 : * because each encoder defined here only gives a single field.
4 : */
5 :
6 : #include <stdio.h>
7 : #include <stdlib.h>
8 : #include <string.h>
9 : #include <pb_encode.h>
10 : #include "alltypes.pb.h"
11 : #include "test_helpers.h"
12 :
13 21 : static bool write_varint(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
14 : {
15 42 : return pb_encode_tag_for_field(stream, field) &&
16 21 : pb_encode_varint(stream, (intptr_t)*arg);
17 : }
18 :
19 6 : static bool write_svarint(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
20 : {
21 12 : return pb_encode_tag_for_field(stream, field) &&
22 6 : pb_encode_svarint(stream, (intptr_t)*arg);
23 : }
24 :
25 9 : static bool write_fixed32(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
26 : {
27 18 : return pb_encode_tag_for_field(stream, field) &&
28 9 : pb_encode_fixed32(stream, *arg);
29 : }
30 :
31 6 : static bool write_fixed64(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
32 : {
33 12 : return pb_encode_tag_for_field(stream, field) &&
34 6 : pb_encode_fixed64(stream, *arg);
35 : }
36 :
37 3 : static bool write_double(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
38 : {
39 : #ifdef PB_CONVERT_DOUBLE_FLOAT
40 : if (sizeof(double) == sizeof(float))
41 : return pb_encode_tag_for_field(stream, field) &&
42 : pb_encode_float_as_double(stream, *(float*)*arg);
43 : #endif
44 :
45 6 : return pb_encode_tag_for_field(stream, field) &&
46 3 : pb_encode_fixed64(stream, *arg);
47 : }
48 :
49 9 : static bool write_string(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
50 : {
51 18 : return pb_encode_tag_for_field(stream, field) &&
52 9 : pb_encode_string(stream, *arg, strlen(*arg));
53 : }
54 :
55 4 : static bool write_submsg(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
56 : {
57 :
58 8 : return pb_encode_tag_for_field(stream, field) &&
59 4 : pb_encode_submessage(stream, SubMessage_fields, *arg);
60 : }
61 :
62 3 : static bool write_emptymsg(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
63 : {
64 3 : EmptyMessage emptymsg = {0};
65 6 : return pb_encode_tag_for_field(stream, field) &&
66 3 : pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg);
67 : }
68 :
69 14 : static bool write_repeated_varint(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
70 : {
71 28 : return pb_encode_tag_for_field(stream, field) &&
72 28 : pb_encode_varint(stream, 0) &&
73 28 : pb_encode_tag_for_field(stream, field) &&
74 28 : pb_encode_varint(stream, 0) &&
75 28 : pb_encode_tag_for_field(stream, field) &&
76 28 : pb_encode_varint(stream, 0) &&
77 28 : pb_encode_tag_for_field(stream, field) &&
78 28 : pb_encode_varint(stream, 0) &&
79 42 : pb_encode_tag_for_field(stream, field) &&
80 14 : pb_encode_varint(stream, (intptr_t)*arg);
81 : }
82 :
83 4 : static bool write_repeated_svarint(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
84 : {
85 8 : return pb_encode_tag_for_field(stream, field) &&
86 8 : pb_encode_svarint(stream, 0) &&
87 8 : pb_encode_tag_for_field(stream, field) &&
88 8 : pb_encode_svarint(stream, 0) &&
89 8 : pb_encode_tag_for_field(stream, field) &&
90 8 : pb_encode_svarint(stream, 0) &&
91 8 : pb_encode_tag_for_field(stream, field) &&
92 8 : pb_encode_svarint(stream, 0) &&
93 12 : pb_encode_tag_for_field(stream, field) &&
94 4 : pb_encode_svarint(stream, (intptr_t)*arg);
95 : }
96 :
97 6 : static bool write_repeated_fixed32(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
98 : {
99 6 : uint32_t dummy = 0;
100 :
101 : /* Make it a packed field */
102 12 : return pb_encode_tag(stream, PB_WT_STRING, field->tag) &&
103 12 : pb_encode_varint(stream, 5 * 4) && /* Number of bytes */
104 12 : pb_encode_fixed32(stream, &dummy) &&
105 12 : pb_encode_fixed32(stream, &dummy) &&
106 12 : pb_encode_fixed32(stream, &dummy) &&
107 18 : pb_encode_fixed32(stream, &dummy) &&
108 6 : pb_encode_fixed32(stream, *arg);
109 : }
110 :
111 4 : static bool write_repeated_fixed64(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
112 : {
113 4 : uint64_t dummy = 0;
114 :
115 : /* Make it a packed field */
116 8 : return pb_encode_tag(stream, PB_WT_STRING, field->tag) &&
117 8 : pb_encode_varint(stream, 5 * 8) && /* Number of bytes */
118 8 : pb_encode_fixed64(stream, &dummy) &&
119 8 : pb_encode_fixed64(stream, &dummy) &&
120 8 : pb_encode_fixed64(stream, &dummy) &&
121 12 : pb_encode_fixed64(stream, &dummy) &&
122 4 : pb_encode_fixed64(stream, *arg);
123 : }
124 :
125 2 : static bool write_repeated_double(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
126 : {
127 2 : uint64_t dummy = 0;
128 :
129 : #ifdef PB_CONVERT_DOUBLE_FLOAT
130 : if (sizeof(double) == sizeof(float))
131 : return pb_encode_tag(stream, PB_WT_STRING, field->tag) &&
132 : pb_encode_varint(stream, 5 * 8) && /* Number of bytes */
133 : pb_encode_float_as_double(stream, 0.0f) &&
134 : pb_encode_float_as_double(stream, 0.0f) &&
135 : pb_encode_float_as_double(stream, 0.0f) &&
136 : pb_encode_float_as_double(stream, 0.0f) &&
137 : pb_encode_float_as_double(stream, *(float*)*arg);
138 : #endif
139 :
140 : /* Make it a packed field */
141 4 : return pb_encode_tag(stream, PB_WT_STRING, field->tag) &&
142 4 : pb_encode_varint(stream, 5 * 8) && /* Number of bytes */
143 4 : pb_encode_fixed64(stream, &dummy) &&
144 4 : pb_encode_fixed64(stream, &dummy) &&
145 4 : pb_encode_fixed64(stream, &dummy) &&
146 6 : pb_encode_fixed64(stream, &dummy) &&
147 2 : pb_encode_fixed64(stream, *arg);
148 : }
149 :
150 6 : static bool write_repeated_string(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
151 : {
152 12 : return pb_encode_tag_for_field(stream, field) &&
153 12 : pb_encode_string(stream, 0, 0) &&
154 12 : pb_encode_tag_for_field(stream, field) &&
155 12 : pb_encode_string(stream, 0, 0) &&
156 12 : pb_encode_tag_for_field(stream, field) &&
157 12 : pb_encode_string(stream, 0, 0) &&
158 12 : pb_encode_tag_for_field(stream, field) &&
159 12 : pb_encode_string(stream, 0, 0) &&
160 18 : pb_encode_tag_for_field(stream, field) &&
161 6 : pb_encode_string(stream, *arg, strlen(*arg));
162 : }
163 :
164 2 : static bool write_repeated_submsg(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
165 : {
166 2 : SubMessage dummy = {""};
167 :
168 4 : return pb_encode_tag_for_field(stream, field) &&
169 4 : pb_encode_submessage(stream, SubMessage_fields, &dummy) &&
170 4 : pb_encode_tag_for_field(stream, field) &&
171 4 : pb_encode_submessage(stream, SubMessage_fields, &dummy) &&
172 4 : pb_encode_tag_for_field(stream, field) &&
173 4 : pb_encode_submessage(stream, SubMessage_fields, &dummy) &&
174 4 : pb_encode_tag_for_field(stream, field) &&
175 4 : pb_encode_submessage(stream, SubMessage_fields, &dummy) &&
176 6 : pb_encode_tag_for_field(stream, field) &&
177 2 : pb_encode_submessage(stream, SubMessage_fields, *arg);
178 : }
179 :
180 2 : static bool write_limits(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
181 : {
182 2 : Limits limits = {0};
183 2 : limits.int32_min = INT32_MIN;
184 2 : limits.int32_max = INT32_MAX;
185 2 : limits.uint32_min = 0;
186 2 : limits.uint32_max = UINT32_MAX;
187 2 : limits.int64_min = INT64_MIN;
188 2 : limits.int64_max = INT64_MAX;
189 2 : limits.uint64_min = 0;
190 2 : limits.uint64_max = UINT64_MAX;
191 2 : limits.enum_min = HugeEnum_Negative;
192 2 : limits.enum_max = HugeEnum_Positive;
193 2 : limits.largetag = 1001;
194 :
195 4 : return pb_encode_tag_for_field(stream, field) &&
196 2 : pb_encode_submessage(stream, Limits_fields, &limits);
197 : }
198 :
199 2 : static bool write_ds8(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
200 : {
201 2 : DescriptorSize8 ds8 = {9991,9992};
202 :
203 4 : return pb_encode_tag_for_field(stream, field) &&
204 2 : pb_encode_submessage(stream, DescriptorSize8_fields, &ds8);
205 : }
206 :
207 2 : static bool write_intsizes(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
208 : {
209 2 : IntSizes intsizes = {-128, 255, -128, -32768, 65535, -32768};
210 :
211 4 : return pb_encode_tag_for_field(stream, field) &&
212 2 : pb_encode_submessage(stream, IntSizes_fields, &intsizes);
213 : }
214 :
215 2 : static bool write_repeated_emptymsg(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
216 : {
217 2 : EmptyMessage emptymsg = {0};
218 4 : return pb_encode_tag_for_field(stream, field) &&
219 4 : pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg) &&
220 4 : pb_encode_tag_for_field(stream, field) &&
221 4 : pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg) &&
222 4 : pb_encode_tag_for_field(stream, field) &&
223 4 : pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg) &&
224 4 : pb_encode_tag_for_field(stream, field) &&
225 4 : pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg) &&
226 6 : pb_encode_tag_for_field(stream, field) &&
227 2 : pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg);
228 : }
229 :
230 2 : static bool write_farray2(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
231 : {
232 2 : uint32_t dummy = 0;
233 2 : uint32_t value = (uint32_t)(intptr_t)*arg;
234 :
235 : /* Make it a packed field */
236 4 : return pb_encode_tag(stream, PB_WT_STRING, field->tag) &&
237 4 : pb_encode_varint(stream, 3 * 4) && /* Number of bytes */
238 4 : pb_encode_fixed32(stream, &dummy) &&
239 6 : pb_encode_fixed32(stream, &dummy) &&
240 2 : pb_encode_fixed32(stream, &value);
241 : }
242 :
243 2 : int main(int argc, char **argv)
244 : {
245 2 : int mode = (argc > 1) ? atoi(argv[1]) : 0;
246 :
247 : /* Values for use from callbacks through pointers. */
248 2 : uint32_t req_fixed32 = 1008;
249 2 : int32_t req_sfixed32 = -1009;
250 2 : float req_float = 1010.0f;
251 2 : uint64_t req_fixed64 = 1011;
252 2 : int64_t req_sfixed64 = -1012;
253 2 : double req_double = 1013.0;
254 2 : SubMessage req_submsg = {"1016", 1016};
255 :
256 2 : uint32_t rep_fixed32 = 2008;
257 2 : int32_t rep_sfixed32 = -2009;
258 2 : float rep_float = 2010.0f;
259 2 : uint64_t rep_fixed64 = 2011;
260 2 : int64_t rep_sfixed64 = -2012;
261 2 : double rep_double = 2013.0;
262 2 : SubMessage rep_submsg = {"2016", 2016, true, 2016};
263 :
264 2 : uint32_t opt_fixed32 = 3048;
265 2 : int32_t opt_sfixed32 = 3049;
266 2 : float opt_float = 3050.0f;
267 2 : uint64_t opt_fixed64 = 3051;
268 2 : int64_t opt_sfixed64 = 3052;
269 2 : double opt_double = 3053.0f;
270 2 : SubMessage opt_submsg = {"3056", 3056};
271 :
272 2 : SubMessage oneof_msg1 = {"4059", 4059};
273 :
274 : /* Bind callbacks for required fields */
275 2 : AllTypes alltypes = {{{0}}};
276 :
277 2 : alltypes.req_int32.funcs.encode = &write_varint;
278 2 : alltypes.req_int32.arg = (void*)-1001;
279 :
280 2 : alltypes.req_int64.funcs.encode = &write_varint;
281 2 : alltypes.req_int64.arg = (void*)-1002;
282 :
283 2 : alltypes.req_uint32.funcs.encode = &write_varint;
284 2 : alltypes.req_uint32.arg = (void*)1003;
285 :
286 2 : alltypes.req_uint32.funcs.encode = &write_varint;
287 2 : alltypes.req_uint32.arg = (void*)1003;
288 :
289 2 : alltypes.req_uint64.funcs.encode = &write_varint;
290 2 : alltypes.req_uint64.arg = (void*)1004;
291 :
292 2 : alltypes.req_sint32.funcs.encode = &write_svarint;
293 2 : alltypes.req_sint32.arg = (void*)-1005;
294 :
295 2 : alltypes.req_sint64.funcs.encode = &write_svarint;
296 2 : alltypes.req_sint64.arg = (void*)-1006;
297 :
298 2 : alltypes.req_bool.funcs.encode = &write_varint;
299 2 : alltypes.req_bool.arg = (void*)true;
300 :
301 2 : alltypes.req_fixed32.funcs.encode = &write_fixed32;
302 2 : alltypes.req_fixed32.arg = &req_fixed32;
303 :
304 2 : alltypes.req_sfixed32.funcs.encode = &write_fixed32;
305 2 : alltypes.req_sfixed32.arg = &req_sfixed32;
306 :
307 2 : alltypes.req_float.funcs.encode = &write_fixed32;
308 2 : alltypes.req_float.arg = &req_float;
309 :
310 2 : alltypes.req_fixed64.funcs.encode = &write_fixed64;
311 2 : alltypes.req_fixed64.arg = &req_fixed64;
312 :
313 2 : alltypes.req_sfixed64.funcs.encode = &write_fixed64;
314 2 : alltypes.req_sfixed64.arg = &req_sfixed64;
315 :
316 2 : alltypes.req_double.funcs.encode = &write_double;
317 2 : alltypes.req_double.arg = &req_double;
318 :
319 2 : alltypes.req_string.funcs.encode = &write_string;
320 2 : alltypes.req_string.arg = "1014";
321 :
322 2 : alltypes.req_bytes.funcs.encode = &write_string;
323 2 : alltypes.req_bytes.arg = "1015";
324 :
325 2 : alltypes.req_submsg.funcs.encode = &write_submsg;
326 2 : alltypes.req_submsg.arg = &req_submsg;
327 :
328 2 : alltypes.req_enum.funcs.encode = &write_varint;
329 2 : alltypes.req_enum.arg = (void*)MyEnum_Truth;
330 :
331 2 : alltypes.req_emptymsg.funcs.encode = &write_emptymsg;
332 :
333 2 : alltypes.req_fbytes.funcs.encode = &write_string;
334 2 : alltypes.req_fbytes.arg = "1019";
335 :
336 : /* Bind callbacks for repeated fields */
337 2 : alltypes.rep_int32.funcs.encode = &write_repeated_varint;
338 2 : alltypes.rep_int32.arg = (void*)-2001;
339 :
340 2 : alltypes.rep_int64.funcs.encode = &write_repeated_varint;
341 2 : alltypes.rep_int64.arg = (void*)-2002;
342 :
343 2 : alltypes.rep_uint32.funcs.encode = &write_repeated_varint;
344 2 : alltypes.rep_uint32.arg = (void*)2003;
345 :
346 2 : alltypes.rep_uint64.funcs.encode = &write_repeated_varint;
347 2 : alltypes.rep_uint64.arg = (void*)2004;
348 :
349 2 : alltypes.rep_sint32.funcs.encode = &write_repeated_svarint;
350 2 : alltypes.rep_sint32.arg = (void*)-2005;
351 :
352 2 : alltypes.rep_sint64.funcs.encode = &write_repeated_svarint;
353 2 : alltypes.rep_sint64.arg = (void*)-2006;
354 :
355 2 : alltypes.rep_bool.funcs.encode = &write_repeated_varint;
356 2 : alltypes.rep_bool.arg = (void*)true;
357 :
358 2 : alltypes.rep_fixed32.funcs.encode = &write_repeated_fixed32;
359 2 : alltypes.rep_fixed32.arg = &rep_fixed32;
360 :
361 2 : alltypes.rep_sfixed32.funcs.encode = &write_repeated_fixed32;
362 2 : alltypes.rep_sfixed32.arg = &rep_sfixed32;
363 :
364 2 : alltypes.rep_float.funcs.encode = &write_repeated_fixed32;
365 2 : alltypes.rep_float.arg = &rep_float;
366 :
367 2 : alltypes.rep_fixed64.funcs.encode = &write_repeated_fixed64;
368 2 : alltypes.rep_fixed64.arg = &rep_fixed64;
369 :
370 2 : alltypes.rep_sfixed64.funcs.encode = &write_repeated_fixed64;
371 2 : alltypes.rep_sfixed64.arg = &rep_sfixed64;
372 :
373 2 : alltypes.rep_double.funcs.encode = &write_repeated_double;
374 2 : alltypes.rep_double.arg = &rep_double;
375 :
376 2 : alltypes.rep_string.funcs.encode = &write_repeated_string;
377 2 : alltypes.rep_string.arg = "2014";
378 :
379 2 : alltypes.rep_bytes.funcs.encode = &write_repeated_string;
380 2 : alltypes.rep_bytes.arg = "2015";
381 :
382 2 : alltypes.rep_submsg.funcs.encode = &write_repeated_submsg;
383 2 : alltypes.rep_submsg.arg = &rep_submsg;
384 :
385 2 : alltypes.rep_enum.funcs.encode = &write_repeated_varint;
386 2 : alltypes.rep_enum.arg = (void*)MyEnum_Truth;
387 :
388 2 : alltypes.rep_emptymsg.funcs.encode = &write_repeated_emptymsg;
389 :
390 2 : alltypes.rep_fbytes.funcs.encode = &write_repeated_string;
391 2 : alltypes.rep_fbytes.arg = "2019";
392 :
393 2 : alltypes.rep_farray.funcs.encode = &write_repeated_varint;
394 2 : alltypes.rep_farray.arg = (void*)2040;
395 :
396 2 : alltypes.rep_farray2.funcs.encode = &write_farray2;
397 2 : alltypes.rep_farray2.arg = (void*)2095;
398 :
399 2 : alltypes.req_limits.funcs.encode = &write_limits;
400 :
401 2 : alltypes.req_ds8.funcs.encode = &write_ds8;
402 :
403 2 : alltypes.req_intsizes.funcs.encode = &write_intsizes;
404 :
405 : /* Bind callbacks for optional fields */
406 2 : if (mode != 0)
407 : {
408 1 : alltypes.opt_int32.funcs.encode = &write_varint;
409 1 : alltypes.opt_int32.arg = (void*)3041;
410 :
411 1 : alltypes.opt_int64.funcs.encode = &write_varint;
412 1 : alltypes.opt_int64.arg = (void*)3042;
413 :
414 1 : alltypes.opt_uint32.funcs.encode = &write_varint;
415 1 : alltypes.opt_uint32.arg = (void*)3043;
416 :
417 1 : alltypes.opt_uint64.funcs.encode = &write_varint;
418 1 : alltypes.opt_uint64.arg = (void*)3044;
419 :
420 1 : alltypes.opt_sint32.funcs.encode = &write_svarint;
421 1 : alltypes.opt_sint32.arg = (void*)3045;
422 :
423 1 : alltypes.opt_sint64.funcs.encode = &write_svarint;
424 1 : alltypes.opt_sint64.arg = (void*)3046;
425 :
426 1 : alltypes.opt_bool.funcs.encode = &write_varint;
427 1 : alltypes.opt_bool.arg = (void*)true;
428 :
429 1 : alltypes.opt_fixed32.funcs.encode = &write_fixed32;
430 1 : alltypes.opt_fixed32.arg = &opt_fixed32;
431 :
432 1 : alltypes.opt_sfixed32.funcs.encode = &write_fixed32;
433 1 : alltypes.opt_sfixed32.arg = &opt_sfixed32;
434 :
435 1 : alltypes.opt_float.funcs.encode = &write_fixed32;
436 1 : alltypes.opt_float.arg = &opt_float;
437 :
438 1 : alltypes.opt_fixed64.funcs.encode = &write_fixed64;
439 1 : alltypes.opt_fixed64.arg = &opt_fixed64;
440 :
441 1 : alltypes.opt_sfixed64.funcs.encode = &write_fixed64;
442 1 : alltypes.opt_sfixed64.arg = &opt_sfixed64;
443 :
444 1 : alltypes.opt_double.funcs.encode = &write_double;
445 1 : alltypes.opt_double.arg = &opt_double;
446 :
447 1 : alltypes.opt_string.funcs.encode = &write_string;
448 1 : alltypes.opt_string.arg = "3054";
449 :
450 1 : alltypes.opt_bytes.funcs.encode = &write_string;
451 1 : alltypes.opt_bytes.arg = "3055";
452 :
453 1 : alltypes.opt_submsg.funcs.encode = &write_submsg;
454 1 : alltypes.opt_submsg.arg = &opt_submsg;
455 :
456 1 : alltypes.opt_enum.funcs.encode = &write_varint;
457 1 : alltypes.opt_enum.arg = (void*)MyEnum_Truth;
458 :
459 1 : alltypes.opt_emptymsg.funcs.encode = &write_emptymsg;
460 :
461 1 : alltypes.opt_fbytes.funcs.encode = &write_string;
462 1 : alltypes.opt_fbytes.arg = "3059";
463 :
464 1 : alltypes.oneof_msg1.funcs.encode = &write_submsg;
465 1 : alltypes.oneof_msg1.arg = &oneof_msg1;
466 :
467 1 : alltypes.opt_non_zero_based_enum.funcs.encode = &write_varint;
468 1 : alltypes.opt_non_zero_based_enum.arg = (void *)NonZeroBasedEnum_Three;
469 : }
470 :
471 2 : alltypes.end.funcs.encode = &write_varint;
472 2 : alltypes.end.arg = (void*)1099;
473 :
474 : {
475 : uint8_t buffer[2048];
476 2 : pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
477 :
478 : /* Now encode it and check if we succeeded. */
479 2 : if (pb_encode(&stream, AllTypes_fields, &alltypes))
480 : {
481 : SET_BINARY_MODE(stdout);
482 2 : fwrite(buffer, 1, stream.bytes_written, stdout);
483 2 : return 0; /* Success */
484 : }
485 : else
486 : {
487 0 : fprintf(stderr, "Encoding failed: %s\n", PB_GET_ERROR(&stream));
488 0 : return 1; /* Failure */
489 : }
490 : }
491 : }
|
