Line data    Source code

       1             : /* Tests the decoding of all types.
       2             :  * This is a backwards-compatibility test, using alltypes_legacy.h.
       3             :  * It is similar to decode_alltypes, but duplicated in order to allow
       4             :  * decode_alltypes to test any new features introduced later.
       5             :  *
       6             :  * Run e.g. ./encode_legacy | ./decode_legacy
       7             :  */
       8             : 
       9             : #include <stdio.h>
      10             : #include <string.h>
      11             : #include <stdlib.h>
      12             : #include <pb_decode.h>
      13             : #include "alltypes_legacy.h"
      14             : #include "test_helpers.h"
      15             : #include "unittests.h"
      16             : 
      17             : /* This function is called once from main(), it handles
      18             :    the decoding and checks the fields. */
      19           2 : bool check_alltypes(pb_istream_t *stream, int mode)
      20             : {
      21           2 :     AllTypes alltypes = {0};
      22           2 :     int status = 0;
      23             :     
      24           2 :     if (!pb_decode(stream, AllTypes_fields, &alltypes))
      25           0 :         return false;
      26             :     
      27           2 :     TEST(alltypes.req_int32         == -1001);
      28           2 :     TEST(alltypes.req_int64         == -1002);
      29           2 :     TEST(alltypes.req_uint32        == 1003);
      30           2 :     TEST(alltypes.req_uint64        == 1004);
      31           2 :     TEST(alltypes.req_sint32        == -1005);
      32           2 :     TEST(alltypes.req_sint64        == -1006);
      33           2 :     TEST(alltypes.req_bool          == true);
      34             :     
      35           2 :     TEST(alltypes.req_fixed32       == 1008);
      36           2 :     TEST(alltypes.req_sfixed32      == -1009);
      37           2 :     TEST(alltypes.req_float         == 1010.0f);
      38             :     
      39           2 :     TEST(alltypes.req_fixed64       == 1011);
      40           2 :     TEST(alltypes.req_sfixed64      == -1012);
      41           2 :     TEST(alltypes.req_double        == 1013.0f);
      42             :     
      43           2 :     TEST(strcmp(alltypes.req_string, "1014") == 0);
      44           2 :     TEST(alltypes.req_bytes.size == 4);
      45           2 :     TEST(memcmp(alltypes.req_bytes.bytes, "1015", 4) == 0);
      46           2 :     TEST(strcmp(alltypes.req_submsg.substuff1, "1016") == 0);
      47           2 :     TEST(alltypes.req_submsg.substuff2 == 1016);
      48           2 :     TEST(alltypes.req_submsg.substuff3 == 3);
      49           2 :     TEST(alltypes.req_enum == MyEnum_Truth);
      50             :     
      51           2 :     TEST(alltypes.rep_int32_count == 5 && alltypes.rep_int32[4] == -2001 && alltypes.rep_int32[0] == 0);
      52           2 :     TEST(alltypes.rep_int64_count == 5 && alltypes.rep_int64[4] == -2002 && alltypes.rep_int64[0] == 0);
      53           2 :     TEST(alltypes.rep_uint32_count == 5 && alltypes.rep_uint32[4] == 2003 && alltypes.rep_uint32[0] == 0);
      54           2 :     TEST(alltypes.rep_uint64_count == 5 && alltypes.rep_uint64[4] == 2004 && alltypes.rep_uint64[0] == 0);
      55           2 :     TEST(alltypes.rep_sint32_count == 5 && alltypes.rep_sint32[4] == -2005 && alltypes.rep_sint32[0] == 0);
      56           2 :     TEST(alltypes.rep_sint64_count == 5 && alltypes.rep_sint64[4] == -2006 && alltypes.rep_sint64[0] == 0);
      57           2 :     TEST(alltypes.rep_bool_count == 5 && alltypes.rep_bool[4] == true && alltypes.rep_bool[0] == false);
      58             :     
      59           2 :     TEST(alltypes.rep_fixed32_count == 5 && alltypes.rep_fixed32[4] == 2008 && alltypes.rep_fixed32[0] == 0);
      60           2 :     TEST(alltypes.rep_sfixed32_count == 5 && alltypes.rep_sfixed32[4] == -2009 && alltypes.rep_sfixed32[0] == 0);
      61           2 :     TEST(alltypes.rep_float_count == 5 && alltypes.rep_float[4] == 2010.0f && alltypes.rep_float[0] == 0.0f);
      62             :     
      63           2 :     TEST(alltypes.rep_fixed64_count == 5 && alltypes.rep_fixed64[4] == 2011 && alltypes.rep_fixed64[0] == 0);
      64           2 :     TEST(alltypes.rep_sfixed64_count == 5 && alltypes.rep_sfixed64[4] == -2012 && alltypes.rep_sfixed64[0] == 0);
      65           2 :     TEST(alltypes.rep_double_count == 5 && alltypes.rep_double[4] == 2013.0 && alltypes.rep_double[0] == 0.0);
      66             :     
      67           2 :     TEST(alltypes.rep_string_count == 5 && strcmp(alltypes.rep_string[4], "2014") == 0 && alltypes.rep_string[0][0] == '\0');
      68           2 :     TEST(alltypes.rep_bytes_count == 5 && alltypes.rep_bytes[4].size == 4 && alltypes.rep_bytes[0].size == 0);
      69           2 :     TEST(memcmp(alltypes.rep_bytes[4].bytes, "2015", 4) == 0);
      70             : 
      71           2 :     TEST(alltypes.rep_submsg_count == 5);
      72           2 :     TEST(strcmp(alltypes.rep_submsg[4].substuff1, "2016") == 0 && alltypes.rep_submsg[0].substuff1[0] == '\0');
      73           2 :     TEST(alltypes.rep_submsg[4].substuff2 == 2016 && alltypes.rep_submsg[0].substuff2 == 0);
      74           2 :     TEST(alltypes.rep_submsg[4].substuff3 == 2016 && alltypes.rep_submsg[0].substuff3 == 3);
      75             :     
      76           2 :     TEST(alltypes.rep_enum_count == 5 && alltypes.rep_enum[4] == MyEnum_Truth && alltypes.rep_enum[0] == MyEnum_Zero);
      77             :     
      78           2 :     if (mode == 0)
      79             :     {
      80             :         /* Expect default values */
      81           2 :         TEST(alltypes.has_opt_int32     == false);
      82           2 :         TEST(alltypes.opt_int32         == 4041);
      83           2 :         TEST(alltypes.has_opt_int64     == false);
      84           2 :         TEST(alltypes.opt_int64         == 4042);
      85           2 :         TEST(alltypes.has_opt_uint32    == false);
      86           2 :         TEST(alltypes.opt_uint32        == 4043);
      87           2 :         TEST(alltypes.has_opt_uint64    == false);
      88           2 :         TEST(alltypes.opt_uint64        == 4044);
      89           2 :         TEST(alltypes.has_opt_sint32    == false);
      90           2 :         TEST(alltypes.opt_sint32        == 4045);
      91           2 :         TEST(alltypes.has_opt_sint64    == false);
      92           2 :         TEST(alltypes.opt_sint64        == 4046);
      93           2 :         TEST(alltypes.has_opt_bool      == false);
      94           2 :         TEST(alltypes.opt_bool          == false);
      95             :         
      96           2 :         TEST(alltypes.has_opt_fixed32   == false);
      97           2 :         TEST(alltypes.opt_fixed32       == 4048);
      98           2 :         TEST(alltypes.has_opt_sfixed32  == false);
      99           2 :         TEST(alltypes.opt_sfixed32      == 4049);
     100           2 :         TEST(alltypes.has_opt_float     == false);
     101           2 :         TEST(alltypes.opt_float         == 4050.0f);
     102             :         
     103           2 :         TEST(alltypes.has_opt_fixed64   == false);
     104           2 :         TEST(alltypes.opt_fixed64       == 4051);
     105           2 :         TEST(alltypes.has_opt_sfixed64  == false);
     106           2 :         TEST(alltypes.opt_sfixed64      == 4052);
     107           2 :         TEST(alltypes.has_opt_double    == false);
     108           2 :         TEST(alltypes.opt_double        == 4053.0);
     109             :         
     110           2 :         TEST(alltypes.has_opt_string    == false);
     111           2 :         TEST(strcmp(alltypes.opt_string, "4054") == 0);
     112           2 :         TEST(alltypes.has_opt_bytes     == false);
     113           2 :         TEST(alltypes.opt_bytes.size == 4);
     114           2 :         TEST(memcmp(alltypes.opt_bytes.bytes, "4055", 4) == 0);
     115           2 :         TEST(alltypes.has_opt_submsg    == false);
     116           2 :         TEST(strcmp(alltypes.opt_submsg.substuff1, "1") == 0);
     117           2 :         TEST(alltypes.opt_submsg.substuff2 == 2);
     118           2 :         TEST(alltypes.opt_submsg.substuff3 == 3);
     119           2 :         TEST(alltypes.has_opt_enum     == false);
     120           2 :         TEST(alltypes.opt_enum == MyEnum_Second);
     121             :     }
     122             :     else
     123             :     {
     124             :         /* Expect filled-in values */
     125           0 :         TEST(alltypes.has_opt_int32     == true);
     126           0 :         TEST(alltypes.opt_int32         == 3041);
     127           0 :         TEST(alltypes.has_opt_int64     == true);
     128           0 :         TEST(alltypes.opt_int64         == 3042);
     129           0 :         TEST(alltypes.has_opt_uint32    == true);
     130           0 :         TEST(alltypes.opt_uint32        == 3043);
     131           0 :         TEST(alltypes.has_opt_uint64    == true);
     132           0 :         TEST(alltypes.opt_uint64        == 3044);
     133           0 :         TEST(alltypes.has_opt_sint32    == true);
     134           0 :         TEST(alltypes.opt_sint32        == 3045);
     135           0 :         TEST(alltypes.has_opt_sint64    == true);
     136           0 :         TEST(alltypes.opt_sint64        == 3046);
     137           0 :         TEST(alltypes.has_opt_bool      == true);
     138           0 :         TEST(alltypes.opt_bool          == true);
     139             :         
     140           0 :         TEST(alltypes.has_opt_fixed32   == true);
     141           0 :         TEST(alltypes.opt_fixed32       == 3048);
     142           0 :         TEST(alltypes.has_opt_sfixed32  == true);
     143           0 :         TEST(alltypes.opt_sfixed32      == 3049);
     144           0 :         TEST(alltypes.has_opt_float     == true);
     145           0 :         TEST(alltypes.opt_float         == 3050.0f);
     146             :         
     147           0 :         TEST(alltypes.has_opt_fixed64   == true);
     148           0 :         TEST(alltypes.opt_fixed64       == 3051);
     149           0 :         TEST(alltypes.has_opt_sfixed64  == true);
     150           0 :         TEST(alltypes.opt_sfixed64      == 3052);
     151           0 :         TEST(alltypes.has_opt_double    == true);
     152           0 :         TEST(alltypes.opt_double        == 3053.0);
     153             :         
     154           0 :         TEST(alltypes.has_opt_string    == true);
     155           0 :         TEST(strcmp(alltypes.opt_string, "3054") == 0);
     156           0 :         TEST(alltypes.has_opt_bytes     == true);
     157           0 :         TEST(alltypes.opt_bytes.size == 4);
     158           0 :         TEST(memcmp(alltypes.opt_bytes.bytes, "3055", 4) == 0);
     159           0 :         TEST(alltypes.has_opt_submsg    == true);
     160           0 :         TEST(strcmp(alltypes.opt_submsg.substuff1, "3056") == 0);
     161           0 :         TEST(alltypes.opt_submsg.substuff2 == 3056);
     162           0 :         TEST(alltypes.opt_submsg.substuff3 == 3);
     163           0 :         TEST(alltypes.has_opt_enum      == true);
     164           0 :         TEST(alltypes.opt_enum == MyEnum_Truth);
     165             :     }
     166             :     
     167           2 :     TEST(alltypes.end == 1099);
     168             :     
     169           2 :     return status == 0;
     170             : }
     171             : 
     172           2 : int main(int argc, char **argv)
     173             : {
     174             :     uint8_t buffer[1024];
     175             :     size_t count;
     176             :     pb_istream_t stream;
     177             : 
     178             :     /* Whether to expect the optional values or the default values. */
     179           2 :     int mode = (argc > 1) ? atoi(argv[1]) : 0;
     180             :     
     181             :     /* Read the data into buffer */
     182             :     SET_BINARY_MODE(stdin);
     183           2 :     count = fread(buffer, 1, sizeof(buffer), stdin);
     184             :     
     185             :     /* Construct a pb_istream_t for reading from the buffer */
     186           2 :     stream = pb_istream_from_buffer(buffer, count);
     187             :     
     188             :     /* Decode and print out the stuff */
     189           2 :     if (!check_alltypes(&stream, mode))
     190             :     {
     191           0 :         printf("Parsing failed: %s\n", PB_GET_ERROR(&stream));
     192           0 :         return 1;
     193             :     } else {
     194           2 :         return 0;
     195             :     }
     196             : }