aboutsummaryrefslogtreecommitdiffstats
path: root/Software/External Repositories/Protobuf/protobuf-c-master/t/generated-code2/test-generated-code2.c
diff options
context:
space:
mode:
Diffstat (limited to 'Software/External Repositories/Protobuf/protobuf-c-master/t/generated-code2/test-generated-code2.c')
-rw-r--r--Software/External Repositories/Protobuf/protobuf-c-master/t/generated-code2/test-generated-code2.c2340
1 files changed, 2340 insertions, 0 deletions
diff --git a/Software/External Repositories/Protobuf/protobuf-c-master/t/generated-code2/test-generated-code2.c b/Software/External Repositories/Protobuf/protobuf-c-master/t/generated-code2/test-generated-code2.c
new file mode 100644
index 000000000..4739736a0
--- /dev/null
+++ b/Software/External Repositories/Protobuf/protobuf-c-master/t/generated-code2/test-generated-code2.c
@@ -0,0 +1,2340 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "t/test-full.pb-c.h"
+#include "t/test-optimized.pb-c.h"
+#include "t/generated-code2/test-full-cxx-output.inc"
+
+#define TEST_ENUM_SMALL_TYPE_NAME Foo__TestEnumSmall
+#define TEST_ENUM_SMALL(shortname) FOO__TEST_ENUM_SMALL__##shortname
+#define TEST_ENUM_TYPE_NAME Foo__TestEnum
+#include "common-test-arrays.h"
+#define N_ELEMENTS(arr) (sizeof(arr)/sizeof((arr)[0]))
+
+/* ==== helper functions ==== */
+static protobuf_c_boolean
+are_bytes_equal (unsigned actual_len,
+ const uint8_t *actual_data,
+ unsigned expected_len,
+ const uint8_t *expected_data)
+{
+ if (actual_len != expected_len)
+ return 0;
+ return memcmp (actual_data, expected_data, actual_len) == 0;
+}
+static void
+dump_bytes_stderr (size_t len, const uint8_t *data)
+{
+ size_t i;
+ for (i = 0; i < len; i++)
+ fprintf(stderr," %02x", data[i]);
+ fprintf(stderr,"\n");
+}
+static void
+test_versus_static_array(unsigned actual_len,
+ const uint8_t *actual_data,
+ unsigned expected_len,
+ const uint8_t *expected_data,
+ const char *static_buf_name,
+ const char *filename,
+ unsigned lineno)
+{
+ if (are_bytes_equal (actual_len, actual_data, expected_len, expected_data))
+ return;
+
+ fprintf (stderr, "test_versus_static_array failed:\n"
+ "actual: [length=%u]\n", actual_len);
+ dump_bytes_stderr (actual_len, actual_data);
+ fprintf (stderr, "expected: [length=%u] [buffer %s]\n",
+ expected_len, static_buf_name);
+ dump_bytes_stderr (expected_len, expected_data);
+ fprintf (stderr, "at line %u of %s.\n", lineno, filename);
+ abort();
+}
+
+#define TEST_VERSUS_STATIC_ARRAY(actual_len, actual_data, buf) \
+ test_versus_static_array(actual_len,actual_data, \
+ sizeof(buf), buf, #buf, __FILE__, __LINE__)
+
+/* rv is unpacked message */
+static void *
+test_compare_pack_methods (ProtobufCMessage *message,
+ size_t *packed_len_out,
+ uint8_t **packed_out)
+{
+ unsigned char scratch[16];
+ ProtobufCBufferSimple bs = PROTOBUF_C_BUFFER_SIMPLE_INIT (scratch);
+ size_t siz1 = protobuf_c_message_get_packed_size (message);
+ size_t siz2;
+ size_t siz3 = protobuf_c_message_pack_to_buffer (message, &bs.base);
+ void *packed1 = malloc (siz1);
+ void *rv;
+ assert (packed1 != NULL);
+ assert (siz1 == siz3);
+ siz2 = protobuf_c_message_pack (message, packed1);
+ assert (siz1 == siz2);
+ assert (bs.len == siz1);
+ assert (memcmp (bs.data, packed1, siz1) == 0);
+ rv = protobuf_c_message_unpack (message->descriptor, NULL, siz1, packed1);
+ assert (rv != NULL);
+ PROTOBUF_C_BUFFER_SIMPLE_CLEAR (&bs);
+ *packed_len_out = siz1;
+ *packed_out = packed1;
+ return rv;
+}
+
+#define GENERIC_ASSIGN(dst,src) ((dst) = (src))
+
+#define NUMERIC_EQUALS(a,b) ((a) == (b))
+#define STRING_EQUALS(a,b) (strcmp((a),(b))==0)
+
+#define CHECK_NONE(a)
+#define CHECK_NOT_NULL(a) assert( (a) != NULL )
+
+static protobuf_c_boolean
+binary_data_equals (ProtobufCBinaryData a, ProtobufCBinaryData b)
+{
+ if (a.len != b.len)
+ return 0;
+ if (a.len == 0 && b.len == 0)
+ return 1;
+ return memcmp (a.data, b.data, a.len) == 0;
+}
+
+static protobuf_c_boolean
+submesses_equals (Foo__SubMess *a, Foo__SubMess *b)
+{
+ assert(a->base.descriptor == &foo__sub_mess__descriptor);
+ assert(b->base.descriptor == &foo__sub_mess__descriptor);
+ return a->test == b->test;
+}
+
+/* === the actual tests === */
+
+
+/* === misc fencepost tests === */
+static void test_enum_small (void)
+{
+
+#define DO_TEST(UC_VALUE) \
+ do{ \
+ Foo__TestMessRequiredEnumSmall small = FOO__TEST_MESS_REQUIRED_ENUM_SMALL__INIT; \
+ size_t len; \
+ uint8_t *data; \
+ Foo__TestMessRequiredEnumSmall *unpacked; \
+ small.test = FOO__TEST_ENUM_SMALL__##UC_VALUE; \
+ unpacked = test_compare_pack_methods ((ProtobufCMessage*)&small, &len, &data); \
+ assert (unpacked->test == FOO__TEST_ENUM_SMALL__##UC_VALUE); \
+ foo__test_mess_required_enum_small__free_unpacked (unpacked, NULL); \
+ TEST_VERSUS_STATIC_ARRAY (len, data, test_enum_small_##UC_VALUE); \
+ free (data); \
+ }while(0)
+
+ assert (sizeof (Foo__TestEnumSmall) == 4);
+
+ DO_TEST(NEG_VALUE);
+ DO_TEST(VALUE);
+ DO_TEST(OTHER_VALUE);
+
+#undef DO_TEST
+}
+
+static void test_enum_big (void)
+{
+ Foo__TestMessRequiredEnum big = FOO__TEST_MESS_REQUIRED_ENUM__INIT;
+ size_t len;
+ uint8_t *data;
+ Foo__TestMessRequiredEnum *unpacked;
+
+ assert (sizeof (Foo__TestEnum) == 4);
+
+#define DO_ONE_TEST(shortname, numeric_value, encoded_len) \
+ do{ \
+ big.test = FOO__TEST_ENUM__##shortname; \
+ unpacked = test_compare_pack_methods ((ProtobufCMessage*)&big, &len, &data); \
+ assert (unpacked->test == FOO__TEST_ENUM__##shortname); \
+ foo__test_mess_required_enum__free_unpacked (unpacked, NULL); \
+ TEST_VERSUS_STATIC_ARRAY (len, data, test_enum_big_##shortname); \
+ assert (encoded_len + 1 == len); \
+ assert (big.test == numeric_value); \
+ free (data); \
+ }while(0)
+
+ DO_ONE_TEST(VALUENEG123456, -123456, 10);
+ DO_ONE_TEST(VALUENEG1, -1, 10);
+ DO_ONE_TEST(VALUE0, 0, 1);
+ DO_ONE_TEST(VALUE127, 127, 1);
+ DO_ONE_TEST(VALUE128, 128, 2);
+ DO_ONE_TEST(VALUE16383, 16383, 2);
+ DO_ONE_TEST(VALUE16384, 16384, 3);
+ DO_ONE_TEST(VALUE2097151, 2097151, 3);
+ DO_ONE_TEST(VALUE2097152, 2097152, 4);
+ DO_ONE_TEST(VALUE268435455, 268435455, 4);
+ DO_ONE_TEST(VALUE268435456, 268435456, 5);
+
+#undef DO_ONE_TEST
+}
+static void test_field_numbers (void)
+{
+ size_t len;
+ uint8_t *data;
+
+#define DO_ONE_TEST(num, exp_len) \
+ { \
+ Foo__TestFieldNo##num t = FOO__TEST_FIELD_NO##num##__INIT; \
+ Foo__TestFieldNo##num *t2; \
+ t.test = "tst"; \
+ t2 = test_compare_pack_methods ((ProtobufCMessage*)(&t), &len, &data); \
+ assert (strcmp (t2->test, "tst") == 0); \
+ TEST_VERSUS_STATIC_ARRAY (len, data, test_field_number_##num); \
+ assert (len == exp_len); \
+ free (data); \
+ foo__test_field_no##num##__free_unpacked (t2, NULL); \
+ }
+ DO_ONE_TEST (15, 1 + 1 + 3);
+ DO_ONE_TEST (16, 2 + 1 + 3);
+ DO_ONE_TEST (2047, 2 + 1 + 3);
+ DO_ONE_TEST (2048, 3 + 1 + 3);
+ DO_ONE_TEST (262143, 3 + 1 + 3);
+ DO_ONE_TEST (262144, 4 + 1 + 3);
+ DO_ONE_TEST (33554431, 4 + 1 + 3);
+ DO_ONE_TEST (33554432, 5 + 1 + 3);
+#undef DO_ONE_TEST
+}
+
+/* === Required type fields === */
+
+#define DO_TEST_REQUIRED(Type, TYPE, type, value, example_packed_data, equal_func) \
+ do{ \
+ Foo__TestMessRequired##Type opt = FOO__TEST_MESS_REQUIRED_##TYPE##__INIT; \
+ Foo__TestMessRequired##Type *mess; \
+ size_t len; uint8_t *data; \
+ opt.test = value; \
+ mess = test_compare_pack_methods (&opt.base, &len, &data); \
+ TEST_VERSUS_STATIC_ARRAY (len, data, example_packed_data); \
+ assert (equal_func (mess->test, value)); \
+ foo__test_mess_required_##type##__free_unpacked (mess, NULL); \
+ free (data); \
+ }while(0)
+static void test_required_int32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(Int32, INT32, int32, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(INT32_MIN, test_required_int32_min);
+ DO_TEST(-1000, test_required_int32_m1000);
+ DO_TEST(0, test_required_int32_0);
+ DO_TEST(INT32_MAX, test_required_int32_max);
+#undef DO_TEST
+}
+
+static void test_required_sint32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(SInt32, SINT32, sint32, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(INT32_MIN, test_required_sint32_min);
+ DO_TEST(-1000, test_required_sint32_m1000);
+ DO_TEST(0, test_required_sint32_0);
+ DO_TEST(INT32_MAX, test_required_sint32_max);
+#undef DO_TEST
+}
+
+static void test_required_sfixed32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(SFixed32, SFIXED32, sfixed32, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(INT32_MIN, test_required_sfixed32_min);
+ DO_TEST(-1000, test_required_sfixed32_m1000);
+ DO_TEST(0, test_required_sfixed32_0);
+ DO_TEST(INT32_MAX, test_required_sfixed32_max);
+#undef DO_TEST
+}
+
+static void test_required_uint32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(UInt32, UINT32, uint32, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(0, test_required_uint32_0);
+ DO_TEST(MILLION, test_required_uint32_million);
+ DO_TEST(UINT32_MAX, test_required_uint32_max);
+#undef DO_TEST
+}
+
+static void test_required_fixed32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(Fixed32, FIXED32, fixed32, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(0, test_required_fixed32_0);
+ DO_TEST(MILLION, test_required_fixed32_million);
+ DO_TEST(UINT32_MAX, test_required_fixed32_max);
+#undef DO_TEST
+}
+
+static void test_required_int64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(Int64, INT64, int64, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(INT64_MIN, test_required_int64_min);
+ DO_TEST(-TRILLION, test_required_int64_mtril);
+ DO_TEST(0, test_required_int64_0);
+ DO_TEST(QUADRILLION, test_required_int64_quad);
+ DO_TEST(INT64_MAX, test_required_int64_max);
+#undef DO_TEST
+}
+
+static void test_required_sint64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(SInt64, SINT64, sint64, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(INT64_MIN, test_required_sint64_min);
+ DO_TEST(-TRILLION, test_required_sint64_mtril);
+ DO_TEST(0, test_required_sint64_0);
+ DO_TEST(QUADRILLION, test_required_sint64_quad);
+ DO_TEST(INT64_MAX, test_required_sint64_max);
+#undef DO_TEST
+}
+
+static void test_required_sfixed64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(SFixed64, SFIXED64, sfixed64, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(INT64_MIN, test_required_sfixed64_min);
+ DO_TEST(-TRILLION, test_required_sfixed64_mtril);
+ DO_TEST(0, test_required_sfixed64_0);
+ DO_TEST(QUADRILLION, test_required_sfixed64_quad);
+ DO_TEST(INT64_MAX, test_required_sfixed64_max);
+#undef DO_TEST
+}
+
+static void test_required_uint64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(UInt64, UINT64, uint64, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(0, test_required_uint64_0);
+ DO_TEST(THOUSAND, test_required_uint64_thou);
+ DO_TEST(MILLION, test_required_uint64_mill);
+ DO_TEST(BILLION, test_required_uint64_bill);
+ DO_TEST(BILLION*20, test_required_uint64_20_bill);
+ DO_TEST(TRILLION, test_required_uint64_tril);
+ DO_TEST(TRILLION*20, test_required_uint64_20_tril);
+ DO_TEST(QUADRILLION, test_required_uint64_quad);
+ DO_TEST(QUINTILLION, test_required_uint64_quint);
+ DO_TEST(UINT64_MAX, test_required_uint64_max);
+#undef DO_TEST
+}
+
+static void test_required_fixed64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(Fixed64, FIXED64, fixed64, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(0, test_required_fixed64_0);
+ DO_TEST(THOUSAND, test_required_fixed64_thou);
+ DO_TEST(MILLION, test_required_fixed64_mill);
+ DO_TEST(BILLION, test_required_fixed64_bill);
+ DO_TEST(TRILLION, test_required_fixed64_tril);
+ DO_TEST(QUADRILLION, test_required_fixed64_quad);
+ DO_TEST(QUINTILLION, test_required_fixed64_quint);
+ DO_TEST(UINT64_MAX, test_required_fixed64_max);
+#undef DO_TEST
+}
+
+static void test_required_float (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(Float, FLOAT, float, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(-THOUSAND, test_required_float_mthou);
+ DO_TEST(0, test_required_float_0);
+ DO_TEST(420, test_required_float_420);
+#undef DO_TEST
+}
+
+static void test_required_double (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(Double, DOUBLE, double, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(-THOUSAND, test_required_double_mthou);
+ DO_TEST(0, test_required_double_0);
+ DO_TEST(420, test_required_double_420);
+#undef DO_TEST
+}
+
+static void test_required_bool (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(Bool, BOOL, bool, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(0, test_required_bool_0);
+ DO_TEST(1, test_required_bool_1);
+#undef DO_TEST
+}
+
+static void test_required_TestEnumSmall (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(EnumSmall, ENUM_SMALL, enum_small, value, example_packed_data, NUMERIC_EQUALS)
+ DO_TEST(FOO__TEST_ENUM_SMALL__VALUE, test_required_enum_small_VALUE);
+ DO_TEST(FOO__TEST_ENUM_SMALL__OTHER_VALUE, test_required_enum_small_OTHER_VALUE);
+#undef DO_TEST
+}
+
+static void test_required_TestEnum (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(Enum, ENUM, enum, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (FOO__TEST_ENUM__VALUENEG1, test_required_enum_neg1);
+ DO_TEST (FOO__TEST_ENUM__VALUE0, test_required_enum_0);
+ DO_TEST (FOO__TEST_ENUM__VALUE1, test_required_enum_1);
+ DO_TEST (FOO__TEST_ENUM__VALUE127, test_required_enum_127);
+ DO_TEST (FOO__TEST_ENUM__VALUE128, test_required_enum_128);
+ DO_TEST (FOO__TEST_ENUM__VALUE16383, test_required_enum_16383);
+ DO_TEST (FOO__TEST_ENUM__VALUE16384, test_required_enum_16384);
+ DO_TEST (FOO__TEST_ENUM__VALUE2097151, test_required_enum_2097151);
+ DO_TEST (FOO__TEST_ENUM__VALUE2097152, test_required_enum_2097152);
+ DO_TEST (FOO__TEST_ENUM__VALUE268435455, test_required_enum_268435455);
+ DO_TEST (FOO__TEST_ENUM__VALUE268435456, test_required_enum_268435456);
+
+#undef DO_TEST
+}
+
+static void test_required_string (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED(String, STRING, string, value, example_packed_data, STRING_EQUALS)
+
+ DO_TEST("", test_required_string_empty);
+ DO_TEST("hello", test_required_string_hello);
+ DO_TEST("two hundred xs follow: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", test_required_string_long);
+
+#undef DO_TEST
+}
+
+static void test_required_bytes (void)
+{
+ static ProtobufCBinaryData bd_empty = { 0, (uint8_t*)"" };
+ static ProtobufCBinaryData bd_hello = { 5, (uint8_t*)"hello" };
+ static ProtobufCBinaryData bd_random = { 5, (uint8_t*)"\1\0\375\2\4" };
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED (Bytes, BYTES, bytes, value, example_packed_data, binary_data_equals)
+ DO_TEST (bd_empty, test_required_bytes_empty);
+ DO_TEST (bd_hello, test_required_bytes_hello);
+ DO_TEST (bd_random, test_required_bytes_random);
+#undef DO_TEST
+}
+
+static void test_required_SubMess (void)
+{
+ Foo__SubMess submess = FOO__SUB_MESS__INIT;
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_REQUIRED (Message, MESSAGE, message, value, example_packed_data, submesses_equals)
+ submess.test = 0;
+ DO_TEST (&submess, test_required_submess_0);
+ submess.test = 42;
+ DO_TEST (&submess, test_required_submess_42);
+#undef DO_TEST
+}
+
+/* === Optional type fields === */
+static void test_empty_optional (void)
+{
+ Foo__TestMessOptional mess = FOO__TEST_MESS_OPTIONAL__INIT;
+ size_t len;
+ uint8_t *data;
+ Foo__TestMessOptional *mess2 = test_compare_pack_methods (&mess.base, &len, &data);
+ assert (len == 0);
+ free (data);
+ foo__test_mess_optional__free_unpacked (mess2, NULL);
+}
+
+
+#define DO_TEST_OPTIONAL(base_member, value, example_packed_data, equal_func) \
+ do{ \
+ Foo__TestMessOptional opt = FOO__TEST_MESS_OPTIONAL__INIT; \
+ Foo__TestMessOptional *mess; \
+ size_t len; uint8_t *data; \
+ opt.has_##base_member = 1; \
+ opt.base_member = value; \
+ mess = test_compare_pack_methods (&opt.base, &len, &data); \
+ TEST_VERSUS_STATIC_ARRAY (len, data, example_packed_data); \
+ assert (mess->has_##base_member); \
+ assert (equal_func (mess->base_member, value)); \
+ foo__test_mess_optional__free_unpacked (mess, NULL); \
+ free (data); \
+ }while(0)
+
+static void test_optional_int32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_int32, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (INT32_MIN, test_optional_int32_min);
+ DO_TEST (-1, test_optional_int32_m1);
+ DO_TEST (0, test_optional_int32_0);
+ DO_TEST (666, test_optional_int32_666);
+ DO_TEST (INT32_MAX, test_optional_int32_max);
+
+#undef DO_TEST
+}
+
+static void test_optional_sint32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_sint32, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (INT32_MIN, test_optional_sint32_min);
+ DO_TEST (-1, test_optional_sint32_m1);
+ DO_TEST (0, test_optional_sint32_0);
+ DO_TEST (666, test_optional_sint32_666);
+ DO_TEST (INT32_MAX, test_optional_sint32_max);
+
+#undef DO_TEST
+}
+static void test_optional_sfixed32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_sfixed32, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (INT32_MIN, test_optional_sfixed32_min);
+ DO_TEST (-1, test_optional_sfixed32_m1);
+ DO_TEST (0, test_optional_sfixed32_0);
+ DO_TEST (666, test_optional_sfixed32_666);
+ DO_TEST (INT32_MAX, test_optional_sfixed32_max);
+
+#undef DO_TEST
+}
+static void test_optional_int64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_int64, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (INT64_MIN, test_optional_int64_min);
+ DO_TEST (-1111111111LL, test_optional_int64_m1111111111LL);
+ DO_TEST (0, test_optional_int64_0);
+ DO_TEST (QUINTILLION, test_optional_int64_quintillion);
+ DO_TEST (INT64_MAX, test_optional_int64_max);
+
+#undef DO_TEST
+}
+static void test_optional_sint64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_sint64, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (INT64_MIN, test_optional_sint64_min);
+ DO_TEST (-1111111111LL, test_optional_sint64_m1111111111LL);
+ DO_TEST (0, test_optional_sint64_0);
+ DO_TEST (QUINTILLION, test_optional_sint64_quintillion);
+ DO_TEST (INT64_MAX, test_optional_sint64_max);
+
+#undef DO_TEST
+}
+static void test_optional_sfixed64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_sfixed64, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (INT64_MIN, test_optional_sfixed64_min);
+ DO_TEST (-1111111111LL, test_optional_sfixed64_m1111111111LL);
+ DO_TEST (0, test_optional_sfixed64_0);
+ DO_TEST (QUINTILLION, test_optional_sfixed64_quintillion);
+ DO_TEST (INT64_MAX, test_optional_sfixed64_max);
+
+#undef DO_TEST
+}
+
+static void test_optional_uint32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_uint32, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_uint32_0);
+ DO_TEST (669, test_optional_uint32_669);
+ DO_TEST (UINT32_MAX, test_optional_uint32_max);
+
+#undef DO_TEST
+}
+
+static void test_optional_fixed32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_fixed32, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_fixed32_0);
+ DO_TEST (669, test_optional_fixed32_669);
+ DO_TEST (UINT32_MAX, test_optional_fixed32_max);
+
+#undef DO_TEST
+}
+
+static void test_optional_uint64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_uint64, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_uint64_0);
+ DO_TEST (669669669669669ULL, test_optional_uint64_669669669669669);
+ DO_TEST (UINT64_MAX, test_optional_uint64_max);
+
+#undef DO_TEST
+}
+
+static void test_optional_fixed64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_fixed64, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_fixed64_0);
+ DO_TEST (669669669669669ULL, test_optional_fixed64_669669669669669);
+ DO_TEST (UINT64_MAX, test_optional_fixed64_max);
+
+#undef DO_TEST
+}
+
+static void test_optional_float (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_float, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (-100, test_optional_float_m100);
+ DO_TEST (0, test_optional_float_0);
+ DO_TEST (141243, test_optional_float_141243);
+
+#undef DO_TEST
+}
+static void test_optional_double (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_double, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (-100, test_optional_double_m100);
+ DO_TEST (0, test_optional_double_0);
+ DO_TEST (141243, test_optional_double_141243);
+
+#undef DO_TEST
+}
+static void test_optional_bool (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_boolean, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_bool_0);
+ DO_TEST (1, test_optional_bool_1);
+
+#undef DO_TEST
+}
+static void test_optional_TestEnumSmall (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_enum_small, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_enum_small_0);
+ DO_TEST (1, test_optional_enum_small_1);
+
+#undef DO_TEST
+}
+
+static void test_optional_TestEnum (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL(test_enum, value, example_packed_data, NUMERIC_EQUALS)
+
+ DO_TEST (FOO__TEST_ENUM__VALUENEG1, test_optional_enum_neg1);
+ DO_TEST (FOO__TEST_ENUM__VALUE0, test_optional_enum_0);
+ DO_TEST (FOO__TEST_ENUM__VALUE1, test_optional_enum_1);
+ DO_TEST (FOO__TEST_ENUM__VALUE127, test_optional_enum_127);
+ DO_TEST (FOO__TEST_ENUM__VALUE128, test_optional_enum_128);
+ DO_TEST (FOO__TEST_ENUM__VALUE16383, test_optional_enum_16383);
+ DO_TEST (FOO__TEST_ENUM__VALUE16384, test_optional_enum_16384);
+ DO_TEST (FOO__TEST_ENUM__VALUE2097151, test_optional_enum_2097151);
+ DO_TEST (FOO__TEST_ENUM__VALUE2097152, test_optional_enum_2097152);
+ DO_TEST (FOO__TEST_ENUM__VALUE268435455, test_optional_enum_268435455);
+ DO_TEST (FOO__TEST_ENUM__VALUE268435456, test_optional_enum_268435456);
+
+#undef DO_TEST
+}
+
+#define DO_TEST_OPTIONAL__NO_HAS(base_member, value, example_packed_data, equal_func) \
+ do{ \
+ Foo__TestMessOptional opt = FOO__TEST_MESS_OPTIONAL__INIT; \
+ Foo__TestMessOptional *mess; \
+ size_t len; uint8_t *data; \
+ opt.base_member = value; \
+ mess = test_compare_pack_methods (&opt.base, &len, &data); \
+ TEST_VERSUS_STATIC_ARRAY (len, data, example_packed_data); \
+ assert (mess->base_member != NULL); \
+ assert (equal_func (mess->base_member, value)); \
+ foo__test_mess_optional__free_unpacked (mess, NULL); \
+ free (data); \
+ }while(0)
+
+static void test_optional_string (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL__NO_HAS (test_string, value, example_packed_data, STRING_EQUALS)
+ DO_TEST ("", test_optional_string_empty);
+ DO_TEST ("hello", test_optional_string_hello);
+#undef DO_TEST
+}
+static void test_optional_bytes (void)
+{
+ static ProtobufCBinaryData bd_empty = { 0, (uint8_t*)"" };
+ static ProtobufCBinaryData bd_hello = { 5, (uint8_t*)"hello" };
+ static ProtobufCBinaryData bd_random = { 5, (uint8_t*)"\1\0\375\2\4" };
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL (test_bytes, value, example_packed_data, binary_data_equals)
+ DO_TEST (bd_empty, test_optional_bytes_empty);
+ DO_TEST (bd_hello, test_optional_bytes_hello);
+ DO_TEST (bd_random, test_optional_bytes_random);
+#undef DO_TEST
+}
+static void test_optional_SubMess (void)
+{
+ Foo__SubMess submess = FOO__SUB_MESS__INIT;
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_OPTIONAL__NO_HAS (test_message, value, example_packed_data, submesses_equals)
+ submess.test = 0;
+ DO_TEST (&submess, test_optional_submess_0);
+ submess.test = 42;
+ DO_TEST (&submess, test_optional_submess_42);
+#undef DO_TEST
+}
+
+/* === Oneof type fields === */
+static void test_empty_oneof (void)
+{
+ Foo__TestMessOneof mess = FOO__TEST_MESS_ONEOF__INIT;
+ size_t len;
+ uint8_t *data;
+ Foo__TestMessOneof *mess2 = test_compare_pack_methods (&mess.base, &len, &data);
+ assert (len == 0);
+ free (data);
+ foo__test_mess_oneof__free_unpacked (mess2, NULL);
+}
+
+#define DO_TEST_GENERIC_ONEOF(type, init, free_unpacked, case_member, case_enum, member, value, example_packed_data, assign, equal_func, result_check) \
+ do{ \
+ type opt = init; \
+ type *mess; \
+ size_t len; uint8_t *data; \
+ opt.case_member = case_enum; \
+ assign(opt.member, value); \
+ mess = test_compare_pack_methods (&opt.base, &len, &data); \
+ TEST_VERSUS_STATIC_ARRAY (len, data, example_packed_data); \
+ assert (mess->case_member == case_enum); \
+ result_check(mess->member); \
+ assert (equal_func (mess->member, value)); \
+ free_unpacked (mess, NULL); \
+ free (data); \
+ }while(0)
+
+#define DO_TEST_ONEOF(member, MEMBER, value, example_packed_data, assign, equal_func) \
+ DO_TEST_GENERIC_ONEOF(Foo__TestMessOneof, \
+ FOO__TEST_MESS_ONEOF__INIT, \
+ foo__test_mess_oneof__free_unpacked, \
+ test_oneof_case, \
+ FOO__TEST_MESS_ONEOF__TEST_ONEOF_##MEMBER, \
+ member, \
+ value, example_packed_data, assign, equal_func, CHECK_NONE)
+
+#define DO_TEST_ONEOF_REF_VAL(member, MEMBER, value, example_packed_data, assign, equal_func) \
+ DO_TEST_GENERIC_ONEOF(Foo__TestMessOneof, \
+ FOO__TEST_MESS_ONEOF__INIT, \
+ foo__test_mess_oneof__free_unpacked, \
+ test_oneof_case, \
+ FOO__TEST_MESS_ONEOF__TEST_ONEOF_##MEMBER, \
+ member, \
+ value, example_packed_data, assign, equal_func, CHECK_NOT_NULL)
+
+static void test_oneof_int32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_int32, TEST_INT32, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (INT32_MIN, test_optional_int32_min);
+ DO_TEST (-1, test_optional_int32_m1);
+ DO_TEST (0, test_optional_int32_0);
+ DO_TEST (666, test_optional_int32_666);
+ DO_TEST (INT32_MAX, test_optional_int32_max);
+
+#undef DO_TEST
+}
+static void test_oneof_sint32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_sint32, TEST_SINT32, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (INT32_MIN, test_optional_sint32_min);
+ DO_TEST (-1, test_optional_sint32_m1);
+ DO_TEST (0, test_optional_sint32_0);
+ DO_TEST (666, test_optional_sint32_666);
+ DO_TEST (INT32_MAX, test_optional_sint32_max);
+
+#undef DO_TEST
+}
+static void test_oneof_sfixed32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_sfixed32, TEST_SFIXED32, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (INT32_MIN, test_optional_sfixed32_min);
+ DO_TEST (-1, test_optional_sfixed32_m1);
+ DO_TEST (0, test_optional_sfixed32_0);
+ DO_TEST (666, test_optional_sfixed32_666);
+ DO_TEST (INT32_MAX, test_optional_sfixed32_max);
+
+#undef DO_TEST
+}
+static void test_oneof_int64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_int64, TEST_INT64, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (INT64_MIN, test_optional_int64_min);
+ DO_TEST (-1111111111LL, test_optional_int64_m1111111111LL);
+ DO_TEST (0, test_optional_int64_0);
+ DO_TEST (QUINTILLION, test_optional_int64_quintillion);
+ DO_TEST (INT64_MAX, test_optional_int64_max);
+
+#undef DO_TEST
+}
+static void test_oneof_sint64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_sint64, TEST_SINT64, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (INT64_MIN, test_optional_sint64_min);
+ DO_TEST (-1111111111LL, test_optional_sint64_m1111111111LL);
+ DO_TEST (0, test_optional_sint64_0);
+ DO_TEST (QUINTILLION, test_optional_sint64_quintillion);
+ DO_TEST (INT64_MAX, test_optional_sint64_max);
+
+#undef DO_TEST
+}
+static void test_oneof_sfixed64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_sfixed64, TEST_SFIXED64, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (INT64_MIN, test_optional_sfixed64_min);
+ DO_TEST (-1111111111LL, test_optional_sfixed64_m1111111111LL);
+ DO_TEST (0, test_optional_sfixed64_0);
+ DO_TEST (QUINTILLION, test_optional_sfixed64_quintillion);
+ DO_TEST (INT64_MAX, test_optional_sfixed64_max);
+
+#undef DO_TEST
+}
+
+static void test_oneof_uint32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_uint32, TEST_UINT32, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_uint32_0);
+ DO_TEST (669, test_optional_uint32_669);
+ DO_TEST (UINT32_MAX, test_optional_uint32_max);
+
+#undef DO_TEST
+}
+
+static void test_oneof_fixed32 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_fixed32, TEST_FIXED32, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_fixed32_0);
+ DO_TEST (669, test_optional_fixed32_669);
+ DO_TEST (UINT32_MAX, test_optional_fixed32_max);
+
+#undef DO_TEST
+}
+
+static void test_oneof_uint64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_uint64, TEST_UINT64, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_uint64_0);
+ DO_TEST (669669669669669ULL, test_optional_uint64_669669669669669);
+ DO_TEST (UINT64_MAX, test_optional_uint64_max);
+
+#undef DO_TEST
+}
+
+static void test_oneof_fixed64 (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_fixed64, TEST_FIXED64, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_fixed64_0);
+ DO_TEST (669669669669669ULL, test_optional_fixed64_669669669669669);
+ DO_TEST (UINT64_MAX, test_optional_fixed64_max);
+
+#undef DO_TEST
+}
+
+static void test_oneof_float (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_float, TEST_FLOAT, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (-100, test_optional_float_m100);
+ DO_TEST (0, test_optional_float_0);
+ DO_TEST (141243, test_optional_float_141243);
+
+#undef DO_TEST
+}
+static void test_oneof_double (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_double, TEST_DOUBLE, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (-100, test_optional_double_m100);
+ DO_TEST (0, test_optional_double_0);
+ DO_TEST (141243, test_optional_double_141243);
+
+#undef DO_TEST
+}
+static void test_oneof_bool (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_boolean, TEST_BOOLEAN, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_bool_0);
+ DO_TEST (1, test_optional_bool_1);
+
+#undef DO_TEST
+}
+static void test_oneof_TestEnumSmall (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_enum_small, TEST_ENUM_SMALL, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (0, test_optional_enum_small_0);
+ DO_TEST (1, test_optional_enum_small_1);
+
+#undef DO_TEST
+}
+
+static void test_oneof_TestEnum (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF(test_enum, TEST_ENUM, value, example_packed_data, GENERIC_ASSIGN, NUMERIC_EQUALS)
+
+ DO_TEST (FOO__TEST_ENUM__VALUENEG1, test_optional_enum_neg1);
+ DO_TEST (FOO__TEST_ENUM__VALUE0, test_optional_enum_0);
+ DO_TEST (FOO__TEST_ENUM__VALUE1, test_optional_enum_1);
+ DO_TEST (FOO__TEST_ENUM__VALUE127, test_optional_enum_127);
+ DO_TEST (FOO__TEST_ENUM__VALUE128, test_optional_enum_128);
+ DO_TEST (FOO__TEST_ENUM__VALUE16383, test_optional_enum_16383);
+ DO_TEST (FOO__TEST_ENUM__VALUE16384, test_optional_enum_16384);
+ DO_TEST (FOO__TEST_ENUM__VALUE2097151, test_optional_enum_2097151);
+ DO_TEST (FOO__TEST_ENUM__VALUE2097152, test_optional_enum_2097152);
+ DO_TEST (FOO__TEST_ENUM__VALUE268435455, test_optional_enum_268435455);
+ DO_TEST (FOO__TEST_ENUM__VALUE268435456, test_optional_enum_268435456);
+
+#undef DO_TEST
+}
+
+static void test_oneof_string (void)
+{
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF_REF_VAL (test_string, TEST_STRING, value, example_packed_data, GENERIC_ASSIGN, STRING_EQUALS)
+ DO_TEST ("", test_optional_string_empty);
+ DO_TEST ("hello", test_optional_string_hello);
+#undef DO_TEST
+}
+static void test_oneof_bytes (void)
+{
+ static ProtobufCBinaryData bd_empty = { 0, (uint8_t*)"" };
+ static ProtobufCBinaryData bd_hello = { 5, (uint8_t*)"hello" };
+ static ProtobufCBinaryData bd_random = { 5, (uint8_t*)"\1\0\375\2\4" };
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF (test_bytes, TEST_BYTES, value, example_packed_data, GENERIC_ASSIGN, binary_data_equals)
+ DO_TEST (bd_empty, test_optional_bytes_empty);
+ DO_TEST (bd_hello, test_optional_bytes_hello);
+ DO_TEST (bd_random, test_optional_bytes_random);
+#undef DO_TEST
+}
+static void test_oneof_SubMess (void)
+{
+ Foo__SubMess submess = FOO__SUB_MESS__INIT;
+#define DO_TEST(value, example_packed_data) \
+ DO_TEST_ONEOF_REF_VAL (test_message, TEST_MESSAGE, value, example_packed_data, GENERIC_ASSIGN, submesses_equals)
+ submess.test = 0;
+ DO_TEST (&submess, test_optional_submess_0);
+ submess.test = 42;
+ DO_TEST (&submess, test_optional_submess_42);
+#undef DO_TEST
+}
+static void test_oneof_merge (void)
+{
+ Foo__TestMessOneof *msg;
+#define DO_TEST(value, member, MEMBER, equals_func, example_packed_data) \
+ msg = foo__test_mess_oneof__unpack (NULL, sizeof (example_packed_data), example_packed_data); \
+ assert (msg); \
+ assert (msg->test_oneof_case == FOO__TEST_MESS_ONEOF__TEST_ONEOF_##MEMBER); \
+ assert (equals_func (msg->member, value)); \
+ foo__test_mess_oneof__free_unpacked (msg, NULL);
+
+ DO_TEST (444455555, test_double, TEST_DOUBLE, NUMERIC_EQUALS, test_oneof_merge_double);
+ DO_TEST (333, test_float, TEST_FLOAT, NUMERIC_EQUALS, test_oneof_merge_float);
+ DO_TEST (666, test_int32, TEST_INT32, NUMERIC_EQUALS, test_oneof_merge_int32);
+ DO_TEST ("", test_string, TEST_STRING, STRING_EQUALS, test_oneof_merge_string);
+
+ Foo__SubMess submess = FOO__SUB_MESS__INIT;
+ submess.test = 42;
+ DO_TEST (&submess, test_message, TEST_MESSAGE, submesses_equals, test_oneof_merge_submess);
+
+ ProtobufCBinaryData bd_hello = { 5, (uint8_t*)"hello" };
+ DO_TEST(bd_hello, test_bytes, TEST_BYTES, binary_data_equals, test_oneof_merge_bytes);
+#undef DO_TEST
+}
+
+/* === repeated type fields === */
+#define DO_TEST_REPEATED(lc_member_name, cast, \
+ static_array, example_packed_data, \
+ equals_macro) \
+ do{ \
+ Foo__TestMess mess = FOO__TEST_MESS__INIT; \
+ Foo__TestMess *mess2; \
+ size_t len; \
+ uint8_t *data; \
+ unsigned i; \
+ mess.n_##lc_member_name = N_ELEMENTS (static_array); \
+ mess.lc_member_name = cast static_array; \
+ mess2 = test_compare_pack_methods ((ProtobufCMessage*)(&mess), &len, &data); \
+ assert(mess2->n_##lc_member_name == N_ELEMENTS (static_array)); \
+ for (i = 0; i < N_ELEMENTS (static_array); i++) \
+ assert(equals_macro(mess2->lc_member_name[i], static_array[i])); \
+ TEST_VERSUS_STATIC_ARRAY (len, data, example_packed_data); \
+ free (data); \
+ foo__test_mess__free_unpacked (mess2, NULL); \
+ }while(0)
+
+static void test_empty_repeated (void)
+{
+ Foo__TestMess mess = FOO__TEST_MESS__INIT;
+ size_t len;
+ uint8_t *data;
+ Foo__TestMess *mess2 = test_compare_pack_methods (&mess.base, &len, &data);
+ assert (len == 0);
+ free (data);
+ foo__test_mess__free_unpacked (mess2, NULL);
+}
+
+static void test_repeated_int32 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_int32, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int32_arr0, test_repeated_int32_arr0);
+ DO_TEST (int32_arr1, test_repeated_int32_arr1);
+ DO_TEST (int32_arr_min_max, test_repeated_int32_arr_min_max);
+
+#undef DO_TEST
+}
+
+static void test_repeated_sint32 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_sint32, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int32_arr0, test_repeated_sint32_arr0);
+ DO_TEST (int32_arr1, test_repeated_sint32_arr1);
+ DO_TEST (int32_arr_min_max, test_repeated_sint32_arr_min_max);
+
+#undef DO_TEST
+}
+
+static void test_repeated_sfixed32 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_sfixed32, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int32_arr0, test_repeated_sfixed32_arr0);
+ DO_TEST (int32_arr1, test_repeated_sfixed32_arr1);
+ DO_TEST (int32_arr_min_max, test_repeated_sfixed32_arr_min_max);
+
+#undef DO_TEST
+}
+
+static void test_repeated_uint32 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_uint32, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (uint32_roundnumbers, test_repeated_uint32_roundnumbers);
+ DO_TEST (uint32_0_max, test_repeated_uint32_0_max);
+
+#undef DO_TEST
+}
+
+
+
+static void test_repeated_fixed32 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_fixed32, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (uint32_roundnumbers, test_repeated_fixed32_roundnumbers);
+ DO_TEST (uint32_0_max, test_repeated_fixed32_0_max);
+
+#undef DO_TEST
+}
+
+static void test_repeated_int64 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_int64, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int64_roundnumbers, test_repeated_int64_roundnumbers);
+ DO_TEST (int64_min_max, test_repeated_int64_min_max);
+
+#undef DO_TEST
+}
+
+static void test_repeated_sint64 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_sint64, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int64_roundnumbers, test_repeated_sint64_roundnumbers);
+ DO_TEST (int64_min_max, test_repeated_sint64_min_max);
+
+#undef DO_TEST
+}
+
+static void test_repeated_sfixed64 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_sfixed64, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int64_roundnumbers, test_repeated_sfixed64_roundnumbers);
+ DO_TEST (int64_min_max, test_repeated_sfixed64_min_max);
+
+#undef DO_TEST
+}
+
+static void test_repeated_uint64 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_uint64, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(uint64_roundnumbers, test_repeated_uint64_roundnumbers);
+ DO_TEST(uint64_0_1_max, test_repeated_uint64_0_1_max);
+ DO_TEST(uint64_random, test_repeated_uint64_random);
+
+#undef DO_TEST
+}
+
+static void test_repeated_fixed64 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_fixed64, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(uint64_roundnumbers, test_repeated_fixed64_roundnumbers);
+ DO_TEST(uint64_0_1_max, test_repeated_fixed64_0_1_max);
+ DO_TEST(uint64_random, test_repeated_fixed64_random);
+
+#undef DO_TEST
+}
+
+static void test_repeated_float (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_float, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(float_random, test_repeated_float_random);
+
+#undef DO_TEST
+}
+
+static void test_repeated_double (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_double, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(double_random, test_repeated_double_random);
+
+#undef DO_TEST
+}
+
+static void test_repeated_boolean (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_boolean, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(boolean_0, test_repeated_boolean_0);
+ DO_TEST(boolean_1, test_repeated_boolean_1);
+ DO_TEST(boolean_random, test_repeated_boolean_random);
+
+#undef DO_TEST
+}
+
+static void test_repeated_TestEnumSmall (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_enum_small, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(enum_small_0, test_repeated_enum_small_0);
+ DO_TEST(enum_small_1, test_repeated_enum_small_1);
+ DO_TEST(enum_small_random, test_repeated_enum_small_random);
+
+#undef DO_TEST
+}
+
+static void test_repeated_TestEnum (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_enum, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(enum_0, test_repeated_enum_0);
+ DO_TEST(enum_1, test_repeated_enum_1);
+ DO_TEST(enum_random, test_repeated_enum_random);
+
+#undef DO_TEST
+}
+
+static void test_repeated_string (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_string, (char **), \
+ static_array, example_packed_data, \
+ STRING_EQUALS)
+
+ DO_TEST(repeated_strings_0, test_repeated_strings_0);
+ DO_TEST(repeated_strings_1, test_repeated_strings_1);
+ DO_TEST(repeated_strings_2, test_repeated_strings_2);
+ DO_TEST(repeated_strings_3, test_repeated_strings_3);
+
+#undef DO_TEST
+}
+
+static void test_repeated_bytes (void)
+{
+ static ProtobufCBinaryData test_binary_data_0[] = {
+ { 4, (uint8_t *) "text" },
+ { 9, (uint8_t *) "str\1\2\3\4\5\0" },
+ { 10, (uint8_t *) "gobble\0foo" }
+ };
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_bytes, , \
+ static_array, example_packed_data, \
+ binary_data_equals)
+
+ DO_TEST (test_binary_data_0, test_repeated_bytes_0);
+
+#undef DO_TEST
+}
+
+static void test_repeated_SubMess (void)
+{
+ static Foo__SubMess submess0 = FOO__SUB_MESS__INIT;
+ static Foo__SubMess submess1 = FOO__SUB_MESS__INIT;
+ static Foo__SubMess submess2 = FOO__SUB_MESS__INIT;
+ static Foo__SubMess *submesses[3] = { &submess0, &submess1, &submess2 };
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_REPEATED(test_message, , \
+ static_array, example_packed_data, \
+ submesses_equals)
+
+ DO_TEST (submesses, test_repeated_submess_0);
+ submess0.test = 42;
+ submess1.test = -10000;
+ submess2.test = 667;
+ DO_TEST (submesses, test_repeated_submess_1);
+
+#undef DO_TEST
+}
+
+#define DO_TEST_PACKED_REPEATED(lc_member_name, cast, \
+ static_array, example_packed_data, \
+ equals_macro) \
+ do{ \
+ Foo__TestMessPacked mess = FOO__TEST_MESS_PACKED__INIT; \
+ Foo__TestMessPacked *mess2; \
+ size_t len; \
+ uint8_t *data; \
+ unsigned i; \
+ mess.n_##lc_member_name = N_ELEMENTS (static_array); \
+ mess.lc_member_name = cast static_array; \
+ mess2 = test_compare_pack_methods ((ProtobufCMessage*)(&mess), &len, &data); \
+ TEST_VERSUS_STATIC_ARRAY (len, data, example_packed_data); \
+ assert(mess2->n_##lc_member_name == N_ELEMENTS (static_array)); \
+ for (i = 0; i < N_ELEMENTS (static_array); i++) \
+ assert(equals_macro(mess2->lc_member_name[i], static_array[i])); \
+ free (data); \
+ foo__test_mess_packed__free_unpacked (mess2, NULL); \
+ }while(0)
+
+static void test_packed_repeated_int32 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_int32, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int32_arr0, test_packed_repeated_int32_arr0);
+ DO_TEST (int32_arr1, test_packed_repeated_int32_arr1);
+ DO_TEST (int32_arr_min_max, test_packed_repeated_int32_arr_min_max);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_sint32 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_sint32, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int32_arr0, test_packed_repeated_sint32_arr0);
+ DO_TEST (int32_arr1, test_packed_repeated_sint32_arr1);
+ DO_TEST (int32_arr_min_max, test_packed_repeated_sint32_arr_min_max);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_sfixed32 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_sfixed32, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int32_arr0, test_packed_repeated_sfixed32_arr0);
+ DO_TEST (int32_arr1, test_packed_repeated_sfixed32_arr1);
+ DO_TEST (int32_arr_min_max, test_packed_repeated_sfixed32_arr_min_max);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_uint32 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_uint32, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (uint32_roundnumbers, test_packed_repeated_uint32_roundnumbers);
+ DO_TEST (uint32_0_max, test_packed_repeated_uint32_0_max);
+
+#undef DO_TEST
+}
+
+
+
+static void test_packed_repeated_fixed32 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_fixed32, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (uint32_roundnumbers, test_packed_repeated_fixed32_roundnumbers);
+ DO_TEST (uint32_0_max, test_packed_repeated_fixed32_0_max);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_int64 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_int64, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int64_roundnumbers, test_packed_repeated_int64_roundnumbers);
+ DO_TEST (int64_min_max, test_packed_repeated_int64_min_max);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_sint64 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_sint64, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int64_roundnumbers, test_packed_repeated_sint64_roundnumbers);
+ DO_TEST (int64_min_max, test_packed_repeated_sint64_min_max);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_sfixed64 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_sfixed64, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST (int64_roundnumbers, test_packed_repeated_sfixed64_roundnumbers);
+ DO_TEST (int64_min_max, test_packed_repeated_sfixed64_min_max);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_uint64 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_uint64, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(uint64_roundnumbers, test_packed_repeated_uint64_roundnumbers);
+ DO_TEST(uint64_0_1_max, test_packed_repeated_uint64_0_1_max);
+ DO_TEST(uint64_random, test_packed_repeated_uint64_random);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_fixed64 (void)
+{
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_fixed64, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(uint64_roundnumbers, test_packed_repeated_fixed64_roundnumbers);
+ DO_TEST(uint64_0_1_max, test_packed_repeated_fixed64_0_1_max);
+ DO_TEST(uint64_random, test_packed_repeated_fixed64_random);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_float (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_float, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(float_random, test_packed_repeated_float_random);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_double (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_double, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(double_random, test_packed_repeated_double_random);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_boolean (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_boolean, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(boolean_0, test_packed_repeated_boolean_0);
+ DO_TEST(boolean_1, test_packed_repeated_boolean_1);
+ DO_TEST(boolean_random, test_packed_repeated_boolean_random);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_TestEnumSmall (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_enum_small, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(enum_small_0, test_packed_repeated_enum_small_0);
+ DO_TEST(enum_small_1, test_packed_repeated_enum_small_1);
+ DO_TEST(enum_small_random, test_packed_repeated_enum_small_random);
+
+#undef DO_TEST
+}
+
+static void test_packed_repeated_TestEnum (void)
+{
+
+#define DO_TEST(static_array, example_packed_data) \
+ DO_TEST_PACKED_REPEATED(test_enum, , \
+ static_array, example_packed_data, \
+ NUMERIC_EQUALS)
+
+ DO_TEST(enum_0, test_packed_repeated_enum_0);
+ DO_TEST(enum_1, test_packed_repeated_enum_1);
+ DO_TEST(enum_random, test_packed_repeated_enum_random);
+
+#undef DO_TEST
+}
+
+
+static void test_unknown_fields (void)
+{
+ static Foo__EmptyMess mess = FOO__EMPTY_MESS__INIT;
+ static Foo__EmptyMess *mess2;
+ ProtobufCMessageUnknownField fields[2];
+ size_t len; uint8_t *data;
+
+ mess.base.n_unknown_fields = 2;
+ mess.base.unknown_fields = fields;
+
+ fields[0].tag = 5454;
+ fields[0].wire_type = PROTOBUF_C_WIRE_TYPE_VARINT;
+ fields[0].len = 2;
+ fields[0].data = (uint8_t*)"\377\1";
+ fields[1].tag = 5555;
+ fields[1].wire_type = PROTOBUF_C_WIRE_TYPE_32BIT;
+ fields[1].len = 4;
+ fields[1].data = (uint8_t*)"\4\1\0\0";
+ mess2 = test_compare_pack_methods (&mess.base, &len, &data);
+ assert (mess2->base.n_unknown_fields == 2);
+ assert (mess2->base.unknown_fields[0].tag == 5454);
+ assert (mess2->base.unknown_fields[0].wire_type == PROTOBUF_C_WIRE_TYPE_VARINT);
+ assert (mess2->base.unknown_fields[0].len == 2);
+ assert (memcmp (mess2->base.unknown_fields[0].data, fields[0].data, 2) == 0);
+ assert (mess2->base.unknown_fields[1].tag == 5555);
+ assert (mess2->base.unknown_fields[1].wire_type == PROTOBUF_C_WIRE_TYPE_32BIT);
+ assert (mess2->base.unknown_fields[1].len == 4);
+ assert (memcmp (mess2->base.unknown_fields[1].data, fields[1].data, 4) == 0);
+ TEST_VERSUS_STATIC_ARRAY (len, data, test_unknown_fields_0);
+ free (data);
+ foo__empty_mess__free_unpacked (mess2, NULL);
+
+ fields[0].tag = 6666;
+ fields[0].wire_type = PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
+ fields[0].len = 9;
+ fields[0].data = (uint8_t*)"\10xxxxxxxx";
+ fields[1].tag = 7777;
+ fields[1].wire_type = PROTOBUF_C_WIRE_TYPE_64BIT;
+ fields[1].len = 8;
+ fields[1].data = (uint8_t*)"\1\1\1\0\0\0\0\0";
+ mess2 = test_compare_pack_methods (&mess.base, &len, &data);
+ assert (mess2->base.n_unknown_fields == 2);
+ assert (mess2->base.unknown_fields[0].tag == 6666);
+ assert (mess2->base.unknown_fields[0].wire_type == PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED);
+ assert (mess2->base.unknown_fields[0].len == 9);
+ assert (memcmp (mess2->base.unknown_fields[0].data, fields[0].data, 9) == 0);
+ assert (mess2->base.unknown_fields[1].tag == 7777);
+ assert (mess2->base.unknown_fields[1].wire_type == PROTOBUF_C_WIRE_TYPE_64BIT);
+ assert (mess2->base.unknown_fields[1].len == 8);
+ assert (memcmp (mess2->base.unknown_fields[1].data, fields[1].data, 8) == 0);
+ TEST_VERSUS_STATIC_ARRAY (len, data, test_unknown_fields_1);
+ free (data);
+ foo__empty_mess__free_unpacked (mess2, NULL);
+}
+
+static void
+test_enum_descriptor (const ProtobufCEnumDescriptor *desc)
+{
+ unsigned i;
+ for (i = 0; i < desc->n_values; i++)
+ {
+ const ProtobufCEnumValue *sv = desc->values + i;
+ const ProtobufCEnumValue *vv;
+ const ProtobufCEnumValue *vn;
+ vv = protobuf_c_enum_descriptor_get_value (desc, sv->value);
+ assert (sv == vv);
+ vn = protobuf_c_enum_descriptor_get_value_by_name (desc, sv->name);
+ if (sv->name != NULL)
+ assert (sv == vn);
+ }
+ for (i = 0; i < desc->n_value_names; i++)
+ {
+ const char *name = desc->values_by_name[i].name;
+ const ProtobufCEnumValue *v;
+ v = protobuf_c_enum_descriptor_get_value_by_name (desc, name);
+ assert (v != NULL);
+ }
+}
+static void
+test_enum_by_name (const ProtobufCEnumDescriptor *desc,
+ const char *name,
+ int expected_value)
+{
+ const ProtobufCEnumValue *v;
+ v = protobuf_c_enum_descriptor_get_value_by_name (desc, name);
+ assert (v != NULL);
+ assert (v->value == expected_value);
+}
+
+static void
+test_lite_enum (void)
+{
+ const ProtobufCEnumDescriptor *desc = &foo__test_enum_lite__descriptor;
+ const ProtobufCEnumValue *v;
+
+ v = protobuf_c_enum_descriptor_get_value_by_name (desc, "BOO");
+ assert (v == NULL);
+
+ v = protobuf_c_enum_descriptor_get_value (desc, 0);
+ assert (v != NULL);
+ assert (v->value == 0);
+
+ v = protobuf_c_enum_descriptor_get_value (desc, 3);
+ assert (v == NULL);
+}
+
+static void
+test_enum_lookups (void)
+{
+ test_enum_descriptor (&foo__test_enum__descriptor);
+ test_enum_descriptor (&foo__test_enum_small__descriptor);
+ test_enum_descriptor (&foo__test_enum_dup_values__descriptor);
+ test_enum_descriptor (&foo__test_enum_lite__descriptor);
+ test_lite_enum ();
+#define TEST_ENUM_DUP_VALUES(str, shortname) \
+ test_enum_by_name (&foo__test_enum_dup_values__descriptor, \
+ str, FOO__TEST_ENUM_DUP_VALUES__##shortname)
+ TEST_ENUM_DUP_VALUES ("VALUE_A", VALUE_A);
+ TEST_ENUM_DUP_VALUES ("VALUE_B", VALUE_B);
+ TEST_ENUM_DUP_VALUES ("VALUE_C", VALUE_C);
+ TEST_ENUM_DUP_VALUES ("VALUE_D", VALUE_D);
+ TEST_ENUM_DUP_VALUES ("VALUE_E", VALUE_E);
+ TEST_ENUM_DUP_VALUES ("VALUE_F", VALUE_F);
+ TEST_ENUM_DUP_VALUES ("VALUE_AA", VALUE_AA);
+ TEST_ENUM_DUP_VALUES ("VALUE_BB", VALUE_BB);
+#undef TEST_ENUM_DUP_VALUES
+}
+
+static void
+test_message_descriptor (const ProtobufCMessageDescriptor *desc)
+{
+ unsigned i;
+ for (i = 0; i < desc->n_fields; i++)
+ {
+ const ProtobufCFieldDescriptor *f = desc->fields + i;
+ const ProtobufCFieldDescriptor *fv;
+ const ProtobufCFieldDescriptor *fn;
+ fv = protobuf_c_message_descriptor_get_field (desc, f->id);
+ assert (f == fv);
+ fn = protobuf_c_message_descriptor_get_field_by_name (desc, f->name);
+ if (desc->fields_sorted_by_name != NULL)
+ assert (f == fn);
+ }
+}
+static void
+test_message_lookups (void)
+{
+ test_message_descriptor (&foo__test_mess__descriptor);
+ test_message_descriptor (&foo__test_mess_optional__descriptor);
+ test_message_descriptor (&foo__test_mess_required_enum__descriptor);
+ test_message_descriptor (&foo__test_mess_lite__descriptor);
+}
+
+static void
+assert_required_default_values_are_default (Foo__DefaultRequiredValues *mess)
+{
+ assert (mess->v_int32 == -42);
+ assert (mess->v_uint32 == 666);
+ assert (mess->v_int64 == 100000);
+ assert (mess->v_uint64 == 100001);
+ assert (mess->v_float == 2.5);
+ assert (mess->v_double == 4.5);
+ assert (strcmp (mess->v_string, "hi mom\n") == 0);
+ assert (mess->v_bytes.len = /* a */ 1
+ + /* space */ 1
+ + /* NUL */ 1
+ + /* space */ 1
+ + /* "character" */ 9);
+ assert (memcmp (mess->v_bytes.data, "a \0 character", 13) == 0);
+}
+
+
+static void
+test_required_default_values (void)
+{
+ Foo__DefaultRequiredValues mess = FOO__DEFAULT_REQUIRED_VALUES__INIT;
+ Foo__DefaultRequiredValues *mess2;
+ size_t len; uint8_t *data;
+ assert_required_default_values_are_default (&mess);
+ mess2 = test_compare_pack_methods (&mess.base, &len, &data);
+ free (data);
+ assert_required_default_values_are_default (mess2);
+ foo__default_required_values__free_unpacked (mess2, NULL);
+}
+
+static void
+assert_optional_default_values_are_default (Foo__DefaultOptionalValues *mess)
+{
+ assert (!mess->has_v_int32);
+ assert (mess->v_int32 == -42);
+ assert (!mess->has_v_uint32);
+ assert (mess->v_uint32 == 666);
+ assert (!mess->has_v_int64);
+ assert (mess->v_int64 == 100000);
+ assert (!mess->has_v_uint64);
+ assert (mess->v_uint64 == 100001);
+ assert (!mess->has_v_float);
+ assert (mess->v_float == 2.5);
+ assert (!mess->has_v_double);
+ assert (mess->v_double == 4.5);
+ assert (strcmp (mess->v_string, "hi mom\n") == 0);
+ assert (!mess->has_v_bytes);
+ assert (mess->v_bytes.len = /* a */ 1
+ + /* space */ 1
+ + /* NUL */ 1
+ + /* space */ 1
+ + /* "character" */ 9);
+ assert (memcmp (mess->v_bytes.data, "a \0 character", 13) == 0);
+}
+
+static void
+assert_unspecified_default_values_are_correct (Foo__TestMessOptional *mess)
+{
+ assert (!mess->has_test_int32);
+ assert (mess->test_int32 == 0);
+ assert (!mess->has_test_uint32);
+ assert (mess->test_uint32 == 0);
+ assert (!mess->has_test_int64);
+ assert (mess->test_int64 == 0);
+ assert (!mess->has_test_uint64);
+ assert (mess->test_uint64 == 0);
+ assert (!mess->has_test_float);
+ assert (mess->test_float == 0.0);
+ assert (!mess->has_test_double);
+ assert (mess->test_double == 0.0);
+ assert (mess->test_string == NULL);
+ assert (!mess->has_test_bytes);
+ assert (mess->test_bytes.len == 0);
+ assert (mess->test_bytes.data == NULL);
+ assert (!mess->has_test_boolean);
+ assert (!mess->test_boolean);
+ assert (!mess->has_test_enum_small);
+ assert (mess->test_enum_small == FOO__TEST_ENUM_SMALL__NEG_VALUE);
+ assert (!mess->has_test_enum);
+ assert (mess->test_enum == FOO__TEST_ENUM__VALUENEG123456);
+}
+
+static void
+test_optional_default_values (void)
+{
+ Foo__DefaultOptionalValues mess = FOO__DEFAULT_OPTIONAL_VALUES__INIT;
+ Foo__DefaultOptionalValues *mess2;
+ size_t len; uint8_t *data;
+ assert_optional_default_values_are_default (&mess);
+ mess2 = test_compare_pack_methods (&mess.base, &len, &data);
+ assert (len == 0); /* no non-default values */
+ free (data);
+ assert_optional_default_values_are_default (mess2);
+ foo__default_optional_values__free_unpacked (mess2, NULL);
+
+ Foo__TestMessOptional mess3 = FOO__TEST_MESS_OPTIONAL__INIT;
+ assert_unspecified_default_values_are_correct (&mess3);
+}
+
+static void
+assert_optional_lowercase_enum_default_value_is_default (Foo__LowerCase *mess)
+{
+ assert (!mess->has_value);
+ assert (mess->value == 2);
+}
+
+static void
+test_optional_lowercase_enum_default_value (void)
+{
+ Foo__LowerCase mess = FOO__LOWER_CASE__INIT;
+ Foo__LowerCase *mess2;
+ size_t len; uint8_t *data;
+ assert_optional_lowercase_enum_default_value_is_default (&mess);
+ mess2 = test_compare_pack_methods (&mess.base, &len, &data);
+ assert (len == 0); /* no non-default values */
+ free (data);
+ assert_optional_lowercase_enum_default_value_is_default (mess2);
+ foo__lower_case__free_unpacked (mess2, NULL);
+}
+
+static void
+test_field_merge (void)
+{
+ Foo__TestMessOptional msg1 = FOO__TEST_MESS_OPTIONAL__INIT;
+ Foo__SubMess sub1 = FOO__SUB_MESS__INIT;
+ Foo__SubMess__SubSubMess subsub1 = FOO__SUB_MESS__SUB_SUB_MESS__INIT;
+
+ msg1.has_test_int32 = 1;
+ msg1.test_int32 = 12345;
+ msg1.has_test_sint32 = 1;
+ msg1.test_sint32 = -12345;
+ msg1.has_test_int64 = 1;
+ msg1.test_int64 = 232;
+ msg1.test_string = "123";
+ msg1.test_message = &sub1;
+ sub1.has_val1 = 1;
+ sub1.val1 = 4;
+ sub1.has_val2 = 1;
+ sub1.val2 = 5;
+ int32_t arr1[] = {0, 1};
+ sub1.n_rep = 2;
+ sub1.rep = arr1;
+ sub1.sub1 = &subsub1;
+ sub1.sub2 = &subsub1;
+ subsub1.n_rep = 2;
+ subsub1.rep = arr1;
+ subsub1.str1 = "test";
+
+ size_t msg_size = foo__test_mess_optional__get_packed_size (&msg1);
+
+ Foo__TestMessOptional msg2 = FOO__TEST_MESS_OPTIONAL__INIT;
+ Foo__SubMess sub2 = FOO__SUB_MESS__INIT;
+ Foo__SubMess__SubSubMess subsub2 = FOO__SUB_MESS__SUB_SUB_MESS__INIT;
+
+ msg2.has_test_int64 = 1;
+ msg2.test_int64 = 2;
+ msg2.has_test_enum = 1;
+ msg2.test_enum = FOO__TEST_ENUM__VALUE128;
+ msg2.test_string = "456";
+ msg2.test_message = &sub2;
+ sub2.has_val2 = 1;
+ sub2.val2 = 666;
+ int32_t arr2[] = {2, 3, 4};
+ sub2.n_rep = 3;
+ sub2.rep = arr2;
+ sub2.sub1 = &subsub2;
+ subsub2.has_val1 = 1;
+ subsub2.val1 = 1;
+
+ msg_size += foo__test_mess_optional__get_packed_size (&msg2);
+
+ uint8_t *packed_buffer = (uint8_t *)malloc (msg_size);
+
+ size_t packed_size = foo__test_mess_optional__pack (&msg1, packed_buffer);
+ packed_size += foo__test_mess_optional__pack (&msg2, packed_buffer + packed_size);
+
+ assert (packed_size == msg_size);
+
+ Foo__TestMessOptional *merged = foo__test_mess_optional__unpack
+ (NULL, msg_size, packed_buffer);
+
+ assert (merged->has_test_int32 && merged->test_int32 == msg1.test_int32);
+ assert (merged->has_test_sint32 && merged->test_sint32 == msg1.test_sint32);
+ assert (merged->has_test_int64 && merged->test_int64 == msg2.test_int64);
+ assert (merged->has_test_enum && merged->test_enum == msg2.test_enum);
+ assert (strcmp (merged->test_string, msg2.test_string) == 0);
+ assert (merged->test_message->has_val1 && merged->test_message->val1 == sub1.val1);
+ assert (merged->test_message->has_val2 && merged->test_message->val2 == sub2.val2);
+ /* Repeated fields should get concatenated */
+ int32_t merged_arr[] = {0, 1, 2, 3, 4};
+ assert (merged->test_message->n_rep == 5 &&
+ memcmp(merged->test_message->rep, merged_arr, sizeof(merged_arr)) == 0);
+
+ assert (merged->test_message->sub1->val1 == subsub2.val1);
+ assert (memcmp(merged->test_message->sub1->bytes1.data,
+ subsub2.bytes1.data, subsub2.bytes1.len) == 0);
+ assert (strcmp(merged->test_message->sub1->str1, subsub1.str1) == 0);
+ assert (merged->test_message->sub1->n_rep == subsub1.n_rep &&
+ memcmp(merged->test_message->sub1->rep, arr1, sizeof(arr1)) == 0);
+
+ assert (!merged->test_message->sub2->has_val1
+ && merged->test_message->sub2->val1 == subsub1.val1);
+
+ free (packed_buffer);
+ foo__test_mess_optional__free_unpacked (merged, NULL);
+}
+
+static void
+test_submessage_merge (void)
+{
+ Foo__TestMessSubMess *merged;
+ size_t size;
+ uint8_t *packed;
+
+ merged = foo__test_mess_sub_mess__unpack
+ (NULL, sizeof (test_submess_unmerged1), test_submess_unmerged1);
+
+ size = foo__test_mess_sub_mess__get_packed_size(merged);
+ packed = malloc (size);
+ foo__test_mess_sub_mess__pack (merged, packed);
+
+ assert (size == sizeof (test_submess_merged1));
+ assert (memcmp (packed, test_submess_merged1, size) == 0);
+
+ foo__test_mess_sub_mess__free_unpacked (merged, NULL);
+ free (packed);
+
+ merged = foo__test_mess_sub_mess__unpack
+ (NULL, sizeof (test_submess_unmerged2), test_submess_unmerged2);
+
+ size = foo__test_mess_sub_mess__get_packed_size(merged);
+ packed = malloc (size);
+ foo__test_mess_sub_mess__pack (merged, packed);
+
+ assert (size == sizeof (test_submess_merged2));
+ assert (memcmp (packed, test_submess_merged2, size) == 0);
+
+ foo__test_mess_sub_mess__free_unpacked (merged, NULL);
+ free (packed);
+}
+
+static struct alloc_data {
+ uint32_t alloc_count;
+ int32_t allocs_left;
+} test_allocator_data;
+
+static void *test_alloc(void *allocator_data, size_t size)
+{
+ struct alloc_data *ad = allocator_data;
+ void *rv = NULL;
+ if (ad->allocs_left-- > 0)
+ rv = malloc (size);
+ /* fprintf (stderr, "alloc %d = %p\n", size, rv); */
+ if (rv)
+ ad->alloc_count++;
+ return rv;
+}
+
+static void test_free (void *allocator_data, void *data)
+{
+ struct alloc_data *ad = allocator_data;
+ /* fprintf (stderr, "free %p\n", data); */
+ free (data);
+ if (data)
+ ad->alloc_count--;
+}
+
+static ProtobufCAllocator test_allocator = {
+ .alloc = test_alloc,
+ .free = test_free,
+ .allocator_data = &test_allocator_data,
+};
+
+#define SETUP_TEST_ALLOC_BUFFER(pbuf, len) \
+ uint8_t bytes[] = "some bytes", *pbuf; \
+ size_t len, _len2; \
+ Foo__DefaultRequiredValues _req = FOO__DEFAULT_REQUIRED_VALUES__INIT; \
+ Foo__AllocValues _mess = FOO__ALLOC_VALUES__INIT; \
+ _mess.a_string = "some string"; \
+ _mess.r_string = repeated_strings_2; \
+ _mess.n_r_string = sizeof(repeated_strings_2) / sizeof(*repeated_strings_2); \
+ _mess.a_bytes.len = sizeof(bytes); \
+ _mess.a_bytes.data = bytes; \
+ _mess.a_mess = &_req; \
+ len = foo__alloc_values__get_packed_size (&_mess); \
+ pbuf = malloc (len); \
+ assert (pbuf); \
+ _len2 = foo__alloc_values__pack (&_mess, pbuf); \
+ assert (len == _len2);
+
+static void
+test_alloc_graceful_cleanup (uint8_t *packed, size_t len, int good_allocs)
+{
+ Foo__AllocValues *mess;
+ test_allocator_data.alloc_count = 0;
+ test_allocator_data.allocs_left = good_allocs;
+ mess = foo__alloc_values__unpack (&test_allocator, len, packed);
+ assert (test_allocator_data.allocs_left < 0 ? !mess : !!mess);
+ if (mess)
+ foo__alloc_values__free_unpacked (mess, &test_allocator);
+ assert (0 == test_allocator_data.alloc_count);
+}
+
+static void
+test_alloc_free_all (void)
+{
+ SETUP_TEST_ALLOC_BUFFER (packed, len);
+ test_alloc_graceful_cleanup (packed, len, INT32_MAX);
+ free (packed);
+}
+
+/* TODO: test alloc failure for slab, unknown fields */
+static void
+test_alloc_fail (void)
+{
+ int i = 0;
+ SETUP_TEST_ALLOC_BUFFER (packed, len);
+ do test_alloc_graceful_cleanup (packed, len, i++);
+ while (test_allocator_data.allocs_left < 0);
+ free (packed);
+}
+
+static void
+test_free_unpacked_input_check_for_null_message (void)
+{
+ protobuf_c_message_free_unpacked (NULL, NULL);
+}
+
+static void
+test_free_unpacked_input_check_for_null_repeated_field (void)
+{
+ Foo__TestMess *tm = calloc(1, foo__test_mess__descriptor.sizeof_message);
+ foo__test_mess__init(tm);
+
+ tm->n_test_string = 1;
+ tm->test_string = NULL;
+
+ tm->n_test_bytes = 1;
+ tm->test_bytes = NULL;
+
+ tm->n_test_message = 1;
+ tm->test_message = NULL;
+
+ foo__test_mess__free_unpacked (tm, NULL);
+}
+
+/* This test checks that protobuf decoder is capable of detecting special
+ cases of incomplete messages. The message should have at least two required
+ fields field1 and field129 with positions pos1 and pos2 (no matter what the
+ field numbers are), such as (pos1 % 128) == (pos2 % 128). The decoder must
+ return NULL instead of incomplete message with field129 missing. */
+static void test_required_fields_bitmap(void)
+{
+ const uint8_t source[] = {
+ (1 << 3) | PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED,
+ sizeof("hello") - 1,
+ 'h', 'e', 'l', 'l', 'o'
+ };
+ Foo__TestRequiredFieldsBitmap *msg;
+ msg = foo__test_required_fields_bitmap__unpack(NULL, sizeof(source), source);
+ assert (msg == NULL);
+}
+
+static void
+test_field_flags (void)
+{
+ const ProtobufCFieldDescriptor *f;
+ const ProtobufCMessageDescriptor *desc = &foo__test_field_flags__descriptor;
+
+ f = protobuf_c_message_descriptor_get_field_by_name(desc, "no_flags1");
+ assert(f != NULL);
+ assert(!(f->flags & PROTOBUF_C_FIELD_FLAG_PACKED));
+ assert(!(f->flags & PROTOBUF_C_FIELD_FLAG_DEPRECATED));
+
+ f = protobuf_c_message_descriptor_get_field_by_name(desc, "no_flags2");
+ assert(f != NULL);
+ assert(!(f->flags & PROTOBUF_C_FIELD_FLAG_PACKED));
+ assert(!(f->flags & PROTOBUF_C_FIELD_FLAG_DEPRECATED));
+
+ f = protobuf_c_message_descriptor_get_field_by_name(desc, "no_flags3");
+ assert(f != NULL);
+ assert(!(f->flags & PROTOBUF_C_FIELD_FLAG_PACKED));
+ assert(!(f->flags & PROTOBUF_C_FIELD_FLAG_DEPRECATED));
+
+ f = protobuf_c_message_descriptor_get_field_by_name(desc, "packed");
+ assert(f != NULL);
+ assert((f->flags & PROTOBUF_C_FIELD_FLAG_PACKED));
+ assert(!(f->flags & PROTOBUF_C_FIELD_FLAG_DEPRECATED));
+
+ f = protobuf_c_message_descriptor_get_field_by_name(desc, "packed_deprecated");
+ assert(f != NULL);
+ assert((f->flags & PROTOBUF_C_FIELD_FLAG_PACKED));
+ assert((f->flags & PROTOBUF_C_FIELD_FLAG_DEPRECATED));
+}
+
+static void
+test_message_check(void)
+{
+ Foo__TestMessageCheck__SubMessage sm = FOO__TEST_MESSAGE_CHECK__SUB_MESSAGE__INIT;
+ Foo__TestMessageCheck__SubMessage sm2 = FOO__TEST_MESSAGE_CHECK__SUB_MESSAGE__INIT;
+ Foo__TestMessageCheck m = FOO__TEST_MESSAGE_CHECK__INIT;
+ char *null = NULL;
+ char *str = "";
+ Foo__TestMessageCheck__SubMessage *sm_p;
+ ProtobufCBinaryData bd;
+
+ /* test incomplete submessage */
+ assert(0 == protobuf_c_message_check(&sm.base));
+
+ /* test complete submessage */
+ sm.str = str;
+ assert(1 == protobuf_c_message_check(&sm.base));
+
+ /* test just initialized message */
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with required_string not set */
+ m.required_string = NULL;
+ m.required_msg = &sm;
+ m.required_bytes.data = (uint8_t *)str; m.required_bytes.len = 1;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with required_msg not set */
+ m.required_string = str;
+ m.required_msg = NULL;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with required_bytes set incorrectly */
+ m.required_msg = &sm;
+ m.required_bytes.data = NULL; m.required_bytes.len = 1;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with all required fields set */
+ m.required_bytes.data = (uint8_t *)str; m.required_bytes.len = 1;
+ assert(1 == protobuf_c_message_check(&m.base));
+
+ /* test with incomplete required submessage */
+ sm.str = NULL;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with incomplete optional submessage */
+ sm.str = str;
+ m.optional_msg = &sm2;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with complete optional submessage */
+ sm2.str = str;
+ assert(1 == protobuf_c_message_check(&m.base));
+
+ /* test with correct optional bytes */
+ m.has_optional_bytes = 1;
+ assert(1 == protobuf_c_message_check(&m.base));
+
+ /* test with incorrect optional bytes */
+ m.optional_bytes.data = NULL; m.optional_bytes.len = 1;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with correct optional bytes */
+ m.optional_bytes.data = (uint8_t *)str; m.optional_bytes.len = 1;
+ assert(1 == protobuf_c_message_check(&m.base));
+
+ /* test with repeated strings set incorrectly */
+ m.n_repeated_string = 1;
+ m.repeated_string = &null;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with repeated strings set correctly */
+ m.repeated_string = &str;
+ assert(1 == protobuf_c_message_check(&m.base));
+
+ /* test with repeated submessage set incorrectly */
+ sm_p = NULL;
+ m.n_repeated_msg = 1;
+ m.repeated_msg = &sm_p;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with repeated incomplete submessage */
+ sm_p = &sm;
+ sm.str = NULL;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with repeated complete submessage */
+ sm.str = str;
+ assert(1 == protobuf_c_message_check(&m.base));
+
+ /* test with repeated bytes set incorrectly */
+ bd.len = 1;
+ bd.data = NULL;
+ m.n_repeated_bytes = 1;
+ m.repeated_bytes = &bd;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with repeated bytes set correctly */
+ bd.data = (uint8_t *)str;
+ assert(1 == protobuf_c_message_check(&m.base));
+
+ /* test with empty repeated string vector */
+ m.repeated_string = NULL;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with empty repeated bytes vector */
+ m.repeated_string = &str;
+ m.repeated_bytes = NULL;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test with empty repeated submessage vector */
+ m.repeated_bytes = &bd;
+ m.repeated_msg = NULL;
+ assert(0 == protobuf_c_message_check(&m.base));
+
+ /* test all vectors set again */
+ m.repeated_msg = &sm_p;
+ assert(1 == protobuf_c_message_check(&m.base));
+}
+
+static void
+test_message_free_null (void)
+{
+ foo__sub_mess__free_unpacked (NULL, NULL);
+}
+
+/* === simple testing framework === */
+
+typedef void (*TestFunc) (void);
+
+typedef struct {
+ const char *name;
+ TestFunc func;
+} Test;
+
+static Test tests[] =
+{
+ { "small enums", test_enum_small },
+ { "big enums", test_enum_big },
+ { "test field numbers", test_field_numbers },
+
+ { "test required int32", test_required_int32 },
+ { "test required sint32", test_required_sint32 },
+ { "test required sfixed32", test_required_sfixed32 },
+ { "test required int64", test_required_int64 },
+ { "test required sint64", test_required_sint64 },
+ { "test required sfixed64", test_required_sfixed64 },
+ { "test required uint32", test_required_uint32 },
+ { "test required fixed32", test_required_fixed32 },
+ { "test required uint64", test_required_uint64 },
+ { "test required fixed64", test_required_fixed64 },
+ { "test required float", test_required_float },
+ { "test required double", test_required_double },
+ { "test required bool", test_required_bool },
+ { "test required TestEnumSmall", test_required_TestEnumSmall },
+ { "test required TestEnum", test_required_TestEnum },
+ { "test required string", test_required_string },
+ { "test required bytes", test_required_bytes },
+ { "test required SubMess", test_required_SubMess },
+
+ { "test empty optional" ,test_empty_optional },
+ { "test optional int32", test_optional_int32 },
+ { "test optional sint32", test_optional_sint32 },
+ { "test optional sfixed32", test_optional_sfixed32 },
+ { "test optional int64", test_optional_int64 },
+ { "test optional sint64", test_optional_sint64 },
+ { "test optional sfixed64", test_optional_sfixed64 },
+ { "test optional uint32", test_optional_uint32 },
+ { "test optional fixed32", test_optional_fixed32 },
+ { "test optional uint64", test_optional_uint64 },
+ { "test optional fixed64", test_optional_fixed64 },
+ { "test optional float", test_optional_float },
+ { "test optional double", test_optional_double },
+ { "test optional bool", test_optional_bool },
+ { "test optional TestEnumSmall", test_optional_TestEnumSmall },
+ { "test optional TestEnum", test_optional_TestEnum },
+ { "test optional string", test_optional_string },
+ { "test optional bytes", test_optional_bytes },
+ { "test optional SubMess", test_optional_SubMess },
+
+ { "test empty oneof" ,test_empty_oneof },
+ { "test oneof int32", test_oneof_int32 },
+ { "test oneof sint32", test_oneof_sint32 },
+ { "test oneof sfixed32", test_oneof_sfixed32 },
+ { "test oneof int64", test_oneof_int64 },
+ { "test oneof sint64", test_oneof_sint64 },
+ { "test oneof sfixed64", test_oneof_sfixed64 },
+ { "test oneof uint32", test_oneof_uint32 },
+ { "test oneof fixed32", test_oneof_fixed32 },
+ { "test oneof uint64", test_oneof_uint64 },
+ { "test oneof fixed64", test_oneof_fixed64 },
+ { "test oneof float", test_oneof_float },
+ { "test oneof double", test_oneof_double },
+ { "test oneof bool", test_oneof_bool },
+ { "test oneof TestEnumSmall", test_oneof_TestEnumSmall },
+ { "test oneof TestEnum", test_oneof_TestEnum },
+ { "test oneof string", test_oneof_string },
+ { "test oneof bytes", test_oneof_bytes },
+ { "test oneof SubMess", test_oneof_SubMess },
+ { "test merged oneof unpack", test_oneof_merge },
+
+ { "test empty repeated" ,test_empty_repeated },
+ { "test repeated int32" ,test_repeated_int32 },
+ { "test repeated sint32" ,test_repeated_sint32 },
+ { "test repeated sfixed32" ,test_repeated_sfixed32 },
+ { "test repeated uint32", test_repeated_uint32 },
+ { "test repeated int64", test_repeated_int64 },
+ { "test repeated sint64", test_repeated_sint64 },
+ { "test repeated sfixed64", test_repeated_sfixed64 },
+ { "test repeated fixed32", test_repeated_fixed32 },
+ { "test repeated uint64", test_repeated_uint64 },
+ { "test repeated fixed64", test_repeated_fixed64 },
+ { "test repeated float", test_repeated_float },
+ { "test repeated double", test_repeated_double },
+ { "test repeated boolean", test_repeated_boolean },
+ { "test repeated TestEnumSmall", test_repeated_TestEnumSmall },
+ { "test repeated TestEnum", test_repeated_TestEnum },
+ { "test repeated string", test_repeated_string },
+ { "test repeated bytes", test_repeated_bytes },
+ { "test repeated SubMess", test_repeated_SubMess },
+
+ { "test packed repeated int32", test_packed_repeated_int32 },
+ { "test packed repeated sint32", test_packed_repeated_sint32 },
+ { "test packed repeated sfixed32" ,test_packed_repeated_sfixed32 },
+ { "test packed repeated uint32", test_packed_repeated_uint32 },
+ { "test packed repeated int64", test_packed_repeated_int64 },
+ { "test packed repeated sint64", test_packed_repeated_sint64 },
+ { "test packed repeated sfixed64", test_packed_repeated_sfixed64 },
+ { "test packed repeated fixed32", test_packed_repeated_fixed32 },
+ { "test packed repeated uint64", test_packed_repeated_uint64 },
+ { "test packed repeated fixed64", test_packed_repeated_fixed64 },
+ { "test packed repeated float", test_packed_repeated_float },
+ { "test packed repeated double", test_packed_repeated_double },
+ { "test packed repeated boolean", test_packed_repeated_boolean },
+ { "test packed repeated TestEnumSmall", test_packed_repeated_TestEnumSmall },
+ { "test packed repeated TestEnum", test_packed_repeated_TestEnum },
+
+ { "test unknown fields", test_unknown_fields },
+
+ { "test enum lookups", test_enum_lookups },
+ { "test message lookups", test_message_lookups },
+
+ { "test required default values", test_required_default_values },
+ { "test optional default values", test_optional_default_values },
+
+ { "test optional lowercase enum default value", test_optional_lowercase_enum_default_value },
+
+ { "test field merge", test_field_merge },
+ { "test submessage merge", test_submessage_merge },
+
+ { "test free unpacked", test_alloc_free_all },
+ { "test alloc failure", test_alloc_fail },
+
+ { "test free unpacked input check for null message", test_free_unpacked_input_check_for_null_message },
+ { "test free unpacked input check for null repeated field", test_free_unpacked_input_check_for_null_repeated_field },
+
+ { "test required_fields_bitmap", test_required_fields_bitmap },
+
+ { "test field flags", test_field_flags },
+
+ { "test message_check()", test_message_check },
+
+ { "test freeing NULL", test_message_free_null },
+};
+#define n_tests (sizeof(tests)/sizeof(Test))
+
+int main ()
+{
+ unsigned i;
+ for (i = 0; i < n_tests; i++)
+ {
+ fprintf (stderr, "Test: %s... ", tests[i].name);
+ tests[i].func ();
+ fprintf (stderr, " done.\n");
+ }
+ return 0;
+}
generated by cgit v1.3.1 (git 2.54.0) at 2026-06-19 16:34:55 +0000