tests/mem_release/mem_release.c

   1 /* Make sure that all fields are freed in various scenarios. */
   2
   3 #include <pb_decode.h>
   4 #include <pb_encode.h>
   5 #include <malloc_wrappers.h>
   6 #include <stdio.h>
   7 #include <test_helpers.h>
   8 #include "mem_release.pb.h"
   9
  10 #define TEST(x) if (!(x)) { \
  11     fprintf(stderr, "Test " #x " on line %d failed.\n", __LINE__); \
  12     return false; \
  13     }
  14
  15 static char *test_str_arr[] = {"1", "2", ""};
  16 static SubMessage test_msg_arr[] = {SubMessage_init_zero, SubMessage_init_zero};
  17
  18 static bool do_test()
  19 {
  20     uint8_t buffer[256];
  21     size_t msgsize;
  22
  23     /* Construct a message with various fields filled in */
  24     {
  25         TestMessage msg = TestMessage_init_zero;
  26         pb_extension_t ext1, ext2;
  27         pb_ostream_t stream;
  28         msg.static_req_submsg.dynamic_str = "12345";
  29         msg.static_req_submsg.dynamic_str_arr_count = 3;
  30         msg.static_req_submsg.dynamic_str_arr = test_str_arr;
  31         msg.static_req_submsg.dynamic_submsg_count = 2;
  32         msg.static_req_submsg.dynamic_submsg = test_msg_arr;
  33         msg.static_req_submsg.dynamic_submsg[1].dynamic_str = "abc";
  34         msg.static_opt_submsg.dynamic_str = "abc";
  35         msg.has_static_opt_submsg = true;
  36         msg.dynamic_submsg = &msg.static_req_submsg;
  37
  38         msg.extensions = &ext1;
  39         ext1.type = &dynamic_ext;
  40         ext1.dest = &msg.static_req_submsg;
  41         ext1.next = &ext2;
  42         ext2.type = &static_ext;
  43         ext2.dest = &msg.static_req_submsg;
  44         ext2.next = NULL;
  45
  46         stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
  47         if (!pb_encode(&stream, TestMessage_fields, &msg))
  48         {
  49             fprintf(stderr, "Encode failed: %s\n", PB_GET_ERROR(&stream));
  50             return false;
  51         }
  52         msgsize = stream.bytes_written;
  53     }
  54
  55     /* Output encoded message for debug */
  56     SET_BINARY_MODE(stdout);
  57     fwrite(buffer, 1, msgsize, stdout);
  58
  59     /* Decode memory using dynamic allocation */
  60     {
  61         TestMessage msg = TestMessage_init_zero;
  62         pb_istream_t stream;
  63         SubMessage ext2_dest;
  64         pb_extension_t ext1, ext2;
  65
  66         msg.extensions = &ext1;
  67         ext1.type = &dynamic_ext;
  68         ext1.dest = NULL;
  69         ext1.next = &ext2;
  70         ext2.type = &static_ext;
  71         ext2.dest = &ext2_dest;
  72         ext2.next = NULL;
  73
  74         stream = pb_istream_from_buffer(buffer, msgsize);
  75         if (!pb_decode(&stream, TestMessage_fields, &msg))
  76         {
  77             fprintf(stderr, "Decode failed: %s\n", PB_GET_ERROR(&stream));
  78             return false;
  79         }
  80
  81         /* Make sure it encodes back to same data */
  82         {
  83             uint8_t buffer2[256];
  84             pb_ostream_t ostream = pb_ostream_from_buffer(buffer2, sizeof(buffer2));
  85             TEST(pb_encode(&ostream, TestMessage_fields, &msg));
  86             TEST(ostream.bytes_written == msgsize);
  87             TEST(memcmp(buffer, buffer2, msgsize) == 0);
  88         }
  89
  90         /* Make sure that malloc counters work */
  91         TEST(get_alloc_count() > 0);
  92
  93         /* Make sure that pb_release releases everything */
  94         pb_release(TestMessage_fields, &msg);
  95         TEST(get_alloc_count() == 0);
  96
  97         /* Check that double-free is a no-op */
  98         pb_release(TestMessage_fields, &msg);
  99         TEST(get_alloc_count() == 0);
 100     }
 101
 102     return true;
 103 }
 104
 105 int main()
 106 {
 107     if (do_test())
 108         return 0;
 109     else
 110         return 1;
 111 }
 112