text: /* This includes the whole .c file to get access to static functions. */
  #include "pb_common.c"
  #include "pb_encode.c"
  
  #include <stdio.h>
  #include <string.h>
  #include "unittests.h"
  #include "unittestproto.pb.h"
  
  bool streamcallback(pb_ostream_t *stream, const uint8_t *buf, size_t count)
  {
      /* Allow only 'x' to be written */
      while (count--)
      {
          if (*buf++ != 'x')
              return false;
      }
      return true;
  }
  
  bool fieldcallback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
  {
      int value = 0x55;
      if (!pb_encode_tag_for_field(stream, field))
          return false;
      return pb_encode_varint(stream, value);
  }
  
  bool crazyfieldcallback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
  {
      /* This callback writes different amount of data the second time. */
      uint32_t *state = (uint32_t*)arg;
      *state <<= 8;
      if (!pb_encode_tag_for_field(stream, field))
          return false;
      return pb_encode_varint(stream, *state);
  }
  
  /* Check that expression x writes data y.
   * Y is a string, which may contain null bytes. Null terminator is ignored.
   */
  #define WRITES(x, y) \
  memset(buffer, 0xAA, sizeof(buffer)), \
  s = pb_ostream_from_buffer(buffer, sizeof(buffer)), \
  (x) && \
  memcmp(buffer, y, sizeof(y) - 1) == 0 && \
  buffer[sizeof(y) - 1] == 0xAA
  
  int main()
  {
      int status = 0;
      
      {
          uint8_t buffer1[] = "foobartest1234";
          uint8_t buffer2[sizeof(buffer1)];
          pb_ostream_t stream = pb_ostream_from_buffer(buffer2, sizeof(buffer1));
          
          COMMENT("Test pb_write and pb_ostream_t");
          TEST(pb_write(&stream, buffer1, sizeof(buffer1)));
          TEST(memcmp(buffer1, buffer2, sizeof(buffer1)) == 0);
          TEST(!pb_write(&stream, buffer1, 1));
          TEST(stream.bytes_written == sizeof(buffer1));
      }
      
      {
          uint8_t buffer1[] = "xxxxxxx";
          pb_ostream_t stream = {&streamcallback, 0, SIZE_MAX, 0};
          
          COMMENT("Test pb_write with custom callback");
          TEST(pb_write(&stream, buffer1, 5));
          buffer1[0] = 'a';
          TEST(!pb_write(&stream, buffer1, 5));
      }
      
      {
          uint8_t buffer[30];
          pb_ostream_t s;
          
          COMMENT("Test pb_encode_varint")
          TEST(WRITES(pb_encode_varint(&s, 0), "\0"));
          TEST(WRITES(pb_encode_varint(&s, 1), "\1"));
          TEST(WRITES(pb_encode_varint(&s, 0x7F), "\x7F"));
          TEST(WRITES(pb_encode_varint(&s, 0x80), "\x80\x01"));
          TEST(WRITES(pb_encode_varint(&s, UINT32_MAX), "\xFF\xFF\xFF\xFF\x0F"));
          TEST(WRITES(pb_encode_varint(&s, UINT64_MAX), "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
      }
      
      {
          uint8_t buffer[50];
          pb_ostream_t s;
          
          COMMENT("Test pb_encode_varint 32-bit fast path")
          TEST(WRITES(pb_encode_varint(&s, 0x00000000), "\x00"));
          TEST(WRITES(pb_encode_varint(&s, 0x00000001), "\x01"));
          TEST(WRITES(pb_encode_varint(&s, 0x0000007F), "\x7F"));
          TEST(WRITES(pb_encode_varint(&s, 0x00000080), "\x80\x01"));
          TEST(WRITES(pb_encode_varint(&s, 0x00000191), "\x91\x03"));
          TEST(WRITES(pb_encode_varint(&s, 0x00003FFF), "\xFF\x7F"));
          TEST(WRITES(pb_encode_varint(&s, 0x00004000), "\x80\x80\x01"));
          TEST(WRITES(pb_encode_varint(&s, 0x0000D111), "\x91\xA2\x03"));
          TEST(WRITES(pb_encode_varint(&s, 0x001FFFFF), "\xFF\xFF\x7F"));
          TEST(WRITES(pb_encode_varint(&s, 0x00200000), "\x80\x80\x80\x01"));
          TEST(WRITES(pb_encode_varint(&s, 0x00711111), "\x91\xA2\xC4\x03"));
          TEST(WRITES(pb_encode_varint(&s, 0x0FFFFFFF), "\xFF\xFF\xFF\x7F"));
          TEST(WRITES(pb_encode_varint(&s, 0x10000000), "\x80\x80\x80\x80\x01"));
          TEST(WRITES(pb_encode_varint(&s, 0x31111111), "\x91\xA2\xC4\x88\x03"));
          TEST(WRITES(pb_encode_varint(&s, UINT32_MAX), "\xFF\xFF\xFF\xFF\x0F"));
      }
      
      {
          uint8_t buffer[50];
          pb_ostream_t s;
          
          COMMENT("Test pb_encode_svarint 32-bit fast path")
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x00000000), "\x00"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0xFFFFFFFF), "\x01"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x0000003F), "\x7E"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0xFFFFFFC0), "\x7F"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x00000040), "\x80\x01"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x00001FFF), "\xFE\x7F"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0xFFFFE000), "\xFF\x7F"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x00002000), "\x80\x80\x01"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x000FFFFF), "\xFE\xFF\x7F"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0xFFF00000), "\xFF\xFF\x7F"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x00100000), "\x80\x80\x80\x01"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x07FFFFFF), "\xFE\xFF\xFF\x7F"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0xF8000000), "\xFF\xFF\xFF\x7F"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x08000000), "\x80\x80\x80\x80\x01"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x7FFFFFFF), "\xFE\xFF\xFF\xFF\x0F"));
          TEST(WRITES(pb_encode_svarint(&s, (int32_t)0x80000000), "\xFF\xFF\xFF\xFF\x0F"));
      }
      
      {
          uint8_t buffer[30];
          pb_ostream_t s;
          
          COMMENT("Test pb_encode_tag")
          TEST(WRITES(pb_encode_tag(&s, PB_WT_STRING, 5), "\x2A"));
          TEST(WRITES(pb_encode_tag(&s, PB_WT_VARINT, 99), "\x98\x06"));
      }
      
      {
          uint8_t buffer[30];
          pb_ostream_t s;
          pb_field_iter_t field;
          field.tag = 10;
  
          COMMENT("Test pb_encode_tag_for_field")
          field.type = PB_LTYPE_SVARINT;
          TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x50"));
          
          field.type = PB_LTYPE_FIXED64;
          TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x51"));
          
          field.type = PB_LTYPE_STRING;
          TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x52"));
          
          field.type = PB_LTYPE_FIXED32;
          TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x55"));
      }
      
      {
          uint8_t buffer[30];
          pb_ostream_t s;
          
          COMMENT("Test pb_encode_string")
          TEST(WRITES(pb_encode_string(&s, (const uint8_t*)"abcd", 4), "\x04""abcd"));
          TEST(WRITES(pb_encode_string(&s, (const uint8_t*)"abcd\x00", 5), "\x05""abcd\x00"));
          TEST(WRITES(pb_encode_string(&s, (const uint8_t*)"", 0), "\x00"));
      }
      
      {
          uint8_t buffer[30];
          pb_ostream_t s;
          uint8_t value = 1;
          int32_t max = INT32_MAX;
          int32_t min = INT32_MIN;
          int64_t lmax = INT64_MAX;
          int64_t lmin = INT64_MIN;
          pb_field_iter_t field;
  
          COMMENT("Test pb_enc_varint and pb_enc_svarint")
          field.type = PB_LTYPE_VARINT;
          field.data_size = sizeof(value);
          field.pData = &value;
          TEST(WRITES(pb_enc_varint(&s, &field), "\x01"));
          
          field.type = PB_LTYPE_SVARINT;
          field.data_size = sizeof(max);
          field.pData = &max;
          TEST(WRITES(pb_enc_varint(&s, &field), "\xfe\xff\xff\xff\x0f"));
  
          field.type = PB_LTYPE_SVARINT;
          field.data_size = sizeof(min);
          field.pData = &min;
          TEST(WRITES(pb_enc_varint(&s, &field), "\xff\xff\xff\xff\x0f"));
          
          field.type = PB_LTYPE_SVARINT;
          field.data_size = sizeof(lmax);
          field.pData = &lmax;
          TEST(WRITES(pb_enc_varint(&s, &field), "\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
  
          field.type = PB_LTYPE_SVARINT;
          field.data_size = sizeof(lmin);
          field.pData = &lmin;
          TEST(WRITES(pb_enc_varint(&s, &field), "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
      }
      
      {
          uint8_t buffer[30];
          pb_ostream_t s;
          float fvalue;
          double dvalue;
          pb_field_iter_t field;
          
          COMMENT("Test pb_enc_fixed using float")
          field.data_size = sizeof(fvalue);
          field.pData = &fvalue;
          fvalue = 0.0f;
          TEST(WRITES(pb_enc_fixed(&s, &field), "\x00\x00\x00\x00"))
          fvalue = 99.0f;
          TEST(WRITES(pb_enc_fixed(&s, &field), "\x00\x00\xc6\x42"))
          fvalue = -12345678.0f;
          TEST(WRITES(pb_enc_fixed(&s, &field), "\x4e\x61\x3c\xcb"))
      
          COMMENT("Test pb_enc_fixed using double")
          field.data_size = sizeof(dvalue);
          field.pData = &dvalue;
          dvalue = 0.0;
          TEST(WRITES(pb_enc_fixed(&s, &field), "\x00\x00\x00\x00\x00\x00\x00\x00"))
          dvalue = 99.0;
          TEST(WRITES(pb_enc_fixed(&s, &field), "\x00\x00\x00\x00\x00\xc0\x58\x40"))
          dvalue = -12345678.0;
          TEST(WRITES(pb_enc_fixed(&s, &field), "\x00\x00\x00\xc0\x29\x8c\x67\xc1"))
      }
      
      {
          uint8_t buffer[30];
          pb_ostream_t s;
          struct { pb_size_t size; uint8_t bytes[5]; } value = {5, {'x', 'y', 'z', 'z', 'y'}};
          pb_field_iter_t field;
          pb_field_iter_begin(&field, BytesMessage_fields, &value);
  
          COMMENT("Test pb_enc_bytes")
          TEST(WRITES(pb_enc_bytes(&s, &field), "\x05xyzzy"))
          value.size = 0;
          TEST(WRITES(pb_enc_bytes(&s, &field), "\x00"))
      }
      
      {
          uint8_t buffer[30];
          pb_ostream_t s;
          char value[30] = "xyzzy";
          pb_field_iter_t field;
          pb_field_iter_begin(&field, StringMessage_fields, &value);
          
          COMMENT("Test pb_enc_string")
          TEST(WRITES(pb_enc_string(&s, &field), "\x05xyzzy"))
          value[0] = '\0';
          TEST(WRITES(pb_enc_string(&s, &field), "\x00"))
          memset(value, 'x', 10);
          value[10] = '\0';
          TEST(WRITES(pb_enc_string(&s, &field), "\x0Axxxxxxxxxx"))
      }
      
      {
          uint8_t buffer[10];
          pb_ostream_t s;
          IntegerArray msg = {5, {1, 2, 3, 4, 5}};
          
          COMMENT("Test pb_encode with int32 array")
          
          TEST(WRITES(pb_encode(&s, IntegerArray_fields, &msg), "\x0A\x05\x01\x02\x03\x04\x05"))
          
          msg.data_count = 0;
          TEST(WRITES(pb_encode(&s, IntegerArray_fields, &msg), ""))
          
          msg.data_count = 10;
          TEST(!pb_encode(&s, IntegerArray_fields, &msg))
      }
      
      {
          uint8_t buffer[10];
          pb_ostream_t s;
          FloatArray msg = {1, {99.0f}};
          
          COMMENT("Test pb_encode with float array")
          
          TEST(WRITES(pb_encode(&s, FloatArray_fields, &msg),
                      "\x0A\x04\x00\x00\xc6\x42"))
          
          msg.data_count = 0;
          TEST(WRITES(pb_encode(&s, FloatArray_fields, &msg), ""))
          
          msg.data_count = 3;
          TEST(!pb_encode(&s, FloatArray_fields, &msg))
      }
      
      {
          uint8_t buffer[50];
          pb_ostream_t s;
          FloatArray msg = {1, {99.0f}};
          
          COMMENT("Test array size limit in pb_encode")
          
          s = pb_ostream_from_buffer(buffer, sizeof(buffer));
          TEST((msg.data_count = 10) && pb_encode(&s, FloatArray_fields, &msg))
          
          s = pb_ostream_from_buffer(buffer, sizeof(buffer));
          TEST((msg.data_count = 11) && !pb_encode(&s, FloatArray_fields, &msg))
      }
      
      {
          uint8_t buffer[10];
          pb_ostream_t s;
          CallbackArray msg;
          
          msg.data.funcs.encode = &fieldcallback;
          
          COMMENT("Test pb_encode with callback field.")
          TEST(WRITES(pb_encode(&s, CallbackArray_fields, &msg), "\x08\x55"))
      }
      
      {
          uint8_t buffer[10];
          pb_ostream_t s;
          IntegerContainer msg = {{5, {1,2,3,4,5}}};
          
          COMMENT("Test pb_encode with packed array in a submessage.")
          TEST(WRITES(pb_encode(&s, IntegerContainer_fields, &msg),
                      "\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
      }
      
      {
          uint8_t buffer[32];
          pb_ostream_t s;
          BytesMessage msg = {{3, "xyz"}};
          
          COMMENT("Test pb_encode with bytes message.")
          TEST(WRITES(pb_encode(&s, BytesMessage_fields, &msg),
                      "\x0A\x03xyz"))
          
          msg.data.size = 17; /* More than maximum */
          TEST(!pb_encode(&s, BytesMessage_fields, &msg))
      }
          
      
      {
          uint8_t buffer[20];
          pb_ostream_t s;
          IntegerContainer msg = {{5, {1,2,3,4,5}}};
          
          COMMENT("Test pb_encode_delimited.")
          TEST(WRITES(pb_encode_delimited(&s, IntegerContainer_fields, &msg),
                      "\x09\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
      }
  
      {
          IntegerContainer msg = {{5, {1,2,3,4,5}}};
          size_t size;
          
          COMMENT("Test pb_get_encoded_size.")
          TEST(pb_get_encoded_size(&size, IntegerContainer_fields, &msg) &&
               size == 9);
      }
      
      {
          uint8_t buffer[10];
          pb_ostream_t s;
          CallbackContainer msg;
          CallbackContainerContainer msg2;
          uint32_t state = 1;
          
          msg.submsg.data.funcs.encode = &fieldcallback;
          msg2.submsg.submsg.data.funcs.encode = &fieldcallback;
          
          COMMENT("Test pb_encode with callback field in a submessage.")
          TEST(WRITES(pb_encode(&s, CallbackContainer_fields, &msg), "\x0A\x02\x08\x55"))
          TEST(WRITES(pb_encode(&s, CallbackContainerContainer_fields, &msg2),
                      "\x0A\x04\x0A\x02\x08\x55"))
          
          /* Misbehaving callback: varying output between calls */
          msg.submsg.data.funcs.encode = &crazyfieldcallback;
          msg.submsg.data.arg = &state;
          msg2.submsg.submsg.data.funcs.encode = &crazyfieldcallback;
          msg2.submsg.submsg.data.arg = &state;
          
          TEST(!pb_encode(&s, CallbackContainer_fields, &msg))
          state = 1;
          TEST(!pb_encode(&s, CallbackContainerContainer_fields, &msg2))
      }
      
      {
          uint8_t buffer[StringMessage_size];
          pb_ostream_t s;
          StringMessage msg = {"0123456789"};
          
          s = pb_ostream_from_buffer(buffer, sizeof(buffer));
          
          COMMENT("Test that StringMessage_size is correct")
  
          TEST(pb_encode(&s, StringMessage_fields, &msg));
          TEST(s.bytes_written == StringMessage_size);
      }
      
      {
          uint8_t buffer[128];
          pb_ostream_t s;
          StringPointerContainer msg = StringPointerContainer_init_zero;
          char *strs[1] = {NULL};
          char zstr[] = "Z";
          
          COMMENT("Test string pointer encoding.");
          
          msg.rep_str = strs;
          msg.rep_str_count = 1;
          TEST(WRITES(pb_encode(&s, StringPointerContainer_fields, &msg), "\x0a\x00"))
          
          strs[0] = zstr;
          TEST(WRITES(pb_encode(&s, StringPointerContainer_fields, &msg), "\x0a\x01Z"))
      }
      
      if (status != 0)
          fprintf(stdout, "\n\nSome tests FAILED!\n");
      
      return status;
  }
  