26 #ifdef DBUS_BUILD_TESTS
28 #include "dbus-marshal-recursive.h"
29 #include "dbus-marshal-basic.h"
30 #include "dbus-signature.h"
31 #include "dbus-internals.h"
38 #ifdef DBUS_HAVE_INT64
47 basic_value_equal (
int type,
55 return strcmp (lhs->
str, rhs->
str) == 0;
59 #ifdef DBUS_HAVE_INT64
60 return lhs->
u64 == rhs->
u64;
78 if (lhs_type != rhs_type)
89 basic_value_zero (&lhs_value);
90 basic_value_zero (&rhs_value);
95 return basic_value_equal (lhs_type, &lhs_value, &rhs_value);
105 return equal_values_helper (&lhs_sub, &rhs_sub);
123 return equal_values_helper (©_lhs, ©_rhs);
128 #ifndef DOXYGEN_SHOULD_SKIP_THIS
130 #include "dbus-test.h"
131 #include "dbus-list.h"
136 #define TEST_OOM_HANDLING 0
140 #define MAX_INITIAL_OFFSET 9
146 #define MAX_ITERATIONS_FOR_EXPENSIVE_TESTS 1000
162 #define N_FENCE_BYTES 5
163 #define FENCE_BYTES_STR "abcde"
164 #define INITIAL_PADDING_BYTE '\0'
167 data_block_init (DataBlock *block,
181 INITIAL_PADDING_BYTE) ||
183 INITIAL_PADDING_BYTE) ||
192 block->byte_order = byte_order;
193 block->initial_offset = initial_offset;
199 data_block_save (DataBlock *block,
200 DataBlockState *state)
207 data_block_restore (DataBlock *block,
208 DataBlockState *state)
211 state->saved_sig_len,
214 state->saved_body_len,
219 data_block_verify (DataBlock *block)
251 0, block->initial_offset));
253 0, block->initial_offset));
257 data_block_free (DataBlock *block)
259 data_block_verify (block);
266 data_block_reset (DataBlock *block)
268 data_block_verify (block);
271 block->initial_offset,
274 block->initial_offset,
277 data_block_verify (block);
281 data_block_init_reader_writer (DataBlock *block,
289 block->initial_offset,
291 block->initial_offset);
305 const char *funcname,
314 _dbus_warn (
"Read type %s while expecting %s at %s line %d\n",
323 #define check_expected_type(reader, expected) real_check_expected_type (reader, expected, _DBUS_FUNCTION_NAME, __LINE__)
325 #define NEXT_EXPECTING_TRUE(reader) do { if (!_dbus_type_reader_next (reader)) \
327 _dbus_warn ("_dbus_type_reader_next() should have returned TRUE at %s %d\n", \
328 _DBUS_FUNCTION_NAME, __LINE__); \
329 _dbus_assert_not_reached ("test failed"); \
333 #define NEXT_EXPECTING_FALSE(reader) do { if (_dbus_type_reader_next (reader)) \
335 _dbus_warn ("_dbus_type_reader_next() should have returned FALSE at %s %d\n", \
336 _DBUS_FUNCTION_NAME, __LINE__); \
337 _dbus_assert_not_reached ("test failed"); \
339 check_expected_type (reader, DBUS_TYPE_INVALID); \
342 typedef struct TestTypeNode TestTypeNode;
343 typedef struct TestTypeNodeClass TestTypeNodeClass;
344 typedef struct TestTypeNodeContainer TestTypeNodeContainer;
345 typedef struct TestTypeNodeContainerClass TestTypeNodeContainerClass;
349 const TestTypeNodeClass *klass;
352 struct TestTypeNodeContainer
358 struct TestTypeNodeClass
367 void (* destroy) (TestTypeNode *node);
380 dbus_bool_t (* build_signature) (TestTypeNode *node,
393 struct TestTypeNodeContainerClass
395 TestTypeNodeClass base;
403 static dbus_bool_t int16_write_value (TestTypeNode *node,
407 static dbus_bool_t int16_read_value (TestTypeNode *node,
410 static dbus_bool_t int16_set_value (TestTypeNode *node,
414 static dbus_bool_t int16_write_multi (TestTypeNode *node,
419 static dbus_bool_t int16_read_multi (TestTypeNode *node,
423 static dbus_bool_t int32_write_value (TestTypeNode *node,
427 static dbus_bool_t int32_read_value (TestTypeNode *node,
430 static dbus_bool_t int32_set_value (TestTypeNode *node,
434 static dbus_bool_t int32_write_multi (TestTypeNode *node,
439 static dbus_bool_t int32_read_multi (TestTypeNode *node,
443 static dbus_bool_t int64_write_value (TestTypeNode *node,
447 static dbus_bool_t int64_read_value (TestTypeNode *node,
450 static dbus_bool_t int64_set_value (TestTypeNode *node,
454 static dbus_bool_t string_write_value (TestTypeNode *node,
458 static dbus_bool_t string_read_value (TestTypeNode *node,
461 static dbus_bool_t string_set_value (TestTypeNode *node,
465 static dbus_bool_t bool_write_value (TestTypeNode *node,
469 static dbus_bool_t bool_read_value (TestTypeNode *node,
472 static dbus_bool_t bool_set_value (TestTypeNode *node,
476 static dbus_bool_t byte_write_value (TestTypeNode *node,
480 static dbus_bool_t byte_read_value (TestTypeNode *node,
483 static dbus_bool_t byte_set_value (TestTypeNode *node,
487 static dbus_bool_t double_write_value (TestTypeNode *node,
491 static dbus_bool_t double_read_value (TestTypeNode *node,
494 static dbus_bool_t double_set_value (TestTypeNode *node,
498 static dbus_bool_t object_path_write_value (TestTypeNode *node,
502 static dbus_bool_t object_path_read_value (TestTypeNode *node,
505 static dbus_bool_t object_path_set_value (TestTypeNode *node,
509 static dbus_bool_t signature_write_value (TestTypeNode *node,
513 static dbus_bool_t signature_read_value (TestTypeNode *node,
516 static dbus_bool_t signature_set_value (TestTypeNode *node,
520 static dbus_bool_t struct_write_value (TestTypeNode *node,
524 static dbus_bool_t struct_read_value (TestTypeNode *node,
527 static dbus_bool_t struct_set_value (TestTypeNode *node,
531 static dbus_bool_t struct_build_signature (TestTypeNode *node,
533 static dbus_bool_t dict_write_value (TestTypeNode *node,
537 static dbus_bool_t dict_read_value (TestTypeNode *node,
540 static dbus_bool_t dict_set_value (TestTypeNode *node,
544 static dbus_bool_t dict_build_signature (TestTypeNode *node,
546 static dbus_bool_t array_write_value (TestTypeNode *node,
550 static dbus_bool_t array_read_value (TestTypeNode *node,
553 static dbus_bool_t array_set_value (TestTypeNode *node,
557 static dbus_bool_t array_build_signature (TestTypeNode *node,
559 static dbus_bool_t variant_write_value (TestTypeNode *node,
563 static dbus_bool_t variant_read_value (TestTypeNode *node,
566 static dbus_bool_t variant_set_value (TestTypeNode *node,
570 static void container_destroy (TestTypeNode *node);
574 static const TestTypeNodeClass int16_class = {
576 sizeof (TestTypeNode),
588 static const TestTypeNodeClass uint16_class = {
590 sizeof (TestTypeNode),
602 static const TestTypeNodeClass int32_class = {
604 sizeof (TestTypeNode),
616 static const TestTypeNodeClass uint32_class = {
618 sizeof (TestTypeNode),
630 static const TestTypeNodeClass int64_class = {
632 sizeof (TestTypeNode),
644 static const TestTypeNodeClass uint64_class = {
646 sizeof (TestTypeNode),
658 static const TestTypeNodeClass string_0_class = {
660 sizeof (TestTypeNode),
672 static const TestTypeNodeClass string_1_class = {
674 sizeof (TestTypeNode),
687 static const TestTypeNodeClass string_3_class = {
689 sizeof (TestTypeNode),
702 static const TestTypeNodeClass string_8_class = {
704 sizeof (TestTypeNode),
716 static const TestTypeNodeClass bool_class = {
718 sizeof (TestTypeNode),
730 static const TestTypeNodeClass byte_class = {
732 sizeof (TestTypeNode),
744 static const TestTypeNodeClass double_class = {
746 sizeof (TestTypeNode),
758 static const TestTypeNodeClass object_path_class = {
760 sizeof (TestTypeNode),
764 object_path_write_value,
765 object_path_read_value,
766 object_path_set_value,
772 static const TestTypeNodeClass signature_class = {
774 sizeof (TestTypeNode),
778 signature_write_value,
779 signature_read_value,
786 static const TestTypeNodeClass struct_1_class = {
788 sizeof (TestTypeNodeContainer),
795 struct_build_signature,
800 static const TestTypeNodeClass struct_2_class = {
802 sizeof (TestTypeNodeContainer),
809 struct_build_signature,
814 static const TestTypeNodeClass dict_1_class = {
816 sizeof (TestTypeNodeContainer),
823 dict_build_signature,
830 static const TestTypeNodeClass array_0_class = {
832 sizeof (TestTypeNodeContainer),
839 array_build_signature,
844 static const TestTypeNodeClass array_1_class = {
846 sizeof (TestTypeNodeContainer),
853 array_build_signature,
858 static const TestTypeNodeClass array_2_class = {
860 sizeof (TestTypeNodeContainer),
867 array_build_signature,
872 static const TestTypeNodeClass array_9_class = {
874 sizeof (TestTypeNodeContainer),
881 array_build_signature,
886 static const TestTypeNodeClass variant_class = {
888 sizeof (TestTypeNodeContainer),
900 static const TestTypeNodeClass*
const
918 #define N_BASICS (_DBUS_N_ELEMENTS (basic_nodes))
920 static const TestTypeNodeClass*
const
921 container_nodes[] = {
933 #define N_CONTAINERS (_DBUS_N_ELEMENTS (container_nodes))
936 node_new (
const TestTypeNodeClass *klass)
946 if (klass->construct)
948 if (!(* klass->construct) (node))
959 node_destroy (TestTypeNode *node)
961 if (node->klass->destroy)
962 (* node->klass->destroy) (node);
967 node_write_value (TestTypeNode *node,
974 retval = (* node->klass->write_value) (node, block, writer, seed);
978 data_block_verify (block);
985 node_read_value (TestTypeNode *node,
991 if (!(* node->klass->read_value) (node, reader, seed))
1002 node_set_value (TestTypeNode *node,
1007 if (!(* node->klass->set_value) (node, reader, realign_root, seed))
1014 node_build_signature (TestTypeNode *node,
1017 if (node->klass->build_signature)
1018 return (* node->klass->build_signature) (node, str);
1024 node_append_child (TestTypeNode *node,
1025 TestTypeNode *child)
1027 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
1029 _dbus_assert (node->klass->instance_size >= (
int) sizeof (TestTypeNodeContainer));
1038 node_write_multi (TestTypeNode *node,
1047 retval = (* node->klass->write_multi) (node, block, writer, seed, n_copies);
1051 data_block_verify (block);
1058 node_read_multi (TestTypeNode *node,
1065 if (!(* node->klass->read_multi) (node, reader, seed, n_copies))
1071 static int n_iterations_completed_total = 0;
1072 static int n_iterations_completed_this_test = 0;
1073 static int n_iterations_expected_this_test = 0;
1080 TestTypeNode **nodes;
1082 } NodeIterationData;
1085 run_test_copy (NodeIterationData *nid)
1093 _dbus_verbose (
"\n");
1099 if (!data_block_init (&dest, src->byte_order, src->initial_offset))
1102 data_block_init_reader_writer (src, &reader,
NULL);
1103 data_block_init_reader_writer (&dest,
NULL, &writer);
1109 dest.initial_offset,
'\0'))
1118 _dbus_verbose (
"SOURCE\n");
1121 _dbus_verbose (
"DEST\n");
1129 _dbus_verbose (
"SOURCE\n");
1132 _dbus_verbose (
"DEST\n");
1142 data_block_free (&dest);
1148 run_test_values_only_write (NodeIterationData *nid)
1156 _dbus_verbose (
"\n");
1160 data_block_reset (nid->block);
1173 nid->block->initial_offset);
1176 while (i < nid->n_nodes)
1178 if (!node_write_value (nid->nodes[i], nid->block, &writer, i))
1189 while (i < nid->n_nodes)
1191 if (!node_read_value (nid->nodes[i], &reader, i))
1194 if (i + 1 == nid->n_nodes)
1195 NEXT_EXPECTING_FALSE (&reader);
1197 NEXT_EXPECTING_TRUE (&reader);
1205 data_block_reset (nid->block);
1217 run_test_set_values (NodeIterationData *nid)
1224 _dbus_verbose (
"\n");
1228 data_block_init_reader_writer (nid->block,
1231 realign_root = reader;
1234 while (i < nid->n_nodes)
1236 if (!node_set_value (nid->nodes[i],
1237 &reader, &realign_root,
1241 if (i + 1 == nid->n_nodes)
1242 NEXT_EXPECTING_FALSE (&reader);
1244 NEXT_EXPECTING_TRUE (&reader);
1251 reader = realign_root;
1254 while (i < nid->n_nodes)
1256 if (!node_read_value (nid->nodes[i], &reader,
1260 if (i + 1 == nid->n_nodes)
1261 NEXT_EXPECTING_FALSE (&reader);
1263 NEXT_EXPECTING_TRUE (&reader);
1275 run_test_delete_values (NodeIterationData *nid)
1281 _dbus_verbose (
"\n");
1285 data_block_init_reader_writer (nid->block,
1310 _dbus_verbose (
"recursing into deletion loop reader.value_pos = %d array.value_pos = %d array.u.start_pos = %d\n",
1315 static int cycle = 0;
1321 if (elem == 3 || elem >= n_elements)
1322 elem = n_elements - 1;
1324 _dbus_verbose (
"deleting array element %d of %d type %s cycle %d reader pos %d elem pos %d\n",
1352 data_block_init_reader_writer (nid->block,
1367 run_test_nodes_iteration (
void *data)
1369 NodeIterationData *nid = data;
1383 data_block_init_reader_writer (nid->block,
1390 nid->type_offset,
'\0'))
1394 while (i < nid->n_nodes)
1396 if (!node_write_value (nid->nodes[i], nid->block, &writer, i))
1403 &nid->block->signature, nid->type_offset))
1405 _dbus_warn (
"Expected signature '%s' and got '%s' with initial offset %d\n",
1413 while (i < nid->n_nodes)
1415 if (!node_read_value (nid->nodes[i], &reader, i))
1418 if (i + 1 == nid->n_nodes)
1419 NEXT_EXPECTING_FALSE (&reader);
1421 NEXT_EXPECTING_TRUE (&reader);
1426 if (n_iterations_expected_this_test <= MAX_ITERATIONS_FOR_EXPENSIVE_TESTS)
1435 if (!run_test_set_values (nid))
1438 if (!run_test_delete_values (nid))
1441 if (!run_test_copy (nid))
1444 if (!run_test_values_only_write (nid))
1456 data_block_reset (nid->block);
1462 run_test_nodes_in_one_configuration (TestTypeNode **nodes,
1469 NodeIterationData nid;
1471 if (!data_block_init (&block, byte_order, initial_offset))
1474 nid.signature = signature;
1476 nid.type_offset = initial_offset;
1478 nid.n_nodes = n_nodes;
1480 if (TEST_OOM_HANDLING &&
1481 n_iterations_expected_this_test <= MAX_ITERATIONS_FOR_EXPENSIVE_TESTS)
1483 _dbus_test_oom_handling (
"running test node",
1484 run_test_nodes_iteration,
1489 if (!run_test_nodes_iteration (&nid))
1493 data_block_free (&block);
1497 run_test_nodes (TestTypeNode **nodes,
1509 if (! node_build_signature (nodes[i], &signature))
1515 _dbus_verbose (
">>> test nodes with signature '%s'\n",
1519 while (i <= MAX_INITIAL_OFFSET)
1521 run_test_nodes_in_one_configuration (nodes, n_nodes, &signature,
1523 run_test_nodes_in_one_configuration (nodes, n_nodes, &signature,
1529 n_iterations_completed_this_test += 1;
1530 n_iterations_completed_total += 1;
1532 if (n_iterations_completed_this_test == n_iterations_expected_this_test)
1534 fprintf (stderr,
" 100%% %d this test (%d cumulative)\n",
1535 n_iterations_completed_this_test,
1536 n_iterations_completed_total);
1539 else if ((n_iterations_completed_this_test %
1540 (
int)(n_iterations_expected_this_test / 10.0)) == 1)
1542 fprintf (stderr,
" %d%% ", (
int) (n_iterations_completed_this_test / (
double) n_iterations_expected_this_test * 100));
1548 #define N_VALUES (N_BASICS * N_CONTAINERS + N_BASICS)
1550 static TestTypeNode*
1551 value_generator (
int *ip)
1554 const TestTypeNodeClass *child_klass;
1555 const TestTypeNodeClass *container_klass;
1556 TestTypeNode *child;
1565 else if (i < N_BASICS)
1567 node = node_new (basic_nodes[i]);
1581 container_klass = container_nodes[i / N_BASICS];
1582 child_klass = basic_nodes[i % N_BASICS];
1584 node = node_new (container_klass);
1585 child = node_new (child_klass);
1587 node_append_child (node, child);
1596 build_body (TestTypeNode **nodes,
1610 if (! node_build_signature (nodes[i], signature))
1616 if (!data_block_init (&block, byte_order, 0))
1619 data_block_init_reader_writer (&block,
1632 if (!node_write_value (nodes[i], &block, &writer, i))
1643 data_block_free (&block);
1647 dbus_internal_do_not_use_generate_bodies (
int sequence,
1652 TestTypeNode *nodes[1];
1656 nodes[0] = value_generator (&sequence);
1658 if (nodes[0] ==
NULL)
1663 build_body (nodes, n_nodes, byte_order, signature, body);
1669 node_destroy (nodes[i]);
1677 make_and_run_values_inside_container (
const TestTypeNodeClass *container_klass,
1681 TestTypeNode *container;
1682 TestTypeNode *child;
1685 root = node_new (container_klass);
1687 for (i = 1; i < n_nested; i++)
1689 child = node_new (container_klass);
1690 node_append_child (container, child);
1697 while ((child = value_generator (&i)))
1699 node_append_child (container, child);
1701 run_test_nodes (&root, 1);
1704 node_destroy (child);
1707 node_destroy (root);
1711 start_next_test (
const char *format,
1714 n_iterations_completed_this_test = 0;
1715 n_iterations_expected_this_test = expected;
1717 fprintf (stderr,
">>> >>> ");
1718 fprintf (stderr, format,
1719 n_iterations_expected_this_test);
1723 make_and_run_test_nodes (
void)
1759 start_next_test (
"Each value by itself %d iterations\n", N_VALUES);
1763 while ((node = value_generator (&i)))
1765 run_test_nodes (&node, 1);
1767 node_destroy (node);
1771 start_next_test (
"Each value by itself with arrays as blocks %d iterations\n", N_VALUES);
1772 arrays_write_fixed_in_blocks =
TRUE;
1776 while ((node = value_generator (&i)))
1778 run_test_nodes (&node, 1);
1780 node_destroy (node);
1783 arrays_write_fixed_in_blocks =
FALSE;
1785 start_next_test (
"All values in one big toplevel %d iteration\n", 1);
1787 TestTypeNode *nodes[N_VALUES];
1790 while ((nodes[i] = value_generator (&i)))
1793 run_test_nodes (nodes, N_VALUES);
1795 for (i = 0; i < N_VALUES; i++)
1796 node_destroy (nodes[i]);
1799 start_next_test (
"Each value,value pair combination as toplevel, in both orders %d iterations\n",
1800 N_VALUES * N_VALUES);
1802 TestTypeNode *nodes[2];
1805 while ((nodes[0] = value_generator (&i)))
1808 while ((nodes[1] = value_generator (&j)))
1810 run_test_nodes (nodes, 2);
1812 node_destroy (nodes[1]);
1815 node_destroy (nodes[0]);
1819 start_next_test (
"Each container containing each value %d iterations\n",
1820 N_CONTAINERS * N_VALUES);
1821 for (i = 0; i < N_CONTAINERS; i++)
1823 const TestTypeNodeClass *container_klass = container_nodes[i];
1825 make_and_run_values_inside_container (container_klass, 1);
1828 start_next_test (
"Each container containing each value with arrays as blocks %d iterations\n",
1829 N_CONTAINERS * N_VALUES);
1830 arrays_write_fixed_in_blocks =
TRUE;
1831 for (i = 0; i < N_CONTAINERS; i++)
1833 const TestTypeNodeClass *container_klass = container_nodes[i];
1835 make_and_run_values_inside_container (container_klass, 1);
1837 arrays_write_fixed_in_blocks =
FALSE;
1839 start_next_test (
"Each container of same container of each value %d iterations\n",
1840 N_CONTAINERS * N_VALUES);
1841 for (i = 0; i < N_CONTAINERS; i++)
1843 const TestTypeNodeClass *container_klass = container_nodes[i];
1845 make_and_run_values_inside_container (container_klass, 2);
1848 start_next_test (
"Each container of same container of same container of each value %d iterations\n",
1849 N_CONTAINERS * N_VALUES);
1850 for (i = 0; i < N_CONTAINERS; i++)
1852 const TestTypeNodeClass *container_klass = container_nodes[i];
1854 make_and_run_values_inside_container (container_klass, 3);
1857 start_next_test (
"Each value,value pair inside a struct %d iterations\n",
1858 N_VALUES * N_VALUES);
1860 TestTypeNode *val1, *val2;
1863 node = node_new (&struct_1_class);
1866 while ((val1 = value_generator (&i)))
1869 while ((val2 = value_generator (&j)))
1871 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
1873 node_append_child (node, val1);
1874 node_append_child (node, val2);
1876 run_test_nodes (&node, 1);
1879 node_destroy (val2);
1881 node_destroy (val1);
1883 node_destroy (node);
1886 start_next_test (
"All values in one big struct %d iteration\n",
1890 TestTypeNode *child;
1892 node = node_new (&struct_1_class);
1895 while ((child = value_generator (&i)))
1896 node_append_child (node, child);
1898 run_test_nodes (&node, 1);
1900 node_destroy (node);
1903 start_next_test (
"Each value in a large array %d iterations\n",
1909 node = node_new (&array_9_class);
1912 while ((val = value_generator (&i)))
1914 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
1916 node_append_child (node, val);
1918 run_test_nodes (&node, 1);
1924 node_destroy (node);
1927 start_next_test (
"Each container of each container of each value %d iterations\n",
1928 N_CONTAINERS * N_CONTAINERS * N_VALUES);
1929 for (i = 0; i < N_CONTAINERS; i++)
1931 const TestTypeNodeClass *outer_container_klass = container_nodes[i];
1932 TestTypeNode *outer_container = node_new (outer_container_klass);
1934 for (j = 0; j < N_CONTAINERS; j++)
1936 TestTypeNode *child;
1937 const TestTypeNodeClass *inner_container_klass = container_nodes[j];
1938 TestTypeNode *inner_container = node_new (inner_container_klass);
1940 node_append_child (outer_container, inner_container);
1943 while ((child = value_generator (&m)))
1945 node_append_child (inner_container, child);
1947 run_test_nodes (&outer_container, 1);
1950 node_destroy (child);
1953 node_destroy (inner_container);
1955 node_destroy (outer_container);
1958 start_next_test (
"Each container of each container of each container of each value %d iterations\n",
1959 N_CONTAINERS * N_CONTAINERS * N_CONTAINERS * N_VALUES);
1960 for (i = 0; i < N_CONTAINERS; i++)
1962 const TestTypeNodeClass *outer_container_klass = container_nodes[i];
1963 TestTypeNode *outer_container = node_new (outer_container_klass);
1965 for (j = 0; j < N_CONTAINERS; j++)
1967 const TestTypeNodeClass *inner_container_klass = container_nodes[j];
1968 TestTypeNode *inner_container = node_new (inner_container_klass);
1970 node_append_child (outer_container, inner_container);
1972 for (k = 0; k < N_CONTAINERS; k++)
1974 TestTypeNode *child;
1975 const TestTypeNodeClass *center_container_klass = container_nodes[k];
1976 TestTypeNode *center_container = node_new (center_container_klass);
1978 node_append_child (inner_container, center_container);
1981 while ((child = value_generator (&m)))
1983 node_append_child (center_container, child);
1985 run_test_nodes (&outer_container, 1);
1988 node_destroy (child);
1991 node_destroy (center_container);
1994 node_destroy (inner_container);
1996 node_destroy (outer_container);
2001 start_next_test (
"Each value,value,value triplet combination as toplevel, in all orders %d iterations\n",
2002 N_VALUES * N_VALUES * N_VALUES);
2004 TestTypeNode *nodes[3];
2007 while ((nodes[0] = value_generator (&i)))
2010 while ((nodes[1] = value_generator (&j)))
2013 while ((nodes[2] = value_generator (&k)))
2015 run_test_nodes (nodes, 3);
2017 node_destroy (nodes[2]);
2019 node_destroy (nodes[1]);
2021 node_destroy (nodes[0]);
2026 fprintf (stderr,
"%d total iterations of recursive marshaling tests\n",
2027 n_iterations_completed_total);
2028 fprintf (stderr,
"each iteration ran at initial offsets 0 through %d in both big and little endian\n",
2029 MAX_INITIAL_OFFSET);
2030 fprintf (stderr,
"out of memory handling %s tested\n",
2031 TEST_OOM_HANDLING ?
"was" :
"was not");
2035 _dbus_marshal_recursive_test (
void)
2037 make_and_run_test_nodes ();
2050 #define MAX_MULTI_COUNT 5
2052 #define SAMPLE_INT16 1234
2053 #define SAMPLE_INT16_ALTERNATE 6785
2055 int16_from_seed (
int seed)
2070 v = SAMPLE_INT16_ALTERNATE;
2090 int16_write_value (TestTypeNode *node,
2098 v = int16_from_seed (seed);
2101 node->klass->typecode,
2106 int16_read_value (TestTypeNode *node,
2113 check_expected_type (reader, node->klass->typecode);
2124 int16_set_value (TestTypeNode *node,
2132 v = int16_from_seed (seed);
2140 int16_write_multi (TestTypeNode *node,
2151 for (i = 0; i < count; ++i)
2152 values[i] = int16_from_seed (seed + i);
2155 node->klass->typecode,
2156 &v_ARRAY_INT16, count);
2160 int16_read_multi (TestTypeNode *node,
2170 check_expected_type (reader, node->klass->typecode);
2176 if (n_elements != count)
2177 _dbus_warn (
"got %d elements expected %d\n", n_elements, count);
2180 for (i = 0; i < count; i++)
2182 (
const unsigned char*)values + (i * 2))) ==
2183 int16_from_seed (seed + i));
2189 #define SAMPLE_INT32 12345678
2190 #define SAMPLE_INT32_ALTERNATE 53781429
2192 int32_from_seed (
int seed)
2207 v = SAMPLE_INT32_ALTERNATE;
2227 int32_write_value (TestTypeNode *node,
2235 v = int32_from_seed (seed);
2238 node->klass->typecode,
2243 int32_read_value (TestTypeNode *node,
2250 check_expected_type (reader, node->klass->typecode);
2261 int32_set_value (TestTypeNode *node,
2269 v = int32_from_seed (seed);
2277 int32_write_multi (TestTypeNode *node,
2288 for (i = 0; i < count; ++i)
2289 values[i] = int32_from_seed (seed + i);
2292 node->klass->typecode,
2293 &v_ARRAY_INT32, count);
2297 int32_read_multi (TestTypeNode *node,
2307 check_expected_type (reader, node->klass->typecode);
2313 if (n_elements != count)
2314 _dbus_warn (
"got %d elements expected %d\n", n_elements, count);
2317 for (i = 0; i < count; i++)
2319 (
const unsigned char*)values + (i * 4))) ==
2320 int32_from_seed (seed + i));
2325 #ifdef DBUS_HAVE_INT64
2327 int64_from_seed (
int seed)
2332 v32 = int32_from_seed (seed);
2342 int64_write_value (TestTypeNode *node,
2347 #ifdef DBUS_HAVE_INT64
2351 v = int64_from_seed (seed);
2354 node->klass->typecode,
2362 int64_read_value (TestTypeNode *node,
2366 #ifdef DBUS_HAVE_INT64
2370 check_expected_type (reader, node->klass->typecode);
2384 int64_set_value (TestTypeNode *node,
2389 #ifdef DBUS_HAVE_INT64
2393 v = int64_from_seed (seed);
2403 #define MAX_SAMPLE_STRING_LEN 10
2405 string_from_seed (
char *buf,
2429 v = (
unsigned char) (
'A' + seed);
2434 if (v < 'A' || v >
'z')
2447 string_write_value (TestTypeNode *node,
2452 char buf[MAX_SAMPLE_STRING_LEN + 1]=
"";
2453 const char *v_string = buf;
2456 string_from_seed (buf, node->klass->subclass_detail,
2460 node->klass->typecode,
2465 string_read_value (TestTypeNode *node,
2470 char buf[MAX_SAMPLE_STRING_LEN + 1];
2473 check_expected_type (reader, node->klass->typecode);
2476 (
const char **) &v);
2478 string_from_seed (buf, node->klass->subclass_detail,
2481 if (strcmp (buf, v) != 0)
2483 _dbus_warn (
"read string '%s' expected '%s'\n",
2492 string_set_value (TestTypeNode *node,
2497 char buf[MAX_SAMPLE_STRING_LEN + 1];
2498 const char *v_string = buf;
2500 string_from_seed (buf, node->klass->subclass_detail,
2503 #if RECURSIVE_MARSHAL_WRITE_TRACE
2507 _dbus_verbose (
"SETTING new string '%s' len %d in place of '%s' len %d\n",
2508 v_string, strlen (v_string), old, strlen (old));
2517 #define BOOL_FROM_SEED(seed) ((dbus_bool_t)((seed) % 2))
2520 bool_write_value (TestTypeNode *node,
2527 v = BOOL_FROM_SEED (seed);
2530 node->klass->typecode,
2535 bool_read_value (TestTypeNode *node,
2541 check_expected_type (reader, node->klass->typecode);
2544 (
unsigned char*) &v);
2552 bool_set_value (TestTypeNode *node,
2559 v = BOOL_FROM_SEED (seed);
2566 #define BYTE_FROM_SEED(seed) ((unsigned char) int32_from_seed (seed))
2569 byte_write_value (TestTypeNode *node,
2576 v = BYTE_FROM_SEED (seed);
2579 node->klass->typecode,
2584 byte_read_value (TestTypeNode *node,
2590 check_expected_type (reader, node->klass->typecode);
2593 (
unsigned char*) &v);
2602 byte_set_value (TestTypeNode *node,
2609 v = BYTE_FROM_SEED (seed);
2617 double_from_seed (
int seed)
2619 return SAMPLE_INT32 * (double) seed + 0.3;
2623 double_write_value (TestTypeNode *node,
2630 v = double_from_seed (seed);
2633 node->klass->typecode,
2638 double_read_value (TestTypeNode *node,
2645 check_expected_type (reader, node->klass->typecode);
2650 expected = double_from_seed (seed);
2654 #ifdef DBUS_INT64_PRINTF_MODIFIER
2655 _dbus_warn (
"Expected double %g got %g\n bits = 0x%" DBUS_INT64_PRINTF_MODIFIER
"x vs.\n bits = 0x%" DBUS_INT64_PRINTF_MODIFIER
"x)\n",
2667 double_set_value (TestTypeNode *node,
2674 v = double_from_seed (seed);
2681 #define MAX_SAMPLE_OBJECT_PATH_LEN 10
2683 object_path_from_seed (
char *buf,
2693 v = (
unsigned char) (
'A' + seed);
2705 if (v < 'A' || v >
'z')
2721 object_path_write_value (TestTypeNode *node,
2726 char buf[MAX_SAMPLE_OBJECT_PATH_LEN + 1];
2727 const char *v_string = buf;
2729 object_path_from_seed (buf, seed);
2732 node->klass->typecode,
2737 object_path_read_value (TestTypeNode *node,
2742 char buf[MAX_SAMPLE_OBJECT_PATH_LEN + 1];
2744 check_expected_type (reader, node->klass->typecode);
2747 (
const char **) &v);
2749 object_path_from_seed (buf, seed);
2751 if (strcmp (buf, v) != 0)
2753 _dbus_warn (
"read object path '%s' expected '%s'\n",
2762 object_path_set_value (TestTypeNode *node,
2767 char buf[MAX_SAMPLE_OBJECT_PATH_LEN + 1];
2768 const char *v_string = buf;
2770 object_path_from_seed (buf, seed);
2777 #define MAX_SAMPLE_SIGNATURE_LEN 10
2779 signature_from_seed (
char *buf,
2783 const char *sample_signatures[] = {
2792 strcpy (buf, sample_signatures[seed %
_DBUS_N_ELEMENTS(sample_signatures)]);
2796 signature_write_value (TestTypeNode *node,
2801 char buf[MAX_SAMPLE_SIGNATURE_LEN + 1];
2802 const char *v_string = buf;
2804 signature_from_seed (buf, seed);
2807 node->klass->typecode,
2812 signature_read_value (TestTypeNode *node,
2817 char buf[MAX_SAMPLE_SIGNATURE_LEN + 1];
2819 check_expected_type (reader, node->klass->typecode);
2822 (
const char **) &v);
2824 signature_from_seed (buf, seed);
2826 if (strcmp (buf, v) != 0)
2828 _dbus_warn (
"read signature value '%s' expected '%s'\n",
2838 signature_set_value (TestTypeNode *node,
2843 char buf[MAX_SAMPLE_SIGNATURE_LEN + 1];
2844 const char *v_string = buf;
2846 signature_from_seed (buf, seed);
2854 struct_write_value (TestTypeNode *node,
2859 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
2860 DataBlockState saved;
2865 n_copies = node->klass->subclass_detail;
2869 data_block_save (block, &saved);
2877 while (i < n_copies)
2882 while (link !=
NULL)
2884 TestTypeNode *child = link->
data;
2887 if (!node_write_value (child, block, &sub, seed + i))
2889 data_block_restore (block, &saved);
2901 data_block_restore (block, &saved);
2909 struct_read_or_set_value (TestTypeNode *node,
2914 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
2919 n_copies = node->klass->subclass_detail;
2926 while (i < n_copies)
2931 while (link !=
NULL)
2933 TestTypeNode *child = link->
data;
2936 if (realign_root ==
NULL)
2938 if (!node_read_value (child, &sub, seed + i))
2943 if (!node_set_value (child, &sub, realign_root, seed + i))
2947 if (i == (n_copies - 1) && next ==
NULL)
2948 NEXT_EXPECTING_FALSE (&sub);
2950 NEXT_EXPECTING_TRUE (&sub);
2962 struct_read_value (TestTypeNode *node,
2966 return struct_read_or_set_value (node, reader,
NULL, seed);
2970 struct_set_value (TestTypeNode *node,
2975 return struct_read_or_set_value (node, reader, realign_root, seed);
2979 struct_build_signature (TestTypeNode *node,
2982 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
2987 n_copies = node->klass->subclass_detail;
2995 while (i < n_copies)
3000 while (link !=
NULL)
3002 TestTypeNode *child = link->
data;
3005 if (!node_build_signature (child, str))
3025 array_write_value (TestTypeNode *node,
3030 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
3031 DataBlockState saved;
3037 TestTypeNode *child;
3039 n_copies = node->klass->subclass_detail;
3043 data_block_save (block, &saved);
3050 if (!node_build_signature (child,
3051 &element_signature))
3057 &element_signature, 0,
3061 if (arrays_write_fixed_in_blocks &&
3063 child->klass->write_multi)
3065 if (!node_write_multi (child, block, &sub, seed, n_copies))
3071 while (i < n_copies)
3076 while (link !=
NULL)
3078 TestTypeNode *child = link->
data;
3081 if (!node_write_value (child, block, &sub, seed + i))
3098 data_block_restore (block, &saved);
3104 array_read_or_set_value (TestTypeNode *node,
3109 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
3113 TestTypeNode *child;
3115 n_copies = node->klass->subclass_detail;
3125 if (realign_root ==
NULL && arrays_write_fixed_in_blocks &&
3127 child->klass->read_multi)
3129 if (!node_read_multi (child, &sub, seed, n_copies))
3135 while (i < n_copies)
3140 while (link !=
NULL)
3142 TestTypeNode *child = link->
data;
3148 if (realign_root ==
NULL)
3150 if (!node_read_value (child, &sub, seed + i))
3155 if (!node_set_value (child, &sub, realign_root, seed + i))
3159 if (i == (n_copies - 1) && next ==
NULL)
3160 NEXT_EXPECTING_FALSE (&sub);
3162 NEXT_EXPECTING_TRUE (&sub);
3176 array_read_value (TestTypeNode *node,
3180 return array_read_or_set_value (node, reader,
NULL, seed);
3184 array_set_value (TestTypeNode *node,
3189 return array_read_or_set_value (node, reader, realign_root, seed);
3193 array_build_signature (TestTypeNode *node,
3196 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
3216 #define VARIANT_SEED 10
3219 variant_write_value (TestTypeNode *node,
3224 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
3225 DataBlockState saved;
3228 TestTypeNode *child;
3235 data_block_save (block, &saved);
3240 if (!node_build_signature (child,
3241 &content_signature))
3245 &content_signature, 0,
3249 if (!node_write_value (child, block, &sub, seed + VARIANT_SEED))
3259 data_block_restore (block, &saved);
3265 variant_read_or_set_value (TestTypeNode *node,
3270 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
3272 TestTypeNode *child;
3283 if (realign_root ==
NULL)
3285 if (!node_read_value (child, &sub, seed + VARIANT_SEED))
3290 if (!node_set_value (child, &sub, realign_root, seed + VARIANT_SEED))
3294 NEXT_EXPECTING_FALSE (&sub);
3300 variant_read_value (TestTypeNode *node,
3304 return variant_read_or_set_value (node, reader,
NULL, seed);
3308 variant_set_value (TestTypeNode *node,
3313 return variant_read_or_set_value (node, reader, realign_root, seed);
3317 dict_write_value (TestTypeNode *node,
3322 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
3323 DataBlockState saved;
3329 int entry_value_type;
3330 TestTypeNode *child;
3332 n_entries = node->klass->subclass_detail;
3336 data_block_save (block, &saved);
3349 if (!node_build_signature (child,
3350 &entry_value_signature))
3359 &dict_entry_signature,
3370 &dict_entry_signature, 0,
3375 while (i < n_entries)
3385 key = int32_from_seed (seed + i);
3392 if (!node_write_value (child, block, &entry_sub, seed + i))
3409 data_block_restore (block, &saved);
3416 dict_read_or_set_value (TestTypeNode *node,
3421 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
3425 TestTypeNode *child;
3427 n_entries = node->klass->subclass_detail;
3440 while (i < n_entries)
3448 if (realign_root ==
NULL)
3459 NEXT_EXPECTING_TRUE (&entry_sub);
3461 if (!node_read_value (child, &entry_sub, seed + i))
3464 NEXT_EXPECTING_FALSE (&entry_sub);
3470 v = int32_from_seed (seed + i);
3477 NEXT_EXPECTING_TRUE (&entry_sub);
3479 if (!node_set_value (child, &entry_sub, realign_root, seed + i))
3482 NEXT_EXPECTING_FALSE (&entry_sub);
3485 if (i == (n_entries - 1))
3486 NEXT_EXPECTING_FALSE (&sub);
3488 NEXT_EXPECTING_TRUE (&sub);
3498 dict_read_value (TestTypeNode *node,
3502 return dict_read_or_set_value (node, reader,
NULL, seed);
3506 dict_set_value (TestTypeNode *node,
3511 return dict_read_or_set_value (node, reader, realign_root, seed);
3515 dict_build_signature (TestTypeNode *node,
3518 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
3544 container_destroy (TestTypeNode *node)
3546 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
3550 while (link !=
NULL)
3552 TestTypeNode *child = link->
data;
3555 node_destroy (child);