libs/nanopb/tests/alltypes_pointer/encode_alltypes_pointer.c

   1 /* Attempts to test all the datatypes supported by ProtoBuf.
   2  */
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <pb_encode.h>
   8 #include "alltypes.pb.h"
   9 #include "test_helpers.h"
  10
  11 int main(int argc, char **argv)
  12 {
  13     int mode = (argc > 1) ? atoi(argv[1]) : 0;
  14
  15     /* Values for required fields */
  16     int32_t     req_int32         = -1001;
  17     int64_t     req_int64         = -1002;
  18     uint32_t    req_uint32        = 1003;
  19     uint64_t    req_uint64        = 1004;
  20     int32_t     req_sint32        = -1005;
  21     int64_t     req_sint64        = -1006;
  22     bool        req_bool          = true;
  23     uint32_t    req_fixed32       = 1008;
  24     int32_t     req_sfixed32      = -1009;
  25     float       req_float         = 1010.0f;
  26     uint64_t    req_fixed64       = 1011;
  27     int64_t     req_sfixed64      = -1012;
  28     double      req_double        = 1013.0;
  29     char*       req_string        = "1014";
  30     PB_BYTES_ARRAY_T(4) req_bytes = {4, {'1', '0', '1', '5'}};
  31     static int32_t req_substuff   = 1016;
  32     SubMessage  req_submsg        = {"1016", &req_substuff};
  33     MyEnum      req_enum          = MyEnum_Truth;
  34     EmptyMessage req_emptymsg     = {0};
  35     pb_byte_t   req_fbytes[4]     = {'1', '0', '1', '9'};
  36
  37     int32_t     end               = 1099;
  38
  39     /* Values for repeated fields */
  40     int32_t     rep_int32[5]      = {0, 0, 0, 0, -2001};
  41     int64_t     rep_int64[5]      = {0, 0, 0, 0, -2002};
  42     uint32_t    rep_uint32[5]     = {0, 0, 0, 0, 2003};
  43     uint64_t    rep_uint64[5]     = {0, 0, 0, 0, 2004};
  44     int32_t     rep_sint32[5]     = {0, 0, 0, 0, -2005};
  45     int64_t     rep_sint64[5]     = {0, 0, 0, 0, -2006};
  46     bool        rep_bool[5]       = {false, false, false, false, true};
  47     uint32_t    rep_fixed32[5]    = {0, 0, 0, 0, 2008};
  48     int32_t     rep_sfixed32[5]   = {0, 0, 0, 0, -2009};
  49     float       rep_float[5]      = {0, 0, 0, 0, 2010.0f};
  50     uint64_t    rep_fixed64[5]    = {0, 0, 0, 0, 2011};
  51     int64_t     rep_sfixed64[5]   = {0, 0, 0, 0, -2012};
  52     double      rep_double[5]     = {0, 0, 0, 0, 2013.0f};
  53     char*       rep_string[5]     = {"", "", "", "", "2014"};
  54     static PB_BYTES_ARRAY_T(4) rep_bytes_4 = {4, {'2', '0', '1', '5'}};
  55     pb_bytes_array_t *rep_bytes[5]= {NULL, NULL, NULL, NULL, (pb_bytes_array_t*)&rep_bytes_4};
  56     static int32_t rep_sub2zero   = 0;
  57     static int32_t rep_substuff2  = 2016;
  58     static uint32_t rep_substuff3 = 2016;
  59     SubMessage  rep_submsg[5]     = {{"", &rep_sub2zero},
  60                                      {"", &rep_sub2zero},
  61                                      {"", &rep_sub2zero},
  62                                      {"", &rep_sub2zero},
  63                                      {"2016", &rep_substuff2, &rep_substuff3}};
  64     MyEnum      rep_enum[5]       = {0, 0, 0, 0, MyEnum_Truth};
  65     EmptyMessage rep_emptymsg[5]  = {{0}, {0}, {0}, {0}, {0}};
  66     pb_byte_t   rep_fbytes[5][4]  = {{0}, {0}, {0}, {0}, {'2', '0', '1', '9'}};
  67
  68     /* Values for optional fields */
  69     int32_t     opt_int32         = 3041;
  70     int64_t     opt_int64         = 3042;
  71     uint32_t    opt_uint32        = 3043;
  72     uint64_t    opt_uint64        = 3044;
  73     int32_t     opt_sint32        = 3045;
  74     int64_t     opt_sint64        = 3046;
  75     bool        opt_bool          = true;
  76     uint32_t    opt_fixed32       = 3048;
  77     int32_t     opt_sfixed32      = 3049;
  78     float       opt_float         = 3050.0f;
  79     uint64_t    opt_fixed64       = 3051;
  80     int64_t     opt_sfixed64      = 3052;
  81     double      opt_double        = 3053.0;
  82     char*       opt_string        = "3054";
  83     PB_BYTES_ARRAY_T(4) opt_bytes = {4, {'3', '0', '5', '5'}};
  84     static int32_t opt_substuff   = 3056;
  85     SubMessage  opt_submsg        = {"3056", &opt_substuff};
  86     MyEnum      opt_enum          = MyEnum_Truth;
  87     EmptyMessage opt_emptymsg     = {0};
  88     pb_byte_t   opt_fbytes[4]     = {'3', '0', '5', '9'};
  89
  90     static int32_t oneof_substuff = 4059;
  91     SubMessage  oneof_msg1        = {"4059", &oneof_substuff};
  92
  93     /* Values for the Limits message. */
  94     static int32_t  int32_min  = INT32_MIN;
  95     static int32_t  int32_max  = INT32_MAX;
  96     static uint32_t uint32_min = 0;
  97     static uint32_t uint32_max = UINT32_MAX;
  98     static int64_t  int64_min  = INT64_MIN;
  99     static int64_t  int64_max  = INT64_MAX;
 100     static uint64_t uint64_min = 0;
 101     static uint64_t uint64_max = UINT64_MAX;
 102     static HugeEnum enum_min   = HugeEnum_Negative;
 103     static HugeEnum enum_max   = HugeEnum_Positive;
 104     Limits req_limits = {&int32_min,    &int32_max,
 105                          &uint32_min,   &uint32_max,
 106                          &int64_min,    &int64_max,
 107                          &uint64_min,   &uint64_max,
 108                          &enum_min,     &enum_max};
 109
 110     /* Initialize the message struct with pointers to the fields. */
 111     AllTypes alltypes = {0};
 112
 113     alltypes.req_int32         = &req_int32;
 114     alltypes.req_int64         = &req_int64;
 115     alltypes.req_uint32        = &req_uint32;
 116     alltypes.req_uint64        = &req_uint64;
 117     alltypes.req_sint32        = &req_sint32;
 118     alltypes.req_sint64        = &req_sint64;
 119     alltypes.req_bool          = &req_bool;
 120     alltypes.req_fixed32       = &req_fixed32;
 121     alltypes.req_sfixed32      = &req_sfixed32;
 122     alltypes.req_float         = &req_float;
 123     alltypes.req_fixed64       = &req_fixed64;
 124     alltypes.req_sfixed64      = &req_sfixed64;
 125     alltypes.req_double        = &req_double;
 126     alltypes.req_string        = req_string;
 127     alltypes.req_bytes         = (pb_bytes_array_t*)&req_bytes;
 128     alltypes.req_submsg        = &req_submsg;
 129     alltypes.req_enum          = &req_enum;
 130     alltypes.req_emptymsg      = &req_emptymsg;
 131     alltypes.req_fbytes        = &req_fbytes;
 132     alltypes.req_limits        = &req_limits;
 133
 134     alltypes.rep_int32_count    = 5; alltypes.rep_int32     = rep_int32;
 135     alltypes.rep_int64_count    = 5; alltypes.rep_int64     = rep_int64;
 136     alltypes.rep_uint32_count   = 5; alltypes.rep_uint32    = rep_uint32;
 137     alltypes.rep_uint64_count   = 5; alltypes.rep_uint64    = rep_uint64;
 138     alltypes.rep_sint32_count   = 5; alltypes.rep_sint32    = rep_sint32;
 139     alltypes.rep_sint64_count   = 5; alltypes.rep_sint64    = rep_sint64;
 140     alltypes.rep_bool_count     = 5; alltypes.rep_bool      = rep_bool;
 141     alltypes.rep_fixed32_count  = 5; alltypes.rep_fixed32   = rep_fixed32;
 142     alltypes.rep_sfixed32_count = 5; alltypes.rep_sfixed32  = rep_sfixed32;
 143     alltypes.rep_float_count    = 5; alltypes.rep_float     = rep_float;
 144     alltypes.rep_fixed64_count  = 5; alltypes.rep_fixed64   = rep_fixed64;
 145     alltypes.rep_sfixed64_count = 5; alltypes.rep_sfixed64  = rep_sfixed64;
 146     alltypes.rep_double_count   = 5; alltypes.rep_double    = rep_double;
 147     alltypes.rep_string_count   = 5; alltypes.rep_string    = rep_string;
 148     alltypes.rep_bytes_count    = 5; alltypes.rep_bytes     = rep_bytes;
 149     alltypes.rep_submsg_count   = 5; alltypes.rep_submsg    = rep_submsg;
 150     alltypes.rep_enum_count     = 5; alltypes.rep_enum      = rep_enum;
 151     alltypes.rep_emptymsg_count = 5; alltypes.rep_emptymsg  = rep_emptymsg;
 152     alltypes.rep_fbytes_count   = 5; alltypes.rep_fbytes    = rep_fbytes;
 153
 154     if (mode != 0)
 155     {
 156         /* Fill in values for optional fields */
 157         alltypes.opt_int32         = &opt_int32;
 158         alltypes.opt_int64         = &opt_int64;
 159         alltypes.opt_uint32        = &opt_uint32;
 160         alltypes.opt_uint64        = &opt_uint64;
 161         alltypes.opt_sint32        = &opt_sint32;
 162         alltypes.opt_sint64        = &opt_sint64;
 163         alltypes.opt_bool          = &opt_bool;
 164         alltypes.opt_fixed32       = &opt_fixed32;
 165         alltypes.opt_sfixed32      = &opt_sfixed32;
 166         alltypes.opt_float         = &opt_float;
 167         alltypes.opt_fixed64       = &opt_fixed64;
 168         alltypes.opt_sfixed64      = &opt_sfixed64;
 169         alltypes.opt_double        = &opt_double;
 170         alltypes.opt_string        = opt_string;
 171         alltypes.opt_bytes         = (pb_bytes_array_t*)&opt_bytes;
 172         alltypes.opt_submsg        = &opt_submsg;
 173         alltypes.opt_enum          = &opt_enum;
 174         alltypes.opt_emptymsg      = &opt_emptymsg;
 175         alltypes.opt_fbytes        = &opt_fbytes;
 176
 177         alltypes.which_oneof = AllTypes_oneof_msg1_tag;
 178         alltypes.oneof.oneof_msg1 = &oneof_msg1;
 179     }
 180
 181     alltypes.end = &end;
 182
 183     {
 184         uint8_t buffer[4096];
 185         pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
 186
 187         /* Now encode it and check if we succeeded. */
 188         if (pb_encode(&stream, AllTypes_fields, &alltypes))
 189         {
 190             SET_BINARY_MODE(stdout);
 191             fwrite(buffer, 1, stream.bytes_written, stdout);
 192             return 0; /* Success */
 193         }
 194         else
 195         {
 196             fprintf(stderr, "Encoding failed: %s\n", PB_GET_ERROR(&stream));
 197             return 1; /* Failure */
 198         }
 199     }
 200 }