rik/nanopb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c2e0b9ed5d9e5913c79f8ac70b8352556ea92837
nanopb/tests/encode_unittests.c
Michael Poole accd93be8d Add an encoder optimized for in-memory buffers. 
git-svn-id: https://svn.kapsi.fi/jpa/nanopb-dev@1088 e3a754e5-d11d-0410-8d38-ebb782a927b9
2012-01-05 22:01:48 +02:00

406 lines
14 KiB
C
Raw Blame History

#include <stdio.h>
#include <string.h>
#include "pb_encode.h"
#include "pb_encode_buffer.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, const void *arg)
{
int value = 0x55;
if (!pb_encode_tag_for_field(stream, field))
return false;
return pb_encode_varint(stream, value);
}
bool fieldcallback_buf(pb_strstream_t *stream, const pb_field_t *field, const void *arg)
{
int value = 0x55;
if (!pb_encbuf_varint(stream, value))
return false;
return pb_encbuf_tag_for_field(stream, field);
}
bool crazyfieldcallback(pb_ostream_t *stream, const pb_field_t *field, const void *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);
}
bool crazyfieldcallback_buf(pb_strstream_t *stream, const pb_field_t *field, const void *arg)
{
/* This callback writes different amount of data the second time. */
uint32_t *state = (uint32_t*)arg;
*state <<= 8;
if (!pb_encbuf_varint(stream, *state))
return false;
return pb_encbuf_tag_for_field(stream, field);
}
/* 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
/* Check that expression x writes data y into s2.
* Y is a string, which may contain null bytes. Null terminator is ignored.
*/
#define WRITES_BUF(x, y) \
memset(buffer, 0xAA, sizeof(buffer)), \
s2 = pb_strstream_from_buffer(buffer, sizeof(buffer)), \
(x) && \
memcmp(s2.last, y, sizeof(y) - 1) == 0 && \
s2.last - buffer == sizeof(buffer) - (sizeof(y) - 1)
/* Check that expression x and y write data z into s and s2, respectively.
*/
#define WRITES_BOTH(x, y, z) (WRITES(x, z)) && (WRITES_BUF(y, z))
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;
pb_strstream_t s2;
COMMENT("Test pb_encode_varint")
TEST(WRITES_BOTH(pb_encode_varint(&s, 0),
pb_encbuf_varint(&s2, 0), "\0"));
TEST(WRITES_BOTH(pb_encode_varint(&s, 1),
pb_encbuf_varint(&s2, 1), "\1"));
TEST(WRITES_BOTH(pb_encode_varint(&s, 0x7F),
pb_encbuf_varint(&s2, 0x7F), "\x7F"));
TEST(WRITES_BOTH(pb_encode_varint(&s, 0x80),
pb_encbuf_varint(&s2, 0x80), "\x80\x01"));
TEST(WRITES_BOTH(pb_encode_varint(&s, UINT32_MAX),
pb_encbuf_varint(&s2, UINT32_MAX),
"\xFF\xFF\xFF\xFF\x0F"));
TEST(WRITES_BOTH(pb_encode_varint(&s, UINT64_MAX),
pb_encbuf_varint(&s2, UINT64_MAX),
"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
}
{
uint8_t buffer[30];
pb_ostream_t s;
pb_strstream_t s2;
COMMENT("Test pb_encode_tag")
TEST(WRITES_BOTH(pb_encode_tag(&s, PB_WT_STRING, 5),
pb_encbuf_tag(&s2, PB_WT_STRING, 5), "\x2A"));
TEST(WRITES_BOTH(pb_encode_tag(&s, PB_WT_VARINT, 99),
pb_encbuf_tag(&s2, PB_WT_VARINT, 99), "\x98\x06"));
}
{
uint8_t buffer[30];
pb_ostream_t s;
pb_strstream_t s2;
pb_field_t field = {10, PB_LTYPE_SVARINT};
COMMENT("Test pb_encode_tag_for_field")
TEST(WRITES_BOTH(pb_encode_tag_for_field(&s, &field),
pb_encbuf_tag_for_field(&s2, &field), "\x50"));
field.type = PB_LTYPE_FIXED64;
TEST(WRITES_BOTH(pb_encode_tag_for_field(&s, &field),
pb_encbuf_tag_for_field(&s2, &field), "\x51"));
field.type = PB_LTYPE_STRING;
TEST(WRITES_BOTH(pb_encode_tag_for_field(&s, &field),
pb_encbuf_tag_for_field(&s2, &field), "\x52"));
field.type = PB_LTYPE_FIXED32;
TEST(WRITES_BOTH(pb_encode_tag_for_field(&s, &field),
pb_encbuf_tag_for_field(&s2, &field), "\x55"));
}
{
uint8_t buffer[30];
pb_ostream_t s;
pb_strstream_t s2;
COMMENT("Test pb_encode_string")
TEST(WRITES_BOTH(pb_encode_string(&s, (const uint8_t*)"abcd", 4),
pb_encbuf_string(&s2, (const uint8_t*)"abcd", 4),
"\x04""abcd"));
TEST(WRITES_BOTH(pb_encode_string(&s, (const uint8_t*)"abcd\x00", 5),
pb_encbuf_string(&s2, (const uint8_t*)"abcd\x00", 5),
"\x05""abcd\x00"));
TEST(WRITES_BOTH(pb_encode_string(&s, (const uint8_t*)"", 0),
pb_encbuf_string(&s2, (const uint8_t*)"", 0), "\x00"));
}
{
uint8_t buffer[30];
pb_ostream_t s;
uint8_t value = 1;
int8_t svalue = -1;
int32_t max = INT32_MAX;
int32_t min = INT32_MIN;
int64_t lmax = INT64_MAX;
int64_t lmin = INT64_MIN;
pb_field_t field = {1, PB_LTYPE_VARINT, 0, 0, sizeof(value)};
COMMENT("Test pb_enc_varint and pb_enc_svarint")
TEST(WRITES(pb_enc_varint(&s, &field, &value), "\x01"));
TEST(WRITES(pb_enc_svarint(&s, &field, &svalue), "\x01"));
TEST(WRITES(pb_enc_svarint(&s, &field, &value), "\x02"));
field.data_size = sizeof(max);
TEST(WRITES(pb_enc_svarint(&s, &field, &max), "\xfe\xff\xff\xff\x0f"));
TEST(WRITES(pb_enc_svarint(&s, &field, &min), "\xff\xff\xff\xff\x0f"));
field.data_size = sizeof(lmax);
TEST(WRITES(pb_enc_svarint(&s, &field, &lmax), "\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
TEST(WRITES(pb_enc_svarint(&s, &field, &lmin), "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
}
{
uint8_t buffer[30];
pb_ostream_t s;
float fvalue;
double dvalue;
COMMENT("Test pb_enc_fixed32 using float")
fvalue = 0.0f;
TEST(WRITES(pb_enc_fixed32(&s, NULL, &fvalue), "\x00\x00\x00\x00"))
fvalue = 99.0f;
TEST(WRITES(pb_enc_fixed32(&s, NULL, &fvalue), "\x00\x00\xc6\x42"))
fvalue = -12345678.0f;
TEST(WRITES(pb_enc_fixed32(&s, NULL, &fvalue), "\x4e\x61\x3c\xcb"))
COMMENT("Test pb_enc_fixed64 using double")
dvalue = 0.0;
TEST(WRITES(pb_enc_fixed64(&s, NULL, &dvalue), "\x00\x00\x00\x00\x00\x00\x00\x00"))
dvalue = 99.0;
TEST(WRITES(pb_enc_fixed64(&s, NULL, &dvalue), "\x00\x00\x00\x00\x00\xc0\x58\x40"))
dvalue = -12345678.0;
TEST(WRITES(pb_enc_fixed64(&s, NULL, &dvalue), "\x00\x00\x00\xc0\x29\x8c\x67\xc1"))
}
{
uint8_t buffer[30];
pb_ostream_t s;
struct { size_t size; uint8_t bytes[5]; } value = {5, {'x', 'y', 'z', 'z', 'y'}};
COMMENT("Test pb_enc_bytes")
TEST(WRITES(pb_enc_bytes(&s, NULL, &value), "\x05xyzzy"))
value.size = 0;
TEST(WRITES(pb_enc_bytes(&s, NULL, &value), "\x00"))
}
{
uint8_t buffer[30];
pb_ostream_t s;
char value[] = "xyzzy";
COMMENT("Test pb_enc_string")
TEST(WRITES(pb_enc_string(&s, NULL, &value), "\x05xyzzy"))
value[0] = '\0';
TEST(WRITES(pb_enc_string(&s, NULL, &value), "\x00"))
}
{
uint8_t buffer[10];
pb_ostream_t s;
pb_strstream_t s2;
IntegerArray msg = {{0}, 5, {1, 2, 3, 4, 5}};
COMMENT("Test pb_encode with int32 array")
TEST(WRITES_BOTH(pb_encode(&s, IntegerArray_msg, &msg),
pb_encode_buffer(&s2, IntegerArray_msg, &msg),
"\x0A\x05\x01\x02\x03\x04\x05"))
msg.data_count = 0;
TEST(WRITES_BOTH(pb_encode(&s, IntegerArray_msg, &msg),
pb_encode_buffer(&s2, IntegerArray_msg, &msg), ""))
msg.data_count = 10;
TEST(!pb_encode(&s, IntegerArray_msg, &msg))
TEST(!pb_encode_buffer(&s2, IntegerArray_msg, &msg))
}
{
uint8_t buffer[10];
pb_ostream_t s;
pb_strstream_t s2;
FloatArray msg = {{0}, 1, {99.0f}};
COMMENT("Test pb_encode with float array")
TEST(WRITES_BOTH(pb_encode(&s, FloatArray_msg, &msg),
pb_encode_buffer(&s2, FloatArray_msg, &msg),
"\x0A\x04\x00\x00\xc6\x42"))
msg.data_count = 0;
TEST(WRITES_BOTH(pb_encode(&s, FloatArray_msg, &msg),
pb_encode_buffer(&s2, FloatArray_msg, &msg), ""))
msg.data_count = 3;
TEST(!pb_encode(&s, FloatArray_msg, &msg))
TEST(!pb_encode_buffer(&s2, FloatArray_msg, &msg))
}
{
uint8_t buffer[10];
pb_ostream_t s;
pb_strstream_t s2;
CallbackArray msg;
COMMENT("Test pb_encode with callback field.")
msg.data.funcs.encode = &fieldcallback;
TEST(WRITES(pb_encode(&s, CallbackArray_msg, &msg), "\x08\x55"))
msg.data.funcs.encode_buffer = &fieldcallback_buf;
TEST(WRITES_BUF(pb_encode_buffer(&s2, CallbackArray_msg, &msg), "\x08\x55"))
}
{
uint8_t buffer[10];
pb_ostream_t s;
pb_strstream_t s2;
IntegerContainer msg = {{0}, {{0}, 5, {1,2,3,4,5}}};
COMMENT("Test pb_encode with packed array in a submessage.")
TEST(WRITES_BOTH(pb_encode(&s, IntegerContainer_msg, &msg),
pb_encode_buffer(&s2, IntegerContainer_msg, &msg),
"\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
}
{
uint8_t buffer[10];
pb_ostream_t s;
pb_strstream_t s2;
CallbackContainer msg;
CallbackContainerContainer msg2;
uint32_t state = 1;
COMMENT("Test pb_encode with callback field in a submessage.")
msg.submsg.data.funcs.encode = &fieldcallback;
msg2.submsg.submsg.data.funcs.encode = &fieldcallback;
TEST(WRITES(pb_encode(&s, CallbackContainer_msg, &msg), "\x0A\x02\x08\x55"))
TEST(WRITES(pb_encode(&s, CallbackContainerContainer_msg, &msg2),
"\x0A\x04\x0A\x02\x08\x55"))
msg.submsg.data.funcs.encode_buffer = &fieldcallback_buf;
msg2.submsg.submsg.data.funcs.encode_buffer = &fieldcallback_buf;
TEST(WRITES_BUF(pb_encode_buffer(&s2, CallbackContainer_msg, &msg), "\x0A\x02\x08\x55"))
TEST(WRITES_BUF(pb_encode_buffer(&s2, CallbackContainerContainer_msg, &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_msg, &msg))
state = 1;
TEST(!pb_encode(&s, CallbackContainerContainer_msg, &msg2))
msg.submsg.data.funcs.encode_buffer = &crazyfieldcallback_buf;
msg.submsg.data.arg = &state;
msg2.submsg.submsg.data.funcs.encode_buffer = &crazyfieldcallback_buf;
msg2.submsg.submsg.data.arg = &state;
TEST(!pb_encode_buffer(&s2, CallbackContainer_msg, &msg))
state = 1;
TEST(!pb_encode_buffer(&s2, CallbackContainerContainer_msg, &msg2))
}
{
uint8_t buffer[30];
pb_ostream_t s;
pb_strstream_t s2;
PointerContainer msg;
DefaultContainer msg2;
IntegerArray msg3;
COMMENT("Test pb_encode with pointer fields.")
memset(&msg, 0, sizeof(msg));
memset(&msg2, 0, sizeof(msg2));
msg.text = "a";
msg.blob.size = 1;
msg.blob.bytes = (uint8_t*)"b";
msg.submsg = &msg2;
TEST(WRITES_BOTH(pb_encode(&s, PointerContainer_msg, &msg),
pb_encode_buffer(&s2, PointerContainer_msg, &msg),
"\x0A\x01\x61\x12\x01\x62\x1A\x00"))
memset(&msg3, 0, sizeof(msg3));
msg.rtext_count = 1;
msg.rtext[0] = "e";
msg.rblob_count = 1;
msg.rblob[0].size = 1;
msg.rblob[0].bytes = (uint8_t*)"f";
msg.rsubmsg_count = 1;
msg.rsubmsg[0] = &msg3;
TEST(WRITES_BOTH(pb_encode(&s, PointerContainer_msg, &msg),
pb_encode_buffer(&s2, PointerContainer_msg, &msg),
"\x0A\x01\x61\x12\x01\x62\x1A\x00"
"\x2A\x01\x65\x32\x01\x66\x3A\x00"));
PointerContainer_set(msg, otext);
msg.otext = "c";
PointerContainer_set(msg, oblob);
msg.oblob.size = 1;
msg.oblob.bytes = (uint8_t*)"d";
TEST(WRITES_BOTH(pb_encode(&s, PointerContainer_msg, &msg),
pb_encode_buffer(&s2, PointerContainer_msg, &msg),
"\x0A\x01\x61\x12\x01\x62\x1A\x00"
"\x2A\x01\x65\x32\x01\x66\x3A\x00"
"\x42\x01\x63\x4A\x01\x64"));
}
if (status != 0)
fprintf(stdout, "\n\nSome tests FAILED!\n");
return status;
}
Reference in New Issue View Git Blame Copy Permalink