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 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 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 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 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
