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