Line data    Source code

       1             : /* Decoding testcase for callback fields.
       2             :  * Run e.g. ./test_encode_callbacks | ./test_decode_callbacks
       3             :  */
       4             : 
       5             : #include <stdio.h>
       6             : #include <pb_decode.h>
       7             : #include "callbacks.pb.h"
       8             : #include "test_helpers.h"
       9             : 
      10           6 : bool print_string(pb_istream_t *stream, const pb_field_t *field, void **arg)
      11             : {
      12           6 :     uint8_t buffer[1024] = {0};
      13             :     
      14             :     /* We could read block-by-block to avoid the large buffer... */
      15           6 :     if (stream->bytes_left > sizeof(buffer) - 1)
      16           0 :         return false;
      17             :     
      18           6 :     if (!pb_read(stream, buffer, stream->bytes_left))
      19           0 :         return false;
      20             :     
      21             :     /* Print the string, in format comparable with protoc --decode.
      22             :      * Format comes from the arg defined in main().
      23             :      */
      24           6 :     printf((char*)*arg, buffer);
      25           6 :     return true;
      26             : }
      27             : 
      28           2 : bool print_int32(pb_istream_t *stream, const pb_field_t *field, void **arg)
      29             : {
      30             :     uint64_t value;
      31           2 :     if (!pb_decode_varint(stream, &value))
      32           0 :         return false;
      33             :     
      34           2 :     printf((char*)*arg, (long)value);
      35           2 :     return true;
      36             : }
      37             : 
      38           2 : bool print_fixed32(pb_istream_t *stream, const pb_field_t *field, void **arg)
      39             : {
      40             :     uint32_t value;
      41           2 :     if (!pb_decode_fixed32(stream, &value))
      42           0 :         return false;
      43             :     
      44           2 :     printf((char*)*arg, (long)value);
      45           2 :     return true;
      46             : }
      47             : 
      48           2 : bool print_fixed64(pb_istream_t *stream, const pb_field_t *field, void **arg)
      49             : {
      50             :     uint64_t value;
      51           2 :     if (!pb_decode_fixed64(stream, &value))
      52           0 :         return false;
      53             :     
      54           2 :     printf((char*)*arg, (long)value);
      55           2 :     return true;
      56             : }
      57             : 
      58           1 : int main()
      59             : {
      60             :     uint8_t buffer[1024];
      61             :     size_t length;
      62             :     pb_istream_t stream;
      63             :     /* Note: empty initializer list initializes the struct with all-0.
      64             :      * This is recommended so that unused callbacks are set to NULL instead
      65             :      * of crashing at runtime.
      66             :      */
      67           1 :     TestMessage testmessage = {{{NULL}}};
      68             :     
      69             :     SET_BINARY_MODE(stdin);
      70           1 :     length = fread(buffer, 1, 1024, stdin);
      71           1 :     stream = pb_istream_from_buffer(buffer, length);    
      72             :     
      73           1 :     testmessage.submsg.stringvalue.funcs.decode = &print_string;
      74           1 :     testmessage.submsg.stringvalue.arg = "submsg {\n  stringvalue: \"%s\"\n";
      75           1 :     testmessage.submsg.int32value.funcs.decode = &print_int32;
      76           1 :     testmessage.submsg.int32value.arg = "  int32value: %ld\n";
      77           1 :     testmessage.submsg.fixed32value.funcs.decode = &print_fixed32;
      78           1 :     testmessage.submsg.fixed32value.arg = "  fixed32value: %ld\n";
      79           1 :     testmessage.submsg.fixed64value.funcs.decode = &print_fixed64;
      80           1 :     testmessage.submsg.fixed64value.arg = "  fixed64value: %ld\n}\n";
      81             :     
      82           1 :     testmessage.stringvalue.funcs.decode = &print_string;
      83           1 :     testmessage.stringvalue.arg = "stringvalue: \"%s\"\n";
      84           1 :     testmessage.int32value.funcs.decode = &print_int32;
      85           1 :     testmessage.int32value.arg = "int32value: %ld\n";
      86           1 :     testmessage.fixed32value.funcs.decode = &print_fixed32;
      87           1 :     testmessage.fixed32value.arg = "fixed32value: %ld\n";
      88           1 :     testmessage.fixed64value.funcs.decode = &print_fixed64;
      89           1 :     testmessage.fixed64value.arg = "fixed64value: %ld\n";
      90           1 :     testmessage.repeatedstring.funcs.decode = &print_string;
      91           1 :     testmessage.repeatedstring.arg = "repeatedstring: \"%s\"\n";
      92             :     
      93           1 :     if (!pb_decode(&stream, TestMessage_fields, &testmessage))
      94           0 :         return 1;
      95             :     
      96           1 :     return 0;
      97             : }