From 394d57c76529c688368c88b7098a11f78ed03bd6 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Sat, 1 Jan 2005 02:03:50 +0000 Subject: remove old unit test code, and clean up whitespace --- dbus/dbus-marshal-recursive.c | 1882 +++++++---------------------------------- 1 file changed, 284 insertions(+), 1598 deletions(-) (limited to 'dbus') diff --git a/dbus/dbus-marshal-recursive.c b/dbus/dbus-marshal-recursive.c index 6b2338be..b89535e8 100644 --- a/dbus/dbus-marshal-recursive.c +++ b/dbus/dbus-marshal-recursive.c @@ -4,7 +4,7 @@ * Copyright (C) 2004 Red Hat, Inc. * * Licensed under the Academic Free License version 2.1 - * + * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or @@ -14,7 +14,7 @@ * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA @@ -48,7 +48,7 @@ first_type_in_signature (const DBusString *str, int t; t = _dbus_string_get_byte (str, pos); - + if (t == DBUS_STRUCT_BEGIN_CHAR) return DBUS_TYPE_STRUCT; else @@ -81,7 +81,7 @@ reader_init (DBusTypeReader *reader, static void base_reader_recurse (DBusTypeReader *sub, DBusTypeReader *parent) -{ +{ /* point subreader at the same place as parent */ reader_init (sub, parent->byte_order, @@ -99,7 +99,7 @@ struct_types_only_reader_recurse (DBusTypeReader *sub, _dbus_assert (_dbus_string_get_byte (sub->type_str, sub->type_pos) == DBUS_STRUCT_BEGIN_CHAR); - + sub->type_pos += 1; } @@ -108,7 +108,7 @@ struct_reader_recurse (DBusTypeReader *sub, DBusTypeReader *parent) { struct_types_only_reader_recurse (sub, parent); - + /* struct has 8 byte alignment */ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8); } @@ -118,7 +118,7 @@ array_types_only_reader_recurse (DBusTypeReader *sub, DBusTypeReader *parent) { base_reader_recurse (sub, parent); - + /* point type_pos at the array element type */ sub->type_pos += 1; @@ -138,24 +138,24 @@ array_reader_recurse (DBusTypeReader *sub, int alignment; _dbus_assert (!_dbus_type_reader_array_is_empty (parent)); - + array_types_only_reader_recurse (sub, parent); - + sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4); - + _dbus_demarshal_basic_type (sub->value_str, DBUS_TYPE_UINT32, &array_len, sub->byte_order, &sub->value_pos); - + sub->u.array.len = array_len; - + alignment = element_type_get_alignment (sub->type_str, sub->type_pos); - + sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, alignment); - + sub->u.array.start_pos = sub->value_pos; #if RECURSIVE_MARSHAL_TRACE @@ -174,7 +174,7 @@ variant_reader_recurse (DBusTypeReader *sub, int sig_len; _dbus_assert (!_dbus_type_reader_array_is_empty (parent)); - + base_reader_recurse (sub, parent); /* Variant is 1 byte sig length (without nul), signature with nul, @@ -185,9 +185,9 @@ variant_reader_recurse (DBusTypeReader *sub, sub->type_str = sub->value_str; sub->type_pos = sub->value_pos + 1; - + sub->value_pos = sub->type_pos + sig_len + 1; - + sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8); #if RECURSIVE_MARSHAL_TRACE @@ -213,7 +213,7 @@ static int struct_reader_get_current_type (DBusTypeReader *reader) { int t; - + if (reader->finished) t = DBUS_TYPE_INVALID; else @@ -241,16 +241,16 @@ array_reader_get_current_type (DBusTypeReader *reader) { int t; int end_pos; - + /* return the array element type if elements remain, and * TYPE_INVALID otherwise */ - + end_pos = reader->u.array.start_pos + reader->u.array.len; - + _dbus_assert (reader->value_pos <= end_pos); _dbus_assert (reader->value_pos >= reader->u.array.start_pos); - + if (reader->value_pos < end_pos) t = reader->u.array.element_type; else @@ -301,9 +301,9 @@ skip_array_values (int element_type, dbus_uint32_t array_len; int pos; int alignment; - + pos = _DBUS_ALIGN_VALUE (*value_pos, 4); - + _dbus_demarshal_basic_type (value_str, DBUS_TYPE_UINT32, &array_len, @@ -313,7 +313,7 @@ skip_array_values (int element_type, alignment = _dbus_type_get_alignment (element_type); pos = _DBUS_ALIGN_VALUE (pos, alignment); - + *value_pos = pos + array_len; } @@ -327,16 +327,16 @@ base_reader_next (DBusTypeReader *reader, /* Scan forward over the entire container contents */ { DBusTypeReader sub; - + /* Recurse into the struct */ _dbus_type_reader_recurse (reader, &sub); - + /* Skip everything in this subreader */ while (_dbus_type_reader_next (&sub)) { /* nothing */; } - + /* Now we are at the end of this container */ reader->type_pos = sub.type_pos; @@ -344,9 +344,9 @@ base_reader_next (DBusTypeReader *reader, reader->value_pos = sub.value_pos; } break; - + case DBUS_TYPE_ARRAY: - { + { if (!reader->klass->types_only) skip_array_values (first_type_in_signature (reader->type_str, reader->type_pos + 1), @@ -355,13 +355,13 @@ base_reader_next (DBusTypeReader *reader, skip_one_complete_type (reader->type_str, &reader->type_pos); } break; - + default: if (!reader->klass->types_only) _dbus_marshal_skip_basic_type (reader->value_str, current_type, reader->byte_order, &reader->value_pos); - + reader->type_pos += 1; break; } @@ -372,9 +372,9 @@ struct_reader_next (DBusTypeReader *reader, int current_type) { int t; - + base_reader_next (reader, current_type); - + /* for STRUCT containers we return FALSE at the end of the struct, * for INVALID we return FALSE at the end of the signature. * In both cases we arrange for get_current_type() to return INVALID @@ -406,25 +406,25 @@ array_reader_next (DBusTypeReader *reader, { /* Skip one array element */ int end_pos; - + end_pos = reader->u.array.start_pos + reader->u.array.len; - + _dbus_assert (reader->value_pos < end_pos); _dbus_assert (reader->value_pos >= reader->u.array.start_pos); - + if (reader->u.array.element_type == DBUS_TYPE_STRUCT) { DBusTypeReader sub; - + /* Recurse into the struct */ _dbus_type_reader_recurse (reader, &sub); - + /* Skip everything in this element */ while (_dbus_type_reader_next (&sub)) { /* nothing */; } - + /* Now we are at the end of this element */ reader->value_pos = sub.value_pos; } @@ -442,7 +442,7 @@ array_reader_next (DBusTypeReader *reader, } _dbus_assert (reader->value_pos <= end_pos); - + if (reader->value_pos == end_pos) { skip_one_complete_type (reader->type_str, @@ -515,7 +515,7 @@ _dbus_type_reader_init (DBusTypeReader *reader, int value_pos) { reader->klass = &body_reader_class; - + reader_init (reader, byte_order, type_str, type_pos, value_str, value_pos); @@ -532,7 +532,7 @@ _dbus_type_reader_init_types_only (DBusTypeReader *reader, int type_pos) { reader->klass = &body_types_only_reader_class; - + reader_init (reader, DBUS_COMPILER_BYTE_ORDER /* irrelevant */, type_str, type_pos, NULL, _DBUS_INT_MAX /* crashes if we screw up */); @@ -552,13 +552,13 @@ _dbus_type_reader_get_current_type (DBusTypeReader *reader) _dbus_assert (t != DBUS_STRUCT_END_CHAR); _dbus_assert (t != DBUS_STRUCT_BEGIN_CHAR); - + #if 0 _dbus_verbose (" type reader %p current type_pos = %d type = %s\n", reader, reader->type_pos, _dbus_type_to_string (t)); #endif - + return t; } @@ -567,12 +567,12 @@ _dbus_type_reader_array_is_empty (DBusTypeReader *reader) { dbus_uint32_t array_len; int len_pos; - + _dbus_assert (_dbus_type_reader_get_current_type (reader) == DBUS_TYPE_ARRAY); _dbus_assert (!reader->klass->types_only); len_pos = _DBUS_ALIGN_VALUE (reader->value_pos, 4); - + _dbus_demarshal_basic_type (reader->value_str, DBUS_TYPE_UINT32, &array_len, @@ -590,15 +590,15 @@ _dbus_type_reader_read_basic (DBusTypeReader *reader, int next; _dbus_assert (!reader->klass->types_only); - + t = _dbus_type_reader_get_current_type (reader); - + next = reader->value_pos; _dbus_demarshal_basic_type (reader->value_str, t, value, reader->byte_order, &next); - + #if RECURSIVE_MARSHAL_TRACE _dbus_verbose (" type reader %p read basic type_pos = %d value_pos = %d next = %d remaining sig '%s'\n", @@ -613,15 +613,15 @@ _dbus_type_reader_read_array_of_basic (DBusTypeReader *reader, void **array, int *array_len) { - _dbus_assert (!reader->klass->types_only); - + _dbus_assert (!reader->klass->types_only); + } /** * Initialize a new reader pointing to the first type and * corresponding value that's a child of the current container. It's * an error to call this if the current type is a non-container. - * + * * Note that DBusTypeReader traverses values, not types. So if you * have an empty array of array of int, you can't recurse into it. You * can only recurse into each element. @@ -634,7 +634,7 @@ _dbus_type_reader_recurse (DBusTypeReader *reader, DBusTypeReader *sub) { int t; - + t = first_type_in_signature (reader->type_str, reader->type_pos); switch (t) @@ -663,7 +663,7 @@ _dbus_type_reader_recurse (DBusTypeReader *reader, if (t == DBUS_TYPE_INVALID) _dbus_warn ("You can't recurse into an empty array or off the end of a message body\n"); #endif /* DBUS_DISABLE_CHECKS */ - + _dbus_assert_not_reached ("don't yet handle recursing into this type"); } @@ -688,7 +688,7 @@ dbus_bool_t _dbus_type_reader_next (DBusTypeReader *reader) { int t; - + t = _dbus_type_reader_get_current_type (reader); #if RECURSIVE_MARSHAL_TRACE @@ -709,7 +709,7 @@ _dbus_type_reader_next (DBusTypeReader *reader) _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0), _dbus_type_to_string (_dbus_type_reader_get_current_type (reader))); #endif - + return _dbus_type_reader_get_current_type (reader) != DBUS_TYPE_INVALID; } @@ -754,7 +754,7 @@ _dbus_type_writer_write_basic_no_typecode (DBusTypeWriter *writer, int bytes_written; old_value_len = _dbus_string_get_length (writer->value_str); - + if (!_dbus_marshal_basic_type (writer->value_str, writer->value_pos, type, @@ -763,7 +763,7 @@ _dbus_type_writer_write_basic_no_typecode (DBusTypeWriter *writer, return FALSE; bytes_written = _dbus_string_get_length (writer->value_str) - old_value_len; - + writer->value_pos += bytes_written; return TRUE; @@ -782,7 +782,7 @@ _dbus_type_writer_write_basic_no_typecode (DBusTypeWriter *writer, * * If you recurse into the array for "ai", then you must specify * "i" for the element type of the array you recurse into. - * + * * While inside an array at any level, we need to avoid writing to * type_str, since the type only appears once for the whole array, * it does not appear for each array element. @@ -801,7 +801,7 @@ writer_recurse_init_and_check (DBusTypeWriter *writer, writer->type_pos, writer->value_str, writer->value_pos); - + sub->container_type = container_type; if (writer->type_pos_is_expectation || @@ -809,14 +809,14 @@ writer_recurse_init_and_check (DBusTypeWriter *writer, sub->type_pos_is_expectation = TRUE; else sub->type_pos_is_expectation = FALSE; - + #ifndef DBUS_DISABLE_CHECKS if (writer->type_pos_is_expectation) { int expected; expected = first_type_in_signature (writer->type_str, writer->type_pos); - + if (expected != sub->container_type) { _dbus_warn ("Writing an element of type %s, but the expected type here is %s\n", @@ -853,15 +853,15 @@ write_or_verify_typecode (DBusTypeWriter *writer, writer, writer->type_pos, _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0)); #endif - + if (writer->type_pos_is_expectation) { #ifndef DBUS_DISABLE_CHECKS { int expected; - + expected = _dbus_string_get_byte (writer->type_str, writer->type_pos); - + if (expected != typecode) { _dbus_warn ("Array or Variant type requires that type %s be written, but %s was written\n", @@ -893,7 +893,7 @@ write_or_verify_typecode (DBusTypeWriter *writer, writer, writer->type_pos, _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0)); #endif - + return TRUE; } @@ -909,17 +909,17 @@ _dbus_type_writer_recurse_struct (DBusTypeWriter *writer, if (!_dbus_string_alloc_space (sub->type_str, 1)) return FALSE; - + if (!write_or_verify_typecode (sub, DBUS_STRUCT_BEGIN_CHAR)) _dbus_assert_not_reached ("failed to insert struct typecode after prealloc"); - + if (!_dbus_string_insert_bytes (sub->value_str, sub->value_pos, _DBUS_ALIGN_VALUE (sub->value_pos, 8) - sub->value_pos, '\0')) _dbus_assert_not_reached ("should not have failed to insert alignment padding for struct"); sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8); - + return TRUE; } @@ -934,12 +934,12 @@ _dbus_type_writer_recurse_array (DBusTypeWriter *writer, int alignment; int aligned; DBusString str; - + writer_recurse_init_and_check (writer, DBUS_TYPE_ARRAY, sub); _dbus_string_init_const (&element_type_str, element_type); element_type_len = _dbus_string_get_length (&element_type_str); - + #ifndef DBUS_DISABLE_CHECKS if (writer->container_type == DBUS_TYPE_ARRAY) { @@ -951,7 +951,7 @@ _dbus_type_writer_recurse_array (DBusTypeWriter *writer, _dbus_assert_not_reached ("incompatible type for child array"); } } -#endif /* DBUS_DISABLE_CHECKS */ +#endif /* DBUS_DISABLE_CHECKS */ /* 4 bytes for the array length and 4 bytes possible padding */ if (!_dbus_string_alloc_space (sub->value_str, 8)) @@ -965,7 +965,7 @@ _dbus_type_writer_recurse_array (DBusTypeWriter *writer, if (!writer->type_pos_is_expectation) { /* sub is a toplevel/outermost array so we need to write the type data */ - + /* alloc space for array typecode, element signature, possible 7 * bytes of padding */ @@ -976,7 +976,7 @@ _dbus_type_writer_recurse_array (DBusTypeWriter *writer, writer->type_pos, DBUS_TYPE_ARRAY)) _dbus_assert_not_reached ("failed to insert array typecode after prealloc"); - + if (!_dbus_string_copy (&element_type_str, 0, sub->type_str, sub->u.array.element_type_pos)) _dbus_assert_not_reached ("should not have failed to insert array element typecodes"); @@ -989,14 +989,14 @@ _dbus_type_writer_recurse_array (DBusTypeWriter *writer, writer->type_pos += 1 + element_type_len; else _dbus_assert (writer->type_pos_is_expectation); /* because it's an array */ - + /* Write the length */ sub->u.array.len_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4); if (!_dbus_type_writer_write_basic_no_typecode (sub, DBUS_TYPE_UINT32, &value)) _dbus_assert_not_reached ("should not have failed to insert array len"); - + _dbus_assert (sub->u.array.len_pos == sub->value_pos - 4); /* Write alignment padding for array elements */ @@ -1011,7 +1011,7 @@ _dbus_type_writer_recurse_array (DBusTypeWriter *writer, aligned - sub->value_pos, '\0')) _dbus_assert_not_reached ("should not have failed to insert alignment padding"); - + sub->value_pos = aligned; } sub->u.array.start_pos = sub->value_pos; @@ -1023,7 +1023,7 @@ _dbus_type_writer_recurse_array (DBusTypeWriter *writer, _dbus_verbose (" type writer %p recurse array done remaining sig '%s'\n", sub, _dbus_string_get_const_data_len (sub->type_str, sub->type_pos, 0)); #endif - + return TRUE; } @@ -1049,7 +1049,7 @@ _dbus_type_writer_recurse_array (DBusTypeWriter *writer, * string is the same string as the value string. Which means * inserting to the type string will move the value_pos; and it means * that inserting to the type string could break type alignment. - * + * * This type alignment issue is why the body of the variant is always * 8-aligned. Then we know that re-8-aligning the start of the body * will always correctly align the full contents of the variant type. @@ -1061,13 +1061,13 @@ _dbus_type_writer_recurse_variant (DBusTypeWriter *writer, { int contained_type_len; DBusString contained_type_str; - + writer_recurse_init_and_check (writer, DBUS_TYPE_VARIANT, sub); _dbus_string_init_const (&contained_type_str, contained_type); - + contained_type_len = _dbus_string_get_length (&contained_type_str); - + /* Allocate space for the worst case, which is 1 byte sig * length, nul byte at end of sig, and 7 bytes padding to * 8-boundary. @@ -1089,7 +1089,7 @@ _dbus_type_writer_recurse_variant (DBusTypeWriter *writer, /* Here we switch over to the expected type sig we're about to write */ sub->type_str = sub->value_str; sub->type_pos = sub->value_pos; - + if (!_dbus_string_copy (&contained_type_str, 0, sub->value_str, sub->value_pos)) _dbus_assert_not_reached ("should not have failed to insert variant type sig"); @@ -1102,14 +1102,14 @@ _dbus_type_writer_recurse_variant (DBusTypeWriter *writer, _dbus_assert_not_reached ("should not have failed to insert variant type nul termination"); sub->value_pos += 1; - + if (!_dbus_string_insert_bytes (sub->value_str, sub->value_pos, _DBUS_ALIGN_VALUE (sub->value_pos, 8) - sub->value_pos, '\0')) _dbus_assert_not_reached ("should not have failed to insert alignment padding for variant body"); sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8); - + return TRUE; } @@ -1132,7 +1132,7 @@ _dbus_type_writer_unrecurse (DBusTypeWriter *writer, sub->type_pos_is_expectation, _dbus_type_to_string (sub->container_type)); #endif - + if (sub->container_type == DBUS_TYPE_STRUCT) { if (!write_or_verify_typecode (sub, DBUS_STRUCT_END_CHAR)) @@ -1158,12 +1158,12 @@ _dbus_type_writer_unrecurse (DBusTypeWriter *writer, * * Cases !writer->type_pos_is_expectation: * (in these cases we want to update to the new insertion point) - * + * * - if we recursed into a STRUCT then we didn't know in advance * what the types in the struct would be; so we have to fill in * that information now. * writer->type_pos = sub->type_pos - * + * * - if we recursed into anything else, we knew the full array * type, or knew the single typecode marking VARIANT, so * writer->type_pos is already correct. @@ -1175,7 +1175,7 @@ _dbus_type_writer_unrecurse (DBusTypeWriter *writer, * * Cases where writer->type_pos_is_expectation: * (in these cases we want to update to next expected type to write) - * + * * - we recursed from STRUCT into STRUCT and we didn't increment * type_pos in the parent just to stay consistent with the * !writer->type_pos_is_expectation case (though we could @@ -1185,7 +1185,7 @@ _dbus_type_writer_unrecurse (DBusTypeWriter *writer, * - we recursed from STRUCT into ARRAY or VARIANT and type_pos * for parent should have been incremented already * writer->type_pos should remain as-is - * + * * - we recursed from ARRAY into a sub-element, so type_pos in the * parent is the element type and should remain the element type * for the benefit of the next child element @@ -1203,7 +1203,7 @@ _dbus_type_writer_unrecurse (DBusTypeWriter *writer, /* Advance the parent to the next struct field */ writer->type_pos = sub->type_pos; } - + writer->value_pos = sub->value_pos; #if RECURSIVE_MARSHAL_TRACE @@ -1211,7 +1211,7 @@ _dbus_type_writer_unrecurse (DBusTypeWriter *writer, writer, writer->type_pos, writer->value_pos, _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0)); #endif - + return TRUE; } @@ -1221,7 +1221,7 @@ _dbus_type_writer_write_basic (DBusTypeWriter *writer, const void *value) { dbus_bool_t retval; - + /* First ensure that our type realloc will succeed */ if (!_dbus_string_alloc_space (writer->type_str, 1)) return FALSE; @@ -1230,18 +1230,18 @@ _dbus_type_writer_write_basic (DBusTypeWriter *writer, if (!_dbus_type_writer_write_basic_no_typecode (writer, type, value)) goto out; - + if (!write_or_verify_typecode (writer, type)) _dbus_assert_not_reached ("failed to write typecode after prealloc"); - + retval = TRUE; - + out: #if RECURSIVE_MARSHAL_TRACE _dbus_verbose (" type writer %p basic type_pos = %d value_pos = %d is_expectation = %d\n", writer, writer->type_pos, writer->value_pos, writer->type_pos_is_expectation); #endif - + return retval; } @@ -1286,7 +1286,7 @@ data_block_init (DataBlock *block) _dbus_string_free (&block->signature); return FALSE; } - + return TRUE; } @@ -1310,11 +1310,11 @@ data_block_restore (DataBlock *block, DataBlockState *state) { /* These set_length should be shortening things so should always work */ - + if (!_dbus_string_set_length (&block->signature, state->saved_sig_len)) _dbus_assert_not_reached ("could not restore signature length"); - + if (!_dbus_string_set_length (&block->body, state->saved_body_len)) _dbus_assert_not_reached ("could not restore body length"); @@ -1332,7 +1332,7 @@ data_block_init_reader_writer (DataBlock *block, _dbus_string_get_length (&block->signature), &block->body, _dbus_string_get_length (&block->body)); - + _dbus_type_writer_init (writer, byte_order, &block->signature, @@ -1350,14 +1350,14 @@ real_check_expected_type (DBusTypeReader *reader, int t; t = _dbus_type_reader_get_current_type (reader); - + if (t != expected) { _dbus_warn ("Read type %s while expecting %s at %s line %d\n", _dbus_type_to_string (t), _dbus_type_to_string (expected), funcname, line); - + exit (1); } } @@ -1383,1429 +1383,126 @@ real_check_expected_type (DBusTypeReader *reader, #define SAMPLE_INT32 12345678 #define SAMPLE_INT32_ALTERNATE 53781429 -static dbus_bool_t -write_int32 (DataBlock *block, - DBusTypeWriter *writer) -{ - dbus_int32_t v = SAMPLE_INT32; - return _dbus_type_writer_write_basic (writer, - DBUS_TYPE_INT32, - &v); -} +typedef struct TestTypeNode TestTypeNode; +typedef struct TestTypeNodeClass TestTypeNodeClass; +typedef struct TestTypeNodeContainer TestTypeNodeContainer; +typedef struct TestTypeNodeContainerClass TestTypeNodeContainerClass; -static dbus_bool_t -read_int32 (DataBlock *block, - DBusTypeReader *reader) +struct TestTypeNode { - dbus_int32_t v; - - check_expected_type (reader, DBUS_TYPE_INT32); - - _dbus_type_reader_read_basic (reader, - (dbus_int32_t*) &v); - - _dbus_assert (v == SAMPLE_INT32); - - return TRUE; -} + const TestTypeNodeClass *klass; +}; -static dbus_bool_t -write_struct_of_int32 (DataBlock *block, - DBusTypeWriter *writer) +struct TestTypeNodeContainer { - dbus_int32_t v; - DataBlockState saved; - DBusTypeWriter sub; + TestTypeNode base; + DBusList *children; +}; - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_struct (writer, - &sub)) - return FALSE; +struct TestTypeNodeClass +{ + int typecode; - v = SAMPLE_INT32; - if (!_dbus_type_writer_write_basic (&sub, - DBUS_TYPE_INT32, - &v)) - { - data_block_restore (block, &saved); - return FALSE; - } + int instance_size; - v = SAMPLE_INT32_ALTERNATE; - if (!_dbus_type_writer_write_basic (&sub, - DBUS_TYPE_INT32, - &v)) - { - data_block_restore (block, &saved); - return FALSE; - } + dbus_bool_t (* construct) (TestTypeNode *node); + void (* destroy) (TestTypeNode *node); - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} + dbus_bool_t (* write_value) (TestTypeNode *node, + DataBlock *block, + DBusTypeWriter *writer, + int seed); + dbus_bool_t (* read_value) (TestTypeNode *node, + DataBlock *block, + DBusTypeReader *reader, + int seed); + dbus_bool_t (* build_signature) (TestTypeNode *node, + DBusString *str); +}; -static dbus_bool_t -read_struct_of_int32 (DataBlock *block, - DBusTypeReader *reader) +struct TestTypeNodeContainerClass { - dbus_int32_t v; - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_STRUCT); - - _dbus_type_reader_recurse (reader, &sub); + TestTypeNodeClass base; +}; - check_expected_type (&sub, DBUS_TYPE_INT32); - - _dbus_type_reader_read_basic (&sub, - (dbus_int32_t*) &v); +static dbus_bool_t int32_write_value (TestTypeNode *node, + DataBlock *block, + DBusTypeWriter *writer, + int seed); +static dbus_bool_t int32_read_value (TestTypeNode *node, + DataBlock *block, + DBusTypeReader *reader, + int seed); +static dbus_bool_t struct_1_write_value (TestTypeNode *node, + DataBlock *block, + DBusTypeWriter *writer, + int seed); +static dbus_bool_t struct_1_read_value (TestTypeNode *node, + DataBlock *block, + DBusTypeReader *reader, + int seed); +static dbus_bool_t struct_1_build_signature (TestTypeNode *node, + DBusString *str); +static dbus_bool_t struct_2_write_value (TestTypeNode *node, + DataBlock *block, + DBusTypeWriter *writer, + int seed); +static dbus_bool_t struct_2_read_value (TestTypeNode *node, + DataBlock *block, + DBusTypeReader *reader, + int seed); +static dbus_bool_t struct_2_build_signature (TestTypeNode *node, + DBusString *str); +static dbus_bool_t array_build_signature (TestTypeNode *node, + DBusString *str); +static dbus_bool_t array_1_write_value (TestTypeNode *node, + DataBlock *block, + DBusTypeWriter *writer, + int seed); +static dbus_bool_t array_1_read_value (TestTypeNode *node, + DataBlock *block, + DBusTypeReader *reader, + int seed); +static dbus_bool_t array_0_write_value (TestTypeNode *node, + DataBlock *block, + DBusTypeWriter *writer, + int seed); +static dbus_bool_t array_0_read_value (TestTypeNode *node, + DataBlock *block, + DBusTypeReader *reader, + int seed); +static dbus_bool_t array_2_write_value (TestTypeNode *node, + DataBlock *block, + DBusTypeWriter *writer, + int seed); +static dbus_bool_t array_2_read_value (TestTypeNode *node, + DataBlock *block, + DBusTypeReader *reader, + int seed); +static void container_destroy (TestTypeNode *node); - _dbus_assert (v == SAMPLE_INT32); - NEXT_EXPECTING_TRUE (&sub); - check_expected_type (&sub, DBUS_TYPE_INT32); - - _dbus_type_reader_read_basic (&sub, - (dbus_int32_t*) &v); - _dbus_assert (v == SAMPLE_INT32_ALTERNATE); +static const TestTypeNodeClass int32_class = { + DBUS_TYPE_INT32, + sizeof (TestTypeNode), + NULL, + NULL, + int32_write_value, + int32_read_value, + NULL +}; - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - -static dbus_bool_t -write_struct_of_structs (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_struct (writer, - &sub)) - return FALSE; - - if (!write_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - if (!write_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - if (!write_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_struct_of_structs (DataBlock *block, - DBusTypeReader *reader) -{ - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_STRUCT); - - _dbus_type_reader_recurse (reader, &sub); - - if (!read_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - -static dbus_bool_t -write_struct_of_structs_of_structs (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_struct (writer, - &sub)) - return FALSE; - - if (!write_struct_of_structs (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - if (!write_struct_of_structs (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_struct_of_structs_of_structs (DataBlock *block, - DBusTypeReader *reader) -{ - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_STRUCT); - - _dbus_type_reader_recurse (reader, &sub); - - if (!read_struct_of_structs (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_struct_of_structs (block, &sub)) - return FALSE; - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - -static dbus_bool_t -write_array_of_int32 (DataBlock *block, - DBusTypeWriter *writer) -{ - dbus_int32_t v; - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_array (writer, - DBUS_TYPE_INT32_AS_STRING, - &sub)) - return FALSE; - - v = SAMPLE_INT32_ALTERNATE; - if (!_dbus_type_writer_write_basic (&sub, - DBUS_TYPE_INT32, - &v)) - { - data_block_restore (block, &saved); - return FALSE; - } - - v = SAMPLE_INT32; - if (!_dbus_type_writer_write_basic (&sub, - DBUS_TYPE_INT32, - &v)) - { - data_block_restore (block, &saved); - return FALSE; - } - - v = SAMPLE_INT32; - if (!_dbus_type_writer_write_basic (&sub, - DBUS_TYPE_INT32, - &v)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_array_of_int32 (DataBlock *block, - DBusTypeReader *reader) -{ - dbus_int32_t v; - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_ARRAY); - - _dbus_type_reader_recurse (reader, &sub); - - check_expected_type (&sub, DBUS_TYPE_INT32); - - _dbus_type_reader_read_basic (&sub, - (dbus_int32_t*) &v); - - _dbus_assert (v == SAMPLE_INT32_ALTERNATE); - - NEXT_EXPECTING_TRUE (&sub); - check_expected_type (&sub, DBUS_TYPE_INT32); - - _dbus_type_reader_read_basic (&sub, - (dbus_int32_t*) &v); - - _dbus_assert (v == SAMPLE_INT32); - - NEXT_EXPECTING_TRUE (&sub); - check_expected_type (&sub, DBUS_TYPE_INT32); - - _dbus_type_reader_read_basic (&sub, - (dbus_int32_t*) &v); - - _dbus_assert (v == SAMPLE_INT32); - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - - -static dbus_bool_t -write_array_of_int32_empty (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_array (writer, - DBUS_TYPE_INT32_AS_STRING, - &sub)) - return FALSE; - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_array_of_int32_empty (DataBlock *block, - DBusTypeReader *reader) -{ - check_expected_type (reader, DBUS_TYPE_ARRAY); - - /* We are iterating over values not types. Thus we can't recurse - * into the array - */ - _dbus_assert (_dbus_type_reader_array_is_empty (reader)); - - return TRUE; -} - -static dbus_bool_t -write_array_of_array_of_int32 (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_array (writer, - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT32_AS_STRING, - &sub)) - return FALSE; - - if (!write_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_array_of_int32_empty (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_array_of_array_of_int32 (DataBlock *block, - DBusTypeReader *reader) -{ - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_ARRAY); - - _dbus_type_reader_recurse (reader, &sub); - - if (!read_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_array_of_int32_empty (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - - -static dbus_bool_t -write_array_of_array_of_int32_empty (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_array (writer, - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT32_AS_STRING, - &sub)) - return FALSE; - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_array_of_array_of_int32_empty (DataBlock *block, - DBusTypeReader *reader) -{ - check_expected_type (reader, DBUS_TYPE_ARRAY); - - /* We are iterating over values, not types. Thus - * we can't recurse in here. - */ - - _dbus_assert (_dbus_type_reader_array_is_empty (reader)); - - return TRUE; -} - -static dbus_bool_t -write_array_of_array_of_array_of_int32 (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_array (writer, - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT32_AS_STRING, - &sub)) - return FALSE; - - if (!write_array_of_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_array_of_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_array_of_array_of_int32_empty (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_array_of_array_of_array_of_int32 (DataBlock *block, - DBusTypeReader *reader) -{ - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_ARRAY); - - _dbus_type_reader_recurse (reader, &sub); - - if (!read_array_of_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_array_of_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_array_of_array_of_int32_empty (block, &sub)) - return FALSE; - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - -static dbus_bool_t -write_struct_of_array_of_int32 (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_struct (writer, - &sub)) - return FALSE; - - if (!write_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_array_of_int32_empty (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_struct_of_array_of_int32 (DataBlock *block, - DBusTypeReader *reader) -{ - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_STRUCT); - - _dbus_type_reader_recurse (reader, &sub); - - check_expected_type (&sub, DBUS_TYPE_ARRAY); - - if (!read_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_array_of_int32_empty (block, &sub)) - return FALSE; - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - -static dbus_bool_t -write_struct_of_struct_of_array_of_int32 (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_struct (writer, - &sub)) - return FALSE; - - if (!write_struct_of_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - if (!write_struct_of_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - if (!write_struct_of_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_struct_of_struct_of_array_of_int32 (DataBlock *block, - DBusTypeReader *reader) -{ - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_STRUCT); - - _dbus_type_reader_recurse (reader, &sub); - - if (!read_struct_of_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_struct_of_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_struct_of_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - -static dbus_bool_t -write_array_of_struct_of_int32 (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_array (writer, - DBUS_STRUCT_BEGIN_CHAR_AS_STRING - DBUS_TYPE_INT32_AS_STRING - DBUS_TYPE_INT32_AS_STRING - DBUS_STRUCT_END_CHAR_AS_STRING, - &sub)) - return FALSE; - - if (!write_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_array_of_struct_of_int32 (DataBlock *block, - DBusTypeReader *reader) -{ - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_ARRAY); - - _dbus_type_reader_recurse (reader, &sub); - - check_expected_type (&sub, DBUS_TYPE_STRUCT); - - if (!read_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - - if (!read_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - - if (!read_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - - -static dbus_bool_t -write_array_of_array_of_struct_of_int32 (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_array (writer, - DBUS_TYPE_ARRAY_AS_STRING - DBUS_STRUCT_BEGIN_CHAR_AS_STRING - DBUS_TYPE_INT32_AS_STRING - DBUS_TYPE_INT32_AS_STRING - DBUS_STRUCT_END_CHAR_AS_STRING, - &sub)) - return FALSE; - - if (!write_array_of_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_array_of_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_array_of_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_array_of_array_of_struct_of_int32 (DataBlock *block, - DBusTypeReader *reader) -{ - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_ARRAY); - - _dbus_type_reader_recurse (reader, &sub); - - check_expected_type (&sub, DBUS_TYPE_ARRAY); - - if (!read_array_of_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - - if (!read_array_of_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - - if (!read_array_of_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - -static dbus_bool_t -write_struct_of_array_of_struct_of_int32 (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_struct (writer, - &sub)) - return FALSE; - - if (!write_array_of_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - if (!write_array_of_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - if (!write_array_of_struct_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_struct_of_array_of_struct_of_int32 (DataBlock *block, - DBusTypeReader *reader) -{ - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_STRUCT); - - _dbus_type_reader_recurse (reader, &sub); - - if (!read_array_of_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_array_of_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - if (!read_array_of_struct_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - -static dbus_bool_t -write_array_of_struct_of_array_of_int32 (DataBlock *block, - DBusTypeWriter *writer) -{ - DataBlockState saved; - DBusTypeWriter sub; - - data_block_save (block, &saved); - - if (!_dbus_type_writer_recurse_array (writer, - DBUS_STRUCT_BEGIN_CHAR_AS_STRING - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT32_AS_STRING - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT32_AS_STRING - DBUS_STRUCT_END_CHAR_AS_STRING, - &sub)) - return FALSE; - - if (!write_struct_of_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_struct_of_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!write_struct_of_array_of_int32 (block, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - if (!_dbus_type_writer_unrecurse (writer, &sub)) - { - data_block_restore (block, &saved); - return FALSE; - } - - return TRUE; -} - -static dbus_bool_t -read_array_of_struct_of_array_of_int32 (DataBlock *block, - DBusTypeReader *reader) -{ - DBusTypeReader sub; - - check_expected_type (reader, DBUS_TYPE_ARRAY); - - _dbus_type_reader_recurse (reader, &sub); - - check_expected_type (&sub, DBUS_TYPE_STRUCT); - - if (!read_struct_of_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - - if (!read_struct_of_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_TRUE (&sub); - - if (!read_struct_of_array_of_int32 (block, &sub)) - return FALSE; - - NEXT_EXPECTING_FALSE (&sub); - - return TRUE; -} - -typedef enum { - ITEM_INVALID = -1, - - ITEM_INT32 = 0, - - ITEM_STRUCT_OF_INT32, - ITEM_STRUCT_OF_STRUCTS, - ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, - - ITEM_ARRAY_OF_INT32, - ITEM_ARRAY_OF_INT32_EMPTY, - ITEM_ARRAY_OF_ARRAY_OF_INT32, - ITEM_ARRAY_OF_ARRAY_OF_INT32_EMPTY, - ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, - - ITEM_STRUCT_OF_ARRAY_OF_INT32, - ITEM_STRUCT_OF_STRUCT_OF_ARRAY_OF_INT32, - - ITEM_ARRAY_OF_STRUCT_OF_INT32, - ITEM_ARRAY_OF_ARRAY_OF_STRUCT_OF_INT32, - - ITEM_STRUCT_OF_ARRAY_OF_STRUCT_OF_INT32, - ITEM_ARRAY_OF_STRUCT_OF_ARRAY_OF_INT32, - - ITEM_LAST -} WhichItem; - - -typedef dbus_bool_t (* WriteItemFunc) (DataBlock *block, - DBusTypeWriter *writer); -typedef dbus_bool_t (* ReadItemFunc) (DataBlock *block, - DBusTypeReader *reader); - -typedef struct -{ - const char *desc; - WhichItem which; - WriteItemFunc write_item_func; - ReadItemFunc read_item_func; -} CheckMarshalItem; - -static CheckMarshalItem items[] = { - { "int32", - ITEM_INT32, write_int32, read_int32 }, - { "struct with two int32", - ITEM_STRUCT_OF_INT32, write_struct_of_int32, read_struct_of_int32 }, - { "struct with three structs of two int32", - ITEM_STRUCT_OF_STRUCTS, write_struct_of_structs, read_struct_of_structs }, - { "struct of two structs of three structs of two int32", - ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, - write_struct_of_structs_of_structs, - read_struct_of_structs_of_structs }, - { "array of int32", - ITEM_ARRAY_OF_INT32, write_array_of_int32, read_array_of_int32 }, - { "empty array of int32", - ITEM_ARRAY_OF_INT32_EMPTY, write_array_of_int32_empty, read_array_of_int32_empty }, - { "array of array of int32", - ITEM_ARRAY_OF_ARRAY_OF_INT32, - write_array_of_array_of_int32, read_array_of_array_of_int32 }, - { "empty array of array of int32", - ITEM_ARRAY_OF_ARRAY_OF_INT32_EMPTY, - write_array_of_array_of_int32_empty, read_array_of_array_of_int32_empty }, - { "array of array of array of int32", - ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, - write_array_of_array_of_array_of_int32, read_array_of_array_of_array_of_int32 }, - { "struct of array of int32", - ITEM_STRUCT_OF_ARRAY_OF_INT32, write_struct_of_array_of_int32, read_struct_of_array_of_int32 }, - { "struct of struct of array of int32", - ITEM_STRUCT_OF_STRUCT_OF_ARRAY_OF_INT32, - write_struct_of_struct_of_array_of_int32, read_struct_of_struct_of_array_of_int32 }, - { "array of struct of int32", - ITEM_ARRAY_OF_STRUCT_OF_INT32, write_array_of_struct_of_int32, read_array_of_struct_of_int32 }, - { "array of array of struct of int32", - ITEM_ARRAY_OF_ARRAY_OF_STRUCT_OF_INT32, - write_array_of_array_of_struct_of_int32, read_array_of_array_of_struct_of_int32 }, - - { "struct of array of struct of int32", - ITEM_STRUCT_OF_ARRAY_OF_STRUCT_OF_INT32, - write_struct_of_array_of_struct_of_int32, read_struct_of_array_of_struct_of_int32 }, - { "array of struct of array of int32", - ITEM_ARRAY_OF_STRUCT_OF_ARRAY_OF_INT32, - write_array_of_struct_of_array_of_int32, read_array_of_struct_of_array_of_int32 }, -}; - -typedef struct -{ - /* Array of items from the above items[]; -1 terminated */ - int items[20]; -} TestRun; - -static TestRun runs[] = { - { { ITEM_INVALID } }, - - /* INT32 */ - { { ITEM_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_INT32, ITEM_INT32, ITEM_INT32, ITEM_INT32, ITEM_INVALID } }, - - /* STRUCT_OF_INT32 */ - { { ITEM_STRUCT_OF_INT32, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_INT32, ITEM_STRUCT_OF_INT32, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_INT32, ITEM_INT32, ITEM_STRUCT_OF_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_STRUCT_OF_INT32, ITEM_INT32, ITEM_STRUCT_OF_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_STRUCT_OF_INT32, ITEM_INT32, ITEM_INT32, ITEM_INT32, ITEM_STRUCT_OF_INT32, ITEM_INVALID } }, - - /* STRUCT_OF_STRUCTS */ - { { ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } }, - - /* STRUCT_OF_STRUCTS_OF_STRUCTS */ - { { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - - /* ARRAY_OF_INT32 */ - { { ITEM_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } }, - - /* ARRAY_OF_ARRAY_OF_INT32 */ - { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - - /* ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32 */ - { { ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - - /* STRUCT_OF_ARRAY_OF_INT32 */ - { { ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - - /* STRUCT_OF_STRUCT_OF_ARRAY_OF_INT32 */ - { { ITEM_STRUCT_OF_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - - /* ARRAY_OF_STRUCT_OF_INT32 */ - { { ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } }, - { { ITEM_STRUCT_OF_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } }, - { { ITEM_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } }, - { { ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } }, - - /* ARRAY_OF_ARRAY_OF_STRUCT_OF_INT32 */ - { { ITEM_ARRAY_OF_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } }, - - /* STRUCT_OF_ARRAY_OF_STRUCT_OF_INT32 */ - { { ITEM_STRUCT_OF_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } }, - - /* ARRAY_OF_STRUCT_OF_ARRAY_OF_INT32 */ - { { ITEM_ARRAY_OF_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } }, - -}; - -static dbus_bool_t -perform_one_run (DataBlock *block, - int byte_order, - TestRun *run) -{ - DBusTypeReader reader; - DBusTypeWriter writer; - int i; - DataBlockState saved; - dbus_bool_t retval; - - retval = FALSE; - - { - _dbus_verbose ("run byteorder %s items ", - byte_order == DBUS_LITTLE_ENDIAN ? "little" : "big"); - i = 0; - while (run->items[i] != ITEM_INVALID) - { - CheckMarshalItem *item = &items[run->items[i]]; - - _dbus_verbose ("%s ", item->desc); - ++i; - } - _dbus_verbose (" = %d items\n", i); - } - - data_block_save (block, &saved); - - data_block_init_reader_writer (block, - byte_order, - &reader, &writer); - - i = 0; - while (run->items[i] != ITEM_INVALID) - { - CheckMarshalItem *item = &items[run->items[i]]; - - _dbus_verbose (">>writing %s\n", item->desc); - - if (!(* item->write_item_func) (block, &writer)) - goto out; - ++i; - } - - i = 0; - while (run->items[i] != ITEM_INVALID) - { - CheckMarshalItem *item = &items[run->items[i]]; - - _dbus_verbose (">>data for reading %s\n", item->desc); - - _dbus_verbose_bytes_of_string (reader.type_str, 0, - _dbus_string_get_length (reader.type_str)); - _dbus_verbose_bytes_of_string (reader.value_str, 0, - _dbus_string_get_length (reader.value_str)); - - _dbus_verbose (">>reading %s\n", item->desc); - - if (!(* item->read_item_func) (block, &reader)) - goto out; - - _dbus_type_reader_next (&reader); - - ++i; - } - - retval = TRUE; - - out: - data_block_restore (block, &saved); - return retval; -} - -static dbus_bool_t -perform_all_runs (int byte_order, - int initial_offset) -{ - int i; - DataBlock block; - dbus_bool_t retval; - - retval = FALSE; - - if (!data_block_init (&block)) - return FALSE; - - if (!_dbus_string_lengthen (&block.signature, initial_offset)) - goto out; - - if (!_dbus_string_lengthen (&block.body, initial_offset)) - goto out; - - i = 0; - while (i < _DBUS_N_ELEMENTS (runs)) - { - if (!perform_one_run (&block, byte_order, &runs[i])) - goto out; - - ++i; - } - - retval = TRUE; - - out: - data_block_free (&block); - - return retval; -} - -static dbus_bool_t -perform_all_items (int byte_order, - int initial_offset) -{ - int i; - DataBlock block; - dbus_bool_t retval; - TestRun run; - - retval = FALSE; - - if (!data_block_init (&block)) - return FALSE; - - - if (!_dbus_string_lengthen (&block.signature, initial_offset)) - goto out; - - if (!_dbus_string_lengthen (&block.body, initial_offset)) - goto out; - - /* Create a run containing all the items */ - i = 0; - while (i < _DBUS_N_ELEMENTS (items)) - { - _dbus_assert (i == items[i].which); - - run.items[i] = items[i].which; - - ++i; - } - - run.items[i] = ITEM_INVALID; - - if (!perform_one_run (&block, byte_order, &run)) - goto out; - - retval = TRUE; - - out: - data_block_free (&block); - - return retval; -} - -static dbus_bool_t -recursive_marshal_test_iteration (void *data) -{ - int i; - - i = 0; - while (i < 18) - { - if (!perform_all_runs (DBUS_LITTLE_ENDIAN, i)) - return FALSE; - if (!perform_all_runs (DBUS_BIG_ENDIAN, i)) - return FALSE; - if (!perform_all_items (DBUS_LITTLE_ENDIAN, i)) - return FALSE; - if (!perform_all_items (DBUS_BIG_ENDIAN, i)) - return FALSE; - - ++i; - } - - return TRUE; -} - -typedef struct TestTypeNode TestTypeNode; -typedef struct TestTypeNodeClass TestTypeNodeClass; -typedef struct TestTypeNodeContainer TestTypeNodeContainer; -typedef struct TestTypeNodeContainerClass TestTypeNodeContainerClass; - -struct TestTypeNode -{ - const TestTypeNodeClass *klass; -}; - -struct TestTypeNodeContainer -{ - TestTypeNode base; - DBusList *children; -}; - -struct TestTypeNodeClass -{ - int typecode; - - int instance_size; - - dbus_bool_t (* construct) (TestTypeNode *node); - void (* destroy) (TestTypeNode *node); - - dbus_bool_t (* write_value) (TestTypeNode *node, - DataBlock *block, - DBusTypeWriter *writer, - int seed); - dbus_bool_t (* read_value) (TestTypeNode *node, - DataBlock *block, - DBusTypeReader *reader, - int seed); - dbus_bool_t (* build_signature) (TestTypeNode *node, - DBusString *str); -}; - -struct TestTypeNodeContainerClass -{ - TestTypeNodeClass base; -}; - -static dbus_bool_t int32_write_value (TestTypeNode *node, - DataBlock *block, - DBusTypeWriter *writer, - int seed); -static dbus_bool_t int32_read_value (TestTypeNode *node, - DataBlock *block, - DBusTypeReader *reader, - int seed); -static dbus_bool_t struct_1_write_value (TestTypeNode *node, - DataBlock *block, - DBusTypeWriter *writer, - int seed); -static dbus_bool_t struct_1_read_value (TestTypeNode *node, - DataBlock *block, - DBusTypeReader *reader, - int seed); -static dbus_bool_t struct_1_build_signature (TestTypeNode *node, - DBusString *str); -static dbus_bool_t struct_2_write_value (TestTypeNode *node, - DataBlock *block, - DBusTypeWriter *writer, - int seed); -static dbus_bool_t struct_2_read_value (TestTypeNode *node, - DataBlock *block, - DBusTypeReader *reader, - int seed); -static dbus_bool_t struct_2_build_signature (TestTypeNode *node, - DBusString *str); -static dbus_bool_t array_build_signature (TestTypeNode *node, - DBusString *str); -static dbus_bool_t array_1_write_value (TestTypeNode *node, - DataBlock *block, - DBusTypeWriter *writer, - int seed); -static dbus_bool_t array_1_read_value (TestTypeNode *node, - DataBlock *block, - DBusTypeReader *reader, - int seed); -static dbus_bool_t array_0_write_value (TestTypeNode *node, - DataBlock *block, - DBusTypeWriter *writer, - int seed); -static dbus_bool_t array_0_read_value (TestTypeNode *node, - DataBlock *block, - DBusTypeReader *reader, - int seed); -static dbus_bool_t array_2_write_value (TestTypeNode *node, - DataBlock *block, - DBusTypeWriter *writer, - int seed); -static dbus_bool_t array_2_read_value (TestTypeNode *node, - DataBlock *block, - DBusTypeReader *reader, - int seed); -static void container_destroy (TestTypeNode *node); - - - -static const TestTypeNodeClass int32_class = { - DBUS_TYPE_INT32, - sizeof (TestTypeNode), - NULL, - NULL, - int32_write_value, - int32_read_value, - NULL -}; - -static const TestTypeNodeClass uint32_class = { - DBUS_TYPE_UINT32, - sizeof (TestTypeNode), - NULL, - NULL, - int32_write_value, /* recycle from int32 */ - int32_read_value, /* recycle from int32 */ - NULL -}; +static const TestTypeNodeClass uint32_class = { + DBUS_TYPE_UINT32, + sizeof (TestTypeNode), + NULL, + NULL, + int32_write_value, /* recycle from int32 */ + int32_read_value, /* recycle from int32 */ + NULL +}; static const TestTypeNodeClass struct_1_class = { DBUS_TYPE_STRUCT, @@ -2884,7 +1581,7 @@ node_new (const TestTypeNodeClass *klass) return NULL; node->klass = klass; - + if (klass->construct) { if (!(* klass->construct) (node)) @@ -3009,7 +1706,7 @@ run_test_nodes_iteration (void *data) } /* FIXME type-iterate both signature and value */ - + return TRUE; } @@ -3028,7 +1725,7 @@ run_test_nodes_in_one_configuration (TestTypeNode **nodes, if (!_dbus_string_lengthen (&block.signature, initial_offset)) _dbus_assert_not_reached ("no memory"); - + if (!_dbus_string_lengthen (&block.body, initial_offset)) _dbus_assert_not_reached ("no memory"); @@ -3038,7 +1735,7 @@ run_test_nodes_in_one_configuration (TestTypeNode **nodes, nid.nodes = nodes; nid.n_nodes = n_nodes; nid.byte_order = byte_order; - + _dbus_test_oom_handling ("running test node", run_test_nodes_iteration, &nid); @@ -3064,7 +1761,7 @@ run_test_nodes (TestTypeNode **nodes, ++i; } - + _dbus_verbose (">>> test nodes with signature '%s'\n", _dbus_string_get_const_data (&signature)); @@ -3078,7 +1775,7 @@ run_test_nodes (TestTypeNode **nodes, DBUS_LITTLE_ENDIAN, i); run_test_nodes_in_one_configuration (nodes, n_nodes, &signature, DBUS_BIG_ENDIAN, i); - + ++i; } @@ -3097,7 +1794,7 @@ value_generator (int *ip) TestTypeNode *node; _dbus_assert (i <= N_VALUES); - + if (i == N_VALUES) { return NULL; @@ -3107,7 +1804,7 @@ value_generator (int *ip) node = node_new (basic_nodes[i]); } else - { + { /* imagine an array: * container 0 of basic 0 * container 0 of basic 1 @@ -3120,13 +1817,13 @@ value_generator (int *ip) container_klass = container_nodes[i / N_BASICS]; child_klass = basic_nodes[i % N_BASICS]; - + node = node_new (container_klass); child = node_new (child_klass); - + node_append_child (node, child); } - + *ip += 1; /* increment the generator */ return node; @@ -3151,12 +1848,12 @@ make_and_run_values_inside_container (const TestTypeNodeClass *container_klass, } /* container should now be the most-nested container */ - + i = 0; while ((child = value_generator (&i))) { node_append_child (container, child); - + run_test_nodes (&root, 1); _dbus_list_clear (&((TestTypeNodeContainer*)container)->children); @@ -3170,7 +1867,7 @@ static void make_and_run_test_nodes (void) { int i, j, k, m; - + /* We try to do this in order of "complicatedness" so that test * failures tend to show up in the simplest test case that * demonstrates the failure. There are also some tests that run @@ -3211,7 +1908,7 @@ make_and_run_test_nodes (void) while ((node = value_generator (&i))) { run_test_nodes (&node, 1); - + node_destroy (node); } } @@ -3229,7 +1926,7 @@ make_and_run_test_nodes (void) for (i = 0; i < N_VALUES; i++) node_destroy (nodes[i]); } - + _dbus_verbose (">>> >>> Each value,value pair combination as toplevel, in both orders %d iterations\n", N_VALUES * N_VALUES * 2); { @@ -3249,7 +1946,7 @@ make_and_run_test_nodes (void) node_destroy (nodes[0]); } } - + _dbus_verbose (">>> >>> Each container containing each value %d iterations\n", N_CONTAINERS * N_VALUES); for (i = 0; i < N_CONTAINERS; i++) @@ -3258,7 +1955,7 @@ make_and_run_test_nodes (void) make_and_run_values_inside_container (container_klass, 1); } - + _dbus_verbose (">>> >>> Each container of same container of each value %d iterations\n", N_CONTAINERS * N_VALUES); for (i = 0; i < N_CONTAINERS; i++) @@ -3276,7 +1973,7 @@ make_and_run_test_nodes (void) make_and_run_values_inside_container (container_klass, 3); } - + _dbus_verbose (">>> >>> Each value,value pair inside a struct %d iterations\n", N_VALUES * N_VALUES); { @@ -3292,12 +1989,12 @@ make_and_run_test_nodes (void) while ((val2 = value_generator (&j))) { TestTypeNodeContainer *container = (TestTypeNodeContainer*) node; - + node_append_child (node, val1); node_append_child (node, val2); run_test_nodes (&node, 1); - + _dbus_list_clear (&container->children); node_destroy (val2); } @@ -3305,12 +2002,12 @@ make_and_run_test_nodes (void) } node_destroy (node); } - + _dbus_verbose (">>> >>> all values in one big struct 1 iteration\n"); { TestTypeNode *node; TestTypeNode *child; - + node = node_new (&struct_1_class); i = 0; @@ -3318,17 +2015,17 @@ make_and_run_test_nodes (void) node_append_child (node, child); run_test_nodes (&node, 1); - + node_destroy (node); } - + _dbus_verbose (">>> >>> Each container of each container of each value %d iterations\n", N_CONTAINERS * N_CONTAINERS * N_VALUES); for (i = 0; i < N_CONTAINERS; i++) { const TestTypeNodeClass *outer_container_klass = container_nodes[i]; TestTypeNode *outer_container = node_new (outer_container_klass); - + for (j = 0; j < N_CONTAINERS; j++) { TestTypeNode *child; @@ -3336,12 +2033,12 @@ make_and_run_test_nodes (void) TestTypeNode *inner_container = node_new (inner_container_klass); node_append_child (outer_container, inner_container); - + m = 0; while ((child = value_generator (&m))) { node_append_child (inner_container, child); - + run_test_nodes (&outer_container, 1); _dbus_list_clear (&((TestTypeNodeContainer*)inner_container)->children); @@ -3352,34 +2049,34 @@ make_and_run_test_nodes (void) } node_destroy (outer_container); } - + _dbus_verbose (">>> >>> Each container of each container of each container of each value %d iterations\n", N_CONTAINERS * N_CONTAINERS * N_CONTAINERS * N_VALUES); for (i = 0; i < N_CONTAINERS; i++) { const TestTypeNodeClass *outer_container_klass = container_nodes[i]; TestTypeNode *outer_container = node_new (outer_container_klass); - + for (j = 0; j < N_CONTAINERS; j++) { const TestTypeNodeClass *inner_container_klass = container_nodes[j]; TestTypeNode *inner_container = node_new (inner_container_klass); node_append_child (outer_container, inner_container); - + for (k = 0; k < N_CONTAINERS; k++) { TestTypeNode *child; const TestTypeNodeClass *center_container_klass = container_nodes[k]; - TestTypeNode *center_container = node_new (center_container_klass); + TestTypeNode *center_container = node_new (center_container_klass); node_append_child (inner_container, center_container); - + m = 0; while ((child = value_generator (&m))) { node_append_child (center_container, child); - + run_test_nodes (&outer_container, 1); _dbus_list_clear (&((TestTypeNodeContainer*)center_container)->children); @@ -3393,7 +2090,7 @@ make_and_run_test_nodes (void) } node_destroy (outer_container); } - + _dbus_verbose (">>> >>> Each value,value,value triplet combination as toplevel, in all orders %d iterations\n", N_VALUES * N_VALUES * N_VALUES); { @@ -3409,7 +2106,7 @@ make_and_run_test_nodes (void) while ((nodes[2] = value_generator (&k))) { run_test_nodes (nodes, 3); - + node_destroy (nodes[2]); } node_destroy (nodes[1]); @@ -3424,19 +2121,8 @@ dbus_bool_t _dbus_marshal_recursive_test (void); dbus_bool_t _dbus_marshal_recursive_test (void) { - /* The new comprehensive tests */ - -#if 1 make_and_run_test_nodes (); -#endif - -#if 0 - /* The old tests */ - _dbus_test_oom_handling ("recursive marshaling", - recursive_marshal_test_iteration, - NULL); -#endif - + return TRUE; } @@ -3488,7 +2174,7 @@ int32_from_seed (int seed) v = 1; break; } - + if (seed > 1) v *= seed; /* wraps around eventually, which is fine */ @@ -3505,7 +2191,7 @@ int32_write_value (TestTypeNode *node, dbus_int32_t v; v = int32_from_seed (seed); - + return _dbus_type_writer_write_basic (writer, node->klass->typecode, &v); @@ -3521,10 +2207,10 @@ int32_read_value (TestTypeNode *node, dbus_int32_t v; check_expected_type (reader, node->klass->typecode); - + _dbus_type_reader_read_basic (reader, (dbus_int32_t*) &v); - + _dbus_assert (v == int32_from_seed (seed)); return TRUE; @@ -3542,9 +2228,9 @@ struct_N_write_value (TestTypeNode *node, int i; _dbus_assert (container->children != NULL); - + data_block_save (block, &saved); - + if (!_dbus_type_writer_recurse_struct (writer, &sub)) return FALSE; @@ -3553,7 +2239,7 @@ struct_N_write_value (TestTypeNode *node, while (i < n_copies) { DBusList *link; - + link = _dbus_list_get_first_link (&container->children); while (link != NULL) { @@ -3565,19 +2251,19 @@ struct_N_write_value (TestTypeNode *node, data_block_restore (block, &saved); return FALSE; } - + link = next; } ++i; } - + if (!_dbus_type_writer_unrecurse (writer, &sub)) { data_block_restore (block, &saved); return FALSE; } - + return TRUE; } @@ -3590,16 +2276,16 @@ struct_N_read_value (TestTypeNode *node, TestTypeNodeContainer *container = (TestTypeNodeContainer*) node; DBusTypeReader sub; int i; - + check_expected_type (reader, DBUS_TYPE_STRUCT); - + _dbus_type_reader_recurse (reader, &sub); i = 0; while (i < n_copies) { DBusList *link; - + link = _dbus_list_get_first_link (&container->children); while (link != NULL) { @@ -3613,13 +2299,13 @@ struct_N_read_value (TestTypeNode *node, NEXT_EXPECTING_FALSE (&sub); else NEXT_EXPECTING_TRUE (&sub); - + link = next; } ++i; } - + return TRUE; } @@ -3636,12 +2322,12 @@ struct_N_build_signature (TestTypeNode *node, if (!_dbus_string_append_byte (str, DBUS_STRUCT_BEGIN_CHAR)) goto oom; - + i = 0; while (i < n_copies) { DBusList *link; - + link = _dbus_list_get_first_link (&container->children); while (link != NULL) { @@ -3650,7 +2336,7 @@ struct_N_build_signature (TestTypeNode *node, if (!node_build_signature (child, str)) goto oom; - + link = next; } @@ -3659,9 +2345,9 @@ struct_N_build_signature (TestTypeNode *node, if (!_dbus_string_append_byte (str, DBUS_STRUCT_END_CHAR)) goto oom; - + return TRUE; - + oom: _dbus_string_set_length (str, orig_len); return FALSE; @@ -3733,14 +2419,14 @@ array_N_write_value (TestTypeNode *node, _dbus_assert (container->children != NULL); data_block_save (block, &saved); - + if (!_dbus_string_init (&element_signature)) return FALSE; if (!node_build_signature (_dbus_list_get_first (&container->children), &element_signature)) goto oom; - + if (!_dbus_type_writer_recurse_array (writer, _dbus_string_get_const_data (&element_signature), &sub)) @@ -3750,7 +2436,7 @@ array_N_write_value (TestTypeNode *node, while (i < n_copies) { DBusList *link; - + link = _dbus_list_get_first_link (&container->children); while (link != NULL) { @@ -3759,16 +2445,16 @@ array_N_write_value (TestTypeNode *node, if (!node_write_value (child, block, &sub, i)) goto oom; - + link = next; } ++i; } - + if (!_dbus_type_writer_unrecurse (writer, &sub)) goto oom; - + return TRUE; oom: @@ -3786,37 +2472,37 @@ array_N_read_value (TestTypeNode *node, TestTypeNodeContainer *container = (TestTypeNodeContainer*) node; DBusTypeReader sub; int i; - + check_expected_type (reader, DBUS_TYPE_ARRAY); if (n_copies > 0) { _dbus_assert (!_dbus_type_reader_array_is_empty (reader)); - + _dbus_type_reader_recurse (reader, &sub); i = 0; while (i < n_copies) { DBusList *link; - + link = _dbus_list_get_first_link (&container->children); while (link != NULL) { TestTypeNode *child = link->data; DBusList *next = _dbus_list_get_next_link (&container->children, link); - + if (!node_read_value (child, block, &sub, i)) return FALSE; - + if (i == (n_copies - 1) && next == NULL) NEXT_EXPECTING_FALSE (&sub); else NEXT_EXPECTING_TRUE (&sub); - + link = next; } - + ++i; } } @@ -3824,7 +2510,7 @@ array_N_read_value (TestTypeNode *node, { _dbus_assert (_dbus_type_reader_array_is_empty (reader)); } - + return TRUE; } @@ -3834,7 +2520,7 @@ array_build_signature (TestTypeNode *node, { TestTypeNodeContainer *container = (TestTypeNodeContainer*) node; int orig_len; - + orig_len = _dbus_string_get_length (str); if (!_dbus_string_append_byte (str, DBUS_TYPE_ARRAY)) @@ -3843,9 +2529,9 @@ array_build_signature (TestTypeNode *node, if (!node_build_signature (_dbus_list_get_first (&container->children), str)) goto oom; - + return TRUE; - + oom: _dbus_string_set_length (str, orig_len); return FALSE; @@ -3911,7 +2597,7 @@ container_destroy (TestTypeNode *node) { TestTypeNodeContainer *container = (TestTypeNodeContainer*) node; DBusList *link; - + link = _dbus_list_get_first_link (&container->children); while (link != NULL) { @@ -3921,7 +2607,7 @@ container_destroy (TestTypeNode *node) node_destroy (child); _dbus_list_free_link (link); - + link = next; } } -- cgit