tests/decode_unittests/decode_unittests.c

   1 /* This includes the whole .c file to get access to static functions. */
   2 #define PB_ENABLE_MALLOC
   3 #include "pb_decode.c"
   4
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include "unittests.h"
   8 #include "unittestproto.pb.h"
   9
  10 #define S(x) pb_istream_from_buffer((uint8_t*)x, sizeof(x) - 1)
  11
  12 bool stream_callback(pb_istream_t *stream, uint8_t *buf, size_t count)
  13 {
  14     if (stream->state != NULL)
  15         return false; /* Simulate error */
  16
  17     if (buf != NULL)
  18         memset(buf, 'x', count);
  19     return true;
  20 }
  21
  22 /* Verifies that the stream passed to callback matches the byte array pointed to by arg. */
  23 bool callback_check(pb_istream_t *stream, const pb_field_t *field, void **arg)
  24 {
  25     int i;
  26     uint8_t byte;
  27     pb_bytes_array_t *ref = (pb_bytes_array_t*) *arg;
  28
  29     for (i = 0; i < ref->size; i++)
  30     {
  31         if (!pb_read(stream, &byte, 1))
  32             return false;
  33
  34         if (byte != ref->bytes[i])
  35             return false;
  36     }
  37
  38     return true;
  39 }
  40
  41 int main()
  42 {
  43     int status = 0;
  44
  45     {
  46         uint8_t buffer1[] = "foobartest1234";
  47         uint8_t buffer2[sizeof(buffer1)];
  48         pb_istream_t stream = pb_istream_from_buffer(buffer1, sizeof(buffer1));
  49
  50         COMMENT("Test pb_read and pb_istream_t");
  51         TEST(pb_read(&stream, buffer2, 6))
  52         TEST(memcmp(buffer2, "foobar", 6) == 0)
  53         TEST(stream.bytes_left == sizeof(buffer1) - 6)
  54         TEST(pb_read(&stream, buffer2 + 6, stream.bytes_left))
  55         TEST(memcmp(buffer1, buffer2, sizeof(buffer1)) == 0)
  56         TEST(stream.bytes_left == 0)
  57         TEST(!pb_read(&stream, buffer2, 1))
  58     }
  59
  60     {
  61         uint8_t buffer[20];
  62         pb_istream_t stream = {&stream_callback, NULL, 20};
  63
  64         COMMENT("Test pb_read with custom callback");
  65         TEST(pb_read(&stream, buffer, 5))
  66         TEST(memcmp(buffer, "xxxxx", 5) == 0)
  67         TEST(!pb_read(&stream, buffer, 50))
  68         stream.state = (void*)1; /* Simulated error return from callback */
  69         TEST(!pb_read(&stream, buffer, 5))
  70         stream.state = NULL;
  71         TEST(pb_read(&stream, buffer, 15))
  72     }
  73
  74     {
  75         pb_istream_t s;
  76         uint64_t u;
  77         int64_t i;
  78
  79         COMMENT("Test pb_decode_varint");
  80         TEST((s = S("\x00"), pb_decode_varint(&s, &u) && u == 0));
  81         TEST((s = S("\x01"), pb_decode_varint(&s, &u) && u == 1));
  82         TEST((s = S("\xAC\x02"), pb_decode_varint(&s, &u) && u == 300));
  83         TEST((s = S("\xFF\xFF\xFF\xFF\x0F"), pb_decode_varint(&s, &u) && u == UINT32_MAX));
  84         TEST((s = S("\xFF\xFF\xFF\xFF\x0F"), pb_decode_varint(&s, (uint64_t*)&i) && i == UINT32_MAX));
  85         TEST((s = S("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"),
  86               pb_decode_varint(&s, (uint64_t*)&i) && i == -1));
  87         TEST((s = S("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"),
  88               pb_decode_varint(&s, &u) && u == UINT64_MAX));
  89     }
  90
  91     {
  92         pb_istream_t s;
  93         COMMENT("Test pb_skip_varint");
  94         TEST((s = S("\x00""foobar"), pb_skip_varint(&s) && s.bytes_left == 6))
  95         TEST((s = S("\xAC\x02""foobar"), pb_skip_varint(&s) && s.bytes_left == 6))
  96         TEST((s = S("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01""foobar"),
  97               pb_skip_varint(&s) && s.bytes_left == 6))
  98         TEST((s = S("\xFF"), !pb_skip_varint(&s)))
  99     }
 100
 101     {
 102         pb_istream_t s;
 103         COMMENT("Test pb_skip_string")
 104         TEST((s = S("\x00""foobar"), pb_skip_string(&s) && s.bytes_left == 6))
 105         TEST((s = S("\x04""testfoobar"), pb_skip_string(&s) && s.bytes_left == 6))
 106         TEST((s = S("\x04"), !pb_skip_string(&s)))
 107         TEST((s = S("\xFF"), !pb_skip_string(&s)))
 108     }
 109
 110     {
 111         pb_istream_t s = S("\x01\xFF\xFF\x03");
 112         pb_field_t f = {1, PB_LTYPE_VARINT, 0, 0, 4, 0, 0};
 113         uint32_t d;
 114         COMMENT("Test pb_dec_varint using uint32_t")
 115         TEST(pb_dec_varint(&s, &f, &d) && d == 1)
 116
 117         /* Verify that no more than data_size is written. */
 118         d = 0;
 119         f.data_size = 1;
 120         TEST(pb_dec_varint(&s, &f, &d) && (d == 0xFF || d == 0xFF000000))
 121     }
 122
 123     {
 124         pb_istream_t s;
 125         pb_field_t f = {1, PB_LTYPE_SVARINT, 0, 0, 4, 0, 0};
 126         int32_t d;
 127
 128         COMMENT("Test pb_dec_svarint using int32_t")
 129         TEST((s = S("\x01"), pb_dec_svarint(&s, &f, &d) && d == -1))
 130         TEST((s = S("\x02"), pb_dec_svarint(&s, &f, &d) && d == 1))
 131         TEST((s = S("\xfe\xff\xff\xff\x0f"), pb_dec_svarint(&s, &f, &d) && d == INT32_MAX))
 132         TEST((s = S("\xff\xff\xff\xff\x0f"), pb_dec_svarint(&s, &f, &d) && d == INT32_MIN))
 133     }
 134
 135     {
 136         pb_istream_t s;
 137         pb_field_t f = {1, PB_LTYPE_SVARINT, 0, 0, 8, 0, 0};
 138         uint64_t d;
 139
 140         COMMENT("Test pb_dec_svarint using uint64_t")
 141         TEST((s = S("\x01"), pb_dec_svarint(&s, &f, &d) && d == -1))
 142         TEST((s = S("\x02"), pb_dec_svarint(&s, &f, &d) && d == 1))
 143         TEST((s = S("\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"), pb_dec_svarint(&s, &f, &d) && d == INT64_MAX))
 144         TEST((s = S("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"), pb_dec_svarint(&s, &f, &d) && d == INT64_MIN))
 145     }
 146
 147     {
 148         pb_istream_t s;
 149         pb_field_t f = {1, PB_LTYPE_FIXED32, 0, 0, 4, 0, 0};
 150         float d;
 151
 152         COMMENT("Test pb_dec_fixed32 using float (failures here may be caused by imperfect rounding)")
 153         TEST((s = S("\x00\x00\x00\x00"), pb_dec_fixed32(&s, &f, &d) && d == 0.0f))
 154         TEST((s = S("\x00\x00\xc6\x42"), pb_dec_fixed32(&s, &f, &d) && d == 99.0f))
 155         TEST((s = S("\x4e\x61\x3c\xcb"), pb_dec_fixed32(&s, &f, &d) && d == -12345678.0f))
 156         TEST((s = S("\x00"), !pb_dec_fixed32(&s, &f, &d) && d == -12345678.0f))
 157     }
 158
 159     {
 160         pb_istream_t s;
 161         pb_field_t f = {1, PB_LTYPE_FIXED64, 0, 0, 8, 0, 0};
 162         double d;
 163
 164         COMMENT("Test pb_dec_fixed64 using double (failures here may be caused by imperfect rounding)")
 165         TEST((s = S("\x00\x00\x00\x00\x00\x00\x00\x00"), pb_dec_fixed64(&s, &f, &d) && d == 0.0))
 166         TEST((s = S("\x00\x00\x00\x00\x00\xc0\x58\x40"), pb_dec_fixed64(&s, &f, &d) && d == 99.0))
 167         TEST((s = S("\x00\x00\x00\xc0\x29\x8c\x67\xc1"), pb_dec_fixed64(&s, &f, &d) && d == -12345678.0f))
 168     }
 169
 170     {
 171         pb_istream_t s;
 172         struct { size_t size; uint8_t bytes[5]; } d;
 173         pb_field_t f = {1, PB_LTYPE_BYTES, 0, 0, sizeof(d), 0, 0};
 174
 175         COMMENT("Test pb_dec_bytes")
 176         TEST((s = S("\x00"), pb_dec_bytes(&s, &f, &d) && d.size == 0))
 177         TEST((s = S("\x01\xFF"), pb_dec_bytes(&s, &f, &d) && d.size == 1 && d.bytes[0] == 0xFF))
 178         TEST((s = S("\x05xxxxx"), pb_dec_bytes(&s, &f, &d) && d.size == 5))
 179         TEST((s = S("\x05xxxx"), !pb_dec_bytes(&s, &f, &d)))
 180
 181         /* Note: the size limit on bytes-fields is not strictly obeyed, as
 182          * the compiler may add some padding to the struct. Using this padding
 183          * is not a very good thing to do, but it is difficult to avoid when
 184          * we use only a single uint8_t to store the size of the field.
 185          * Therefore this tests against a 10-byte string, while otherwise even
 186          * 6 bytes should error out.
 187          */
 188         TEST((s = S("\x10xxxxxxxxxx"), !pb_dec_bytes(&s, &f, &d)))
 189     }
 190
 191     {
 192         pb_istream_t s;
 193         pb_field_t f = {1, PB_LTYPE_STRING, 0, 0, 5, 0, 0};
 194         char d[5];
 195
 196         COMMENT("Test pb_dec_string")
 197         TEST((s = S("\x00"), pb_dec_string(&s, &f, &d) && d[0] == '\0'))
 198         TEST((s = S("\x04xyzz"), pb_dec_string(&s, &f, &d) && strcmp(d, "xyzz") == 0))
 199         TEST((s = S("\x05xyzzy"), !pb_dec_string(&s, &f, &d)))
 200     }
 201
 202     {
 203         pb_istream_t s;
 204         IntegerArray dest;
 205
 206         COMMENT("Testing pb_decode with repeated int32 field")
 207         TEST((s = S(""), pb_decode(&s, IntegerArray_fields, &dest) && dest.data_count == 0))
 208         TEST((s = S("\x08\x01\x08\x02"), pb_decode(&s, IntegerArray_fields, &dest)
 209              && dest.data_count == 2 && dest.data[0] == 1 && dest.data[1] == 2))
 210         s = S("\x08\x01\x08\x02\x08\x03\x08\x04\x08\x05\x08\x06\x08\x07\x08\x08\x08\x09\x08\x0A");
 211         TEST(pb_decode(&s, IntegerArray_fields, &dest) && dest.data_count == 10 && dest.data[9] == 10)
 212         s = S("\x08\x01\x08\x02\x08\x03\x08\x04\x08\x05\x08\x06\x08\x07\x08\x08\x08\x09\x08\x0A\x08\x0B");
 213         TEST(!pb_decode(&s, IntegerArray_fields, &dest))
 214     }
 215
 216     {
 217         pb_istream_t s;
 218         IntegerArray dest;
 219
 220         COMMENT("Testing pb_decode with packed int32 field")
 221         TEST((s = S("\x0A\x00"), pb_decode(&s, IntegerArray_fields, &dest)
 222             && dest.data_count == 0))
 223         TEST((s = S("\x0A\x01\x01"), pb_decode(&s, IntegerArray_fields, &dest)
 224             && dest.data_count == 1 && dest.data[0] == 1))
 225         TEST((s = S("\x0A\x0A\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A"), pb_decode(&s, IntegerArray_fields, &dest)
 226             && dest.data_count == 10 && dest.data[0] == 1 && dest.data[9] == 10))
 227         TEST((s = S("\x0A\x0B\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B"), !pb_decode(&s, IntegerArray_fields, &dest)))
 228
 229         /* Test invalid wire data */
 230         TEST((s = S("\x0A\xFF"), !pb_decode(&s, IntegerArray_fields, &dest)))
 231         TEST((s = S("\x0A\x01"), !pb_decode(&s, IntegerArray_fields, &dest)))
 232     }
 233
 234     {
 235         pb_istream_t s;
 236         IntegerArray dest;
 237
 238         COMMENT("Testing pb_decode with unknown fields")
 239         TEST((s = S("\x18\x0F\x08\x01"), pb_decode(&s, IntegerArray_fields, &dest)
 240             && dest.data_count == 1 && dest.data[0] == 1))
 241         TEST((s = S("\x19\x00\x00\x00\x00\x00\x00\x00\x00\x08\x01"), pb_decode(&s, IntegerArray_fields, &dest)
 242             && dest.data_count == 1 && dest.data[0] == 1))
 243         TEST((s = S("\x1A\x00\x08\x01"), pb_decode(&s, IntegerArray_fields, &dest)
 244             && dest.data_count == 1 && dest.data[0] == 1))
 245         TEST((s = S("\x1B\x08\x01"), !pb_decode(&s, IntegerArray_fields, &dest)))
 246         TEST((s = S("\x1D\x00\x00\x00\x00\x08\x01"), pb_decode(&s, IntegerArray_fields, &dest)
 247             && dest.data_count == 1 && dest.data[0] == 1))
 248     }
 249
 250     {
 251         pb_istream_t s;
 252         CallbackArray dest;
 253         struct { size_t size; uint8_t bytes[10]; } ref;
 254         dest.data.funcs.decode = &callback_check;
 255         dest.data.arg = &ref;
 256
 257         COMMENT("Testing pb_decode with callbacks")
 258         /* Single varint */
 259         ref.size = 1; ref.bytes[0] = 0x55;
 260         TEST((s = S("\x08\x55"), pb_decode(&s, CallbackArray_fields, &dest)))
 261         /* Packed varint */
 262         ref.size = 3; ref.bytes[0] = ref.bytes[1] = ref.bytes[2] = 0x55;
 263         TEST((s = S("\x0A\x03\x55\x55\x55"), pb_decode(&s, CallbackArray_fields, &dest)))
 264         /* Packed varint with loop */
 265         ref.size = 1; ref.bytes[0] = 0x55;
 266         TEST((s = S("\x0A\x03\x55\x55\x55"), pb_decode(&s, CallbackArray_fields, &dest)))
 267         /* Single fixed32 */
 268         ref.size = 4; ref.bytes[0] = ref.bytes[1] = ref.bytes[2] = ref.bytes[3] = 0xAA;
 269         TEST((s = S("\x0D\xAA\xAA\xAA\xAA"), pb_decode(&s, CallbackArray_fields, &dest)))
 270         /* Single fixed64 */
 271         ref.size = 8; memset(ref.bytes, 0xAA, 8);
 272         TEST((s = S("\x09\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"), pb_decode(&s, CallbackArray_fields, &dest)))
 273         /* Unsupported field type */
 274         TEST((s = S("\x0B\x00"), !pb_decode(&s, CallbackArray_fields, &dest)))
 275
 276         /* Just make sure that our test function works */
 277         ref.size = 1; ref.bytes[0] = 0x56;
 278         TEST((s = S("\x08\x55"), !pb_decode(&s, CallbackArray_fields, &dest)))
 279     }
 280
 281     {
 282         pb_istream_t s;
 283         IntegerArray dest;
 284
 285         COMMENT("Testing pb_decode message termination")
 286         TEST((s = S(""), pb_decode(&s, IntegerArray_fields, &dest)))
 287         TEST((s = S("\x00"), pb_decode(&s, IntegerArray_fields, &dest)))
 288         TEST((s = S("\x08\x01"), pb_decode(&s, IntegerArray_fields, &dest)))
 289         TEST((s = S("\x08\x01\x00"), pb_decode(&s, IntegerArray_fields, &dest)))
 290         TEST((s = S("\x08"), !pb_decode(&s, IntegerArray_fields, &dest)))
 291     }
 292
 293     {
 294         pb_istream_t s;
 295         IntegerContainer dest = {{0}};
 296
 297         COMMENT("Testing pb_decode_delimited")
 298         TEST((s = S("\x09\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"),
 299               pb_decode_delimited(&s, IntegerContainer_fields, &dest)) &&
 300               dest.submsg.data_count == 5)
 301     }
 302
 303     {
 304         pb_istream_t s = {0};
 305         void *data = NULL;
 306
 307         COMMENT("Testing allocate_field")
 308         TEST(allocate_field(&s, &data, 10, 10) && data != NULL);
 309         TEST(allocate_field(&s, &data, 10, 20) && data != NULL);
 310
 311         {
 312             void *oldvalue = data;
 313             size_t very_big = (size_t)-1;
 314             size_t somewhat_big = very_big / 2 + 1;
 315             size_t not_so_big = (size_t)1 << (4 * sizeof(size_t));
 316
 317             TEST(!allocate_field(&s, &data, very_big, 2) && data == oldvalue);
 318             TEST(!allocate_field(&s, &data, somewhat_big, 2) && data == oldvalue);
 319             TEST(!allocate_field(&s, &data, not_so_big, not_so_big) && data == oldvalue);
 320         }
 321
 322         pb_free(data);
 323     }
 324
 325     if (status != 0)
 326         fprintf(stdout, "\n\nSome tests FAILED!\n");
 327
 328     return status;
 329 }