1 /* This includes the whole .c file to get access to static functions. */
2 #include "pb_common.c"
3 #include "pb_encode.c"
4
5 #include <stdio.h>
6 #include <string.h>
7 #include "unittests.h"
8 #include "unittestproto.pb.h"
9
streamcallback(pb_ostream_t * stream,const uint8_t * buf,size_t count)10 bool streamcallback(pb_ostream_t *stream, const uint8_t *buf, size_t count)
11 {
12 /* Allow only 'x' to be written */
13 while (count--)
14 {
15 if (*buf++ != 'x')
16 return false;
17 }
18 return true;
19 }
20
fieldcallback(pb_ostream_t * stream,const pb_field_t * field,void * const * arg)21 bool fieldcallback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
22 {
23 int value = 0x55;
24 if (!pb_encode_tag_for_field(stream, field))
25 return false;
26 return pb_encode_varint(stream, value);
27 }
28
crazyfieldcallback(pb_ostream_t * stream,const pb_field_t * field,void * const * arg)29 bool crazyfieldcallback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
30 {
31 /* This callback writes different amount of data the second time. */
32 uint32_t *state = (uint32_t*)arg;
33 *state <<= 8;
34 if (!pb_encode_tag_for_field(stream, field))
35 return false;
36 return pb_encode_varint(stream, *state);
37 }
38
39 /* Check that expression x writes data y.
40 * Y is a string, which may contain null bytes. Null terminator is ignored.
41 */
42 #define WRITES(x, y) \
43 memset(buffer, 0xAA, sizeof(buffer)), \
44 s = pb_ostream_from_buffer(buffer, sizeof(buffer)), \
45 (x) && \
46 memcmp(buffer, y, sizeof(y) - 1) == 0 && \
47 buffer[sizeof(y) - 1] == 0xAA
48
main()49 int main()
50 {
51 int status = 0;
52
53 {
54 uint8_t buffer1[] = "foobartest1234";
55 uint8_t buffer2[sizeof(buffer1)];
56 pb_ostream_t stream = pb_ostream_from_buffer(buffer2, sizeof(buffer1));
57
58 COMMENT("Test pb_write and pb_ostream_t");
59 TEST(pb_write(&stream, buffer1, sizeof(buffer1)));
60 TEST(memcmp(buffer1, buffer2, sizeof(buffer1)) == 0);
61 TEST(!pb_write(&stream, buffer1, 1));
62 TEST(stream.bytes_written == sizeof(buffer1));
63 }
64
65 {
66 uint8_t buffer1[] = "xxxxxxx";
67 pb_ostream_t stream = {&streamcallback, 0, SIZE_MAX, 0};
68
69 COMMENT("Test pb_write with custom callback");
70 TEST(pb_write(&stream, buffer1, 5));
71 buffer1[0] = 'a';
72 TEST(!pb_write(&stream, buffer1, 5));
73 }
74
75 {
76 uint8_t buffer[30];
77 pb_ostream_t s;
78
79 COMMENT("Test pb_encode_varint")
80 TEST(WRITES(pb_encode_varint(&s, 0), "\0"));
81 TEST(WRITES(pb_encode_varint(&s, 1), "\1"));
82 TEST(WRITES(pb_encode_varint(&s, 0x7F), "\x7F"));
83 TEST(WRITES(pb_encode_varint(&s, 0x80), "\x80\x01"));
84 TEST(WRITES(pb_encode_varint(&s, UINT32_MAX), "\xFF\xFF\xFF\xFF\x0F"));
85 TEST(WRITES(pb_encode_varint(&s, UINT64_MAX), "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
86 }
87
88 {
89 uint8_t buffer[30];
90 pb_ostream_t s;
91
92 COMMENT("Test pb_encode_tag")
93 TEST(WRITES(pb_encode_tag(&s, PB_WT_STRING, 5), "\x2A"));
94 TEST(WRITES(pb_encode_tag(&s, PB_WT_VARINT, 99), "\x98\x06"));
95 }
96
97 {
98 uint8_t buffer[30];
99 pb_ostream_t s;
100 pb_field_t field = {10, PB_LTYPE_SVARINT};
101
102 COMMENT("Test pb_encode_tag_for_field")
103 TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x50"));
104
105 field.type = PB_LTYPE_FIXED64;
106 TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x51"));
107
108 field.type = PB_LTYPE_STRING;
109 TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x52"));
110
111 field.type = PB_LTYPE_FIXED32;
112 TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x55"));
113 }
114
115 {
116 uint8_t buffer[30];
117 pb_ostream_t s;
118
119 COMMENT("Test pb_encode_string")
120 TEST(WRITES(pb_encode_string(&s, (const uint8_t*)"abcd", 4), "\x04""abcd"));
121 TEST(WRITES(pb_encode_string(&s, (const uint8_t*)"abcd\x00", 5), "\x05""abcd\x00"));
122 TEST(WRITES(pb_encode_string(&s, (const uint8_t*)"", 0), "\x00"));
123 }
124
125 {
126 uint8_t buffer[30];
127 pb_ostream_t s;
128 uint8_t value = 1;
129 int32_t max = INT32_MAX;
130 int32_t min = INT32_MIN;
131 int64_t lmax = INT64_MAX;
132 int64_t lmin = INT64_MIN;
133 pb_field_t field = {1, PB_LTYPE_VARINT, 0, 0, sizeof(value)};
134
135 COMMENT("Test pb_enc_varint and pb_enc_svarint")
136 TEST(WRITES(pb_enc_varint(&s, &field, &value), "\x01"));
137
138 field.data_size = sizeof(max);
139 TEST(WRITES(pb_enc_svarint(&s, &field, &max), "\xfe\xff\xff\xff\x0f"));
140 TEST(WRITES(pb_enc_svarint(&s, &field, &min), "\xff\xff\xff\xff\x0f"));
141
142 field.data_size = sizeof(lmax);
143 TEST(WRITES(pb_enc_svarint(&s, &field, &lmax), "\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
144 TEST(WRITES(pb_enc_svarint(&s, &field, &lmin), "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
145 }
146
147 {
148 uint8_t buffer[30];
149 pb_ostream_t s;
150 float fvalue;
151 double dvalue;
152
153 COMMENT("Test pb_enc_fixed32 using float")
154 fvalue = 0.0f;
155 TEST(WRITES(pb_enc_fixed32(&s, NULL, &fvalue), "\x00\x00\x00\x00"))
156 fvalue = 99.0f;
157 TEST(WRITES(pb_enc_fixed32(&s, NULL, &fvalue), "\x00\x00\xc6\x42"))
158 fvalue = -12345678.0f;
159 TEST(WRITES(pb_enc_fixed32(&s, NULL, &fvalue), "\x4e\x61\x3c\xcb"))
160
161 COMMENT("Test pb_enc_fixed64 using double")
162 dvalue = 0.0;
163 TEST(WRITES(pb_enc_fixed64(&s, NULL, &dvalue), "\x00\x00\x00\x00\x00\x00\x00\x00"))
164 dvalue = 99.0;
165 TEST(WRITES(pb_enc_fixed64(&s, NULL, &dvalue), "\x00\x00\x00\x00\x00\xc0\x58\x40"))
166 dvalue = -12345678.0;
167 TEST(WRITES(pb_enc_fixed64(&s, NULL, &dvalue), "\x00\x00\x00\xc0\x29\x8c\x67\xc1"))
168 }
169
170 {
171 uint8_t buffer[30];
172 pb_ostream_t s;
173 struct { pb_size_t size; uint8_t bytes[5]; } value = {5, {'x', 'y', 'z', 'z', 'y'}};
174
175 COMMENT("Test pb_enc_bytes")
176 TEST(WRITES(pb_enc_bytes(&s, &BytesMessage_fields[0], &value), "\x05xyzzy"))
177 value.size = 0;
178 TEST(WRITES(pb_enc_bytes(&s, &BytesMessage_fields[0], &value), "\x00"))
179 }
180
181 {
182 uint8_t buffer[30];
183 pb_ostream_t s;
184 char value[30] = "xyzzy";
185
186 COMMENT("Test pb_enc_string")
187 TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x05xyzzy"))
188 value[0] = '\0';
189 TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x00"))
190 memset(value, 'x', 30);
191 TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x0Axxxxxxxxxx"))
192 }
193
194 {
195 uint8_t buffer[10];
196 pb_ostream_t s;
197 IntegerArray msg = {5, {1, 2, 3, 4, 5}};
198
199 COMMENT("Test pb_encode with int32 array")
200
201 TEST(WRITES(pb_encode(&s, IntegerArray_fields, &msg), "\x0A\x05\x01\x02\x03\x04\x05"))
202
203 msg.data_count = 0;
204 TEST(WRITES(pb_encode(&s, IntegerArray_fields, &msg), ""))
205
206 msg.data_count = 10;
207 TEST(!pb_encode(&s, IntegerArray_fields, &msg))
208 }
209
210 {
211 uint8_t buffer[10];
212 pb_ostream_t s;
213 FloatArray msg = {1, {99.0f}};
214
215 COMMENT("Test pb_encode with float array")
216
217 TEST(WRITES(pb_encode(&s, FloatArray_fields, &msg),
218 "\x0A\x04\x00\x00\xc6\x42"))
219
220 msg.data_count = 0;
221 TEST(WRITES(pb_encode(&s, FloatArray_fields, &msg), ""))
222
223 msg.data_count = 3;
224 TEST(!pb_encode(&s, FloatArray_fields, &msg))
225 }
226
227 {
228 uint8_t buffer[50];
229 pb_ostream_t s;
230 FloatArray msg = {1, {99.0f}};
231
232 COMMENT("Test array size limit in pb_encode")
233
234 s = pb_ostream_from_buffer(buffer, sizeof(buffer));
235 TEST((msg.data_count = 10) && pb_encode(&s, FloatArray_fields, &msg))
236
237 s = pb_ostream_from_buffer(buffer, sizeof(buffer));
238 TEST((msg.data_count = 11) && !pb_encode(&s, FloatArray_fields, &msg))
239 }
240
241 {
242 uint8_t buffer[10];
243 pb_ostream_t s;
244 CallbackArray msg;
245
246 msg.data.funcs.encode = &fieldcallback;
247
248 COMMENT("Test pb_encode with callback field.")
249 TEST(WRITES(pb_encode(&s, CallbackArray_fields, &msg), "\x08\x55"))
250 }
251
252 {
253 uint8_t buffer[10];
254 pb_ostream_t s;
255 IntegerContainer msg = {{5, {1,2,3,4,5}}};
256
257 COMMENT("Test pb_encode with packed array in a submessage.")
258 TEST(WRITES(pb_encode(&s, IntegerContainer_fields, &msg),
259 "\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
260 }
261
262 {
263 uint8_t buffer[32];
264 pb_ostream_t s;
265 BytesMessage msg = {{3, "xyz"}};
266
267 COMMENT("Test pb_encode with bytes message.")
268 TEST(WRITES(pb_encode(&s, BytesMessage_fields, &msg),
269 "\x0A\x03xyz"))
270
271 msg.data.size = 17; /* More than maximum */
272 TEST(!pb_encode(&s, BytesMessage_fields, &msg))
273 }
274
275
276 {
277 uint8_t buffer[20];
278 pb_ostream_t s;
279 IntegerContainer msg = {{5, {1,2,3,4,5}}};
280
281 COMMENT("Test pb_encode_delimited.")
282 TEST(WRITES(pb_encode_delimited(&s, IntegerContainer_fields, &msg),
283 "\x09\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
284 }
285
286 {
287 IntegerContainer msg = {{5, {1,2,3,4,5}}};
288 size_t size;
289
290 COMMENT("Test pb_get_encoded_size.")
291 TEST(pb_get_encoded_size(&size, IntegerContainer_fields, &msg) &&
292 size == 9);
293 }
294
295 {
296 uint8_t buffer[10];
297 pb_ostream_t s;
298 CallbackContainer msg;
299 CallbackContainerContainer msg2;
300 uint32_t state = 1;
301
302 msg.submsg.data.funcs.encode = &fieldcallback;
303 msg2.submsg.submsg.data.funcs.encode = &fieldcallback;
304
305 COMMENT("Test pb_encode with callback field in a submessage.")
306 TEST(WRITES(pb_encode(&s, CallbackContainer_fields, &msg), "\x0A\x02\x08\x55"))
307 TEST(WRITES(pb_encode(&s, CallbackContainerContainer_fields, &msg2),
308 "\x0A\x04\x0A\x02\x08\x55"))
309
310 /* Misbehaving callback: varying output between calls */
311 msg.submsg.data.funcs.encode = &crazyfieldcallback;
312 msg.submsg.data.arg = &state;
313 msg2.submsg.submsg.data.funcs.encode = &crazyfieldcallback;
314 msg2.submsg.submsg.data.arg = &state;
315
316 TEST(!pb_encode(&s, CallbackContainer_fields, &msg))
317 state = 1;
318 TEST(!pb_encode(&s, CallbackContainerContainer_fields, &msg2))
319 }
320
321 {
322 uint8_t buffer[StringMessage_size];
323 pb_ostream_t s;
324 StringMessage msg = {"0123456789"};
325
326 s = pb_ostream_from_buffer(buffer, sizeof(buffer));
327
328 COMMENT("Test that StringMessage_size is correct")
329
330 TEST(pb_encode(&s, StringMessage_fields, &msg));
331 TEST(s.bytes_written == StringMessage_size);
332 }
333
334 {
335 uint8_t buffer[128];
336 pb_ostream_t s;
337 StringPointerContainer msg = StringPointerContainer_init_zero;
338 char *strs[1] = {NULL};
339 char zstr[] = "Z";
340
341 COMMENT("Test string pointer encoding.");
342
343 msg.rep_str = strs;
344 msg.rep_str_count = 1;
345 TEST(WRITES(pb_encode(&s, StringPointerContainer_fields, &msg), "\x0a\x00"))
346
347 strs[0] = zstr;
348 TEST(WRITES(pb_encode(&s, StringPointerContainer_fields, &msg), "\x0a\x01Z"))
349 }
350
351 if (status != 0)
352 fprintf(stdout, "\n\nSome tests FAILED!\n");
353
354 return status;
355 }
356