1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dbus-message-factory.c Generator of valid and invalid message data for test suite
4 * Copyright (C) 2005 Red Hat Inc.
6 * Licensed under the Academic Free License version 2.1
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #ifdef DBUS_BUILD_TESTS
26 #include "dbus-message-factory.h"
27 #include "dbus-message-private.h"
28 #include "dbus-test.h"
37 #define BYTE_ORDER_OFFSET 0
39 #define BODY_LENGTH_OFFSET 4
40 #define FIELDS_ARRAY_LENGTH_OFFSET 12
43 iter_recurse (DBusMessageDataIter *iter)
46 _dbus_assert (iter->depth < _DBUS_MESSAGE_DATA_MAX_NESTING);
47 _dbus_assert (iter->sequence_nos[iter->depth] >= 0);
51 iter_get_sequence (DBusMessageDataIter *iter)
53 _dbus_assert (iter->sequence_nos[iter->depth] >= 0);
54 return iter->sequence_nos[iter->depth];
58 iter_set_sequence (DBusMessageDataIter *iter,
61 _dbus_assert (sequence >= 0);
62 iter->sequence_nos[iter->depth] = sequence;
66 iter_unrecurse (DBusMessageDataIter *iter)
69 _dbus_assert (iter->depth >= 0);
73 iter_next (DBusMessageDataIter *iter)
75 iter->sequence_nos[iter->depth] += 1;
79 iter_first_in_series (DBusMessageDataIter *iter)
84 while (i < _DBUS_MESSAGE_DATA_MAX_NESTING)
86 if (iter->sequence_nos[i] != 0)
93 typedef dbus_bool_t (* DBusInnerGeneratorFunc) (DBusMessageDataIter *iter,
94 DBusMessage **message_p);
95 typedef dbus_bool_t (* DBusMessageGeneratorFunc) (DBusMessageDataIter *iter,
97 DBusValidity *expected_validity);
100 set_reply_serial (DBusMessage *message)
103 _dbus_assert_not_reached ("oom");
104 if (!dbus_message_set_reply_serial (message, 100))
105 _dbus_assert_not_reached ("oom");
109 generate_trivial_inner (DBusMessageDataIter *iter,
110 DBusMessage **message_p)
112 DBusMessage *message;
114 switch (iter_get_sequence (iter))
117 message = dbus_message_new_method_call ("org.freedesktop.TextEditor",
119 "org.freedesktop.DocumentFactory",
123 message = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);
124 set_reply_serial (message);
127 message = dbus_message_new_signal ("/foo/bar",
128 "org.freedesktop.DocumentFactory",
132 message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
134 if (!dbus_message_set_error_name (message,
135 "org.freedesktop.TestErrorName"))
136 _dbus_assert_not_reached ("oom");
139 DBusMessageIter iter;
140 const char *v_STRING = "This is an error";
142 dbus_message_iter_init_append (message, &iter);
143 if (!dbus_message_iter_append_basic (&iter,
146 _dbus_assert_not_reached ("oom");
149 set_reply_serial (message);
156 _dbus_assert_not_reached ("oom");
158 *message_p = message;
164 generate_many_bodies_inner (DBusMessageDataIter *iter,
165 DBusMessage **message_p)
167 DBusMessage *message;
168 DBusString signature;
171 /* Keeping this small makes things go faster */
172 message = dbus_message_new_method_call ("o.z.F",
177 _dbus_assert_not_reached ("oom");
179 set_reply_serial (message);
181 if (!_dbus_string_init (&signature) || !_dbus_string_init (&body))
182 _dbus_assert_not_reached ("oom");
184 if (dbus_internal_do_not_use_generate_bodies (iter_get_sequence (iter),
188 const char *v_SIGNATURE;
190 v_SIGNATURE = _dbus_string_get_const_data (&signature);
191 if (!_dbus_header_set_field_basic (&message->header,
192 DBUS_HEADER_FIELD_SIGNATURE,
195 _dbus_assert_not_reached ("oom");
197 if (!_dbus_string_move (&body, 0, &message->body, 0))
198 _dbus_assert_not_reached ("oom");
200 _dbus_marshal_set_uint32 (&message->header.data, BODY_LENGTH_OFFSET,
201 _dbus_string_get_length (&message->body),
202 message->byte_order);
204 *message_p = message;
208 dbus_message_unref (message);
212 _dbus_string_free (&signature);
213 _dbus_string_free (&body);
215 return *message_p != NULL;
219 generate_from_message (DBusString *data,
220 DBusValidity *expected_validity,
221 DBusMessage *message)
223 _dbus_message_set_serial (message, 1);
224 _dbus_message_lock (message);
226 *expected_validity = DBUS_VALID;
228 /* move for efficiency, since we'll nuke the message anyway */
229 if (!_dbus_string_move (&message->header.data, 0,
231 _dbus_assert_not_reached ("oom");
233 if (!_dbus_string_copy (&message->body, 0,
234 data, _dbus_string_get_length (data)))
235 _dbus_assert_not_reached ("oom");
239 generate_outer (DBusMessageDataIter *iter,
241 DBusValidity *expected_validity,
242 DBusInnerGeneratorFunc func)
244 DBusMessage *message;
247 if (!(*func)(iter, &message))
252 _dbus_assert (message != NULL);
254 generate_from_message (data, expected_validity, message);
256 dbus_message_unref (message);
262 generate_trivial (DBusMessageDataIter *iter,
264 DBusValidity *expected_validity)
266 return generate_outer (iter, data, expected_validity,
267 generate_trivial_inner);
271 generate_many_bodies (DBusMessageDataIter *iter,
273 DBusValidity *expected_validity)
275 return generate_outer (iter, data, expected_validity,
276 generate_many_bodies_inner);
280 simple_method_call (void)
282 DBusMessage *message;
283 /* Keeping this small makes stuff go faster */
284 message = dbus_message_new_method_call ("o.b.Q",
289 _dbus_assert_not_reached ("oom");
296 DBusMessage *message;
297 message = dbus_message_new_signal ("/f/b",
301 _dbus_assert_not_reached ("oom");
306 simple_method_return (void)
308 DBusMessage *message;
309 message = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);
311 _dbus_assert_not_reached ("oom");
313 set_reply_serial (message);
319 generate_special (DBusMessageDataIter *iter,
321 DBusValidity *expected_validity)
324 DBusMessage *message;
326 dbus_int32_t v_INT32;
328 _dbus_assert (_dbus_string_get_length (data) == 0);
333 item_seq = iter_get_sequence (iter);
337 message = simple_method_call ();
338 if (!dbus_message_append_args (message,
339 DBUS_TYPE_INT32, &v_INT32,
340 DBUS_TYPE_INT32, &v_INT32,
341 DBUS_TYPE_INT32, &v_INT32,
343 _dbus_assert_not_reached ("oom");
345 _dbus_header_get_field_raw (&message->header,
346 DBUS_HEADER_FIELD_SIGNATURE,
348 generate_from_message (data, expected_validity, message);
350 /* set an invalid typecode */
351 _dbus_string_set_byte (data, pos + 1, '$');
353 *expected_validity = DBUS_INVALID_UNKNOWN_TYPECODE;
355 else if (item_seq == 1)
357 char long_sig[DBUS_MAXIMUM_TYPE_RECURSION_DEPTH+1];
358 const char *v_STRING;
361 message = simple_method_call ();
362 if (!dbus_message_append_args (message,
363 DBUS_TYPE_INT32, &v_INT32,
364 DBUS_TYPE_INT32, &v_INT32,
365 DBUS_TYPE_INT32, &v_INT32,
367 _dbus_assert_not_reached ("oom");
370 while (i <= (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH + 1))
372 long_sig[i] = DBUS_TYPE_ARRAY;
377 if (!_dbus_header_set_field_basic (&message->header,
378 DBUS_HEADER_FIELD_SIGNATURE,
381 _dbus_assert_not_reached ("oom");
383 _dbus_header_get_field_raw (&message->header,
384 DBUS_HEADER_FIELD_SIGNATURE,
386 generate_from_message (data, expected_validity, message);
388 *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION;
390 else if (item_seq == 2)
392 char long_sig[DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*2+3];
393 const char *v_STRING;
396 message = simple_method_call ();
397 if (!dbus_message_append_args (message,
398 DBUS_TYPE_INT32, &v_INT32,
399 DBUS_TYPE_INT32, &v_INT32,
400 DBUS_TYPE_INT32, &v_INT32,
402 _dbus_assert_not_reached ("oom");
405 while (i <= (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH + 1))
407 long_sig[i] = DBUS_STRUCT_BEGIN_CHAR;
411 long_sig[i] = DBUS_TYPE_INT32;
414 while (i <= (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*2 + 3))
416 long_sig[i] = DBUS_STRUCT_END_CHAR;
421 if (!_dbus_header_set_field_basic (&message->header,
422 DBUS_HEADER_FIELD_SIGNATURE,
425 _dbus_assert_not_reached ("oom");
427 _dbus_header_get_field_raw (&message->header,
428 DBUS_HEADER_FIELD_SIGNATURE,
430 generate_from_message (data, expected_validity, message);
432 *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION;
434 else if (item_seq == 3)
436 message = simple_method_call ();
437 if (!dbus_message_append_args (message,
438 DBUS_TYPE_INT32, &v_INT32,
439 DBUS_TYPE_INT32, &v_INT32,
440 DBUS_TYPE_INT32, &v_INT32,
442 _dbus_assert_not_reached ("oom");
444 _dbus_header_get_field_raw (&message->header,
445 DBUS_HEADER_FIELD_SIGNATURE,
447 generate_from_message (data, expected_validity, message);
449 _dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_BEGIN_CHAR);
451 *expected_validity = DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED;
453 else if (item_seq == 4)
455 message = simple_method_call ();
456 if (!dbus_message_append_args (message,
457 DBUS_TYPE_INT32, &v_INT32,
458 DBUS_TYPE_INT32, &v_INT32,
459 DBUS_TYPE_INT32, &v_INT32,
461 _dbus_assert_not_reached ("oom");
463 _dbus_header_get_field_raw (&message->header,
464 DBUS_HEADER_FIELD_SIGNATURE,
466 generate_from_message (data, expected_validity, message);
468 _dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_END_CHAR);
470 *expected_validity = DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED;
472 else if (item_seq == 5)
474 message = simple_method_call ();
475 if (!dbus_message_append_args (message,
476 DBUS_TYPE_INT32, &v_INT32,
477 DBUS_TYPE_INT32, &v_INT32,
478 DBUS_TYPE_INT32, &v_INT32,
480 _dbus_assert_not_reached ("oom");
482 _dbus_header_get_field_raw (&message->header,
483 DBUS_HEADER_FIELD_SIGNATURE,
485 generate_from_message (data, expected_validity, message);
487 _dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_BEGIN_CHAR);
488 _dbus_string_set_byte (data, pos + 2, DBUS_STRUCT_END_CHAR);
490 *expected_validity = DBUS_INVALID_STRUCT_HAS_NO_FIELDS;
492 else if (item_seq == 6)
494 message = simple_method_call ();
495 generate_from_message (data, expected_validity, message);
497 _dbus_string_set_byte (data, TYPE_OFFSET, DBUS_MESSAGE_TYPE_INVALID);
499 *expected_validity = DBUS_INVALID_BAD_MESSAGE_TYPE;
501 else if (item_seq == 7)
503 /* Messages of unknown type are considered valid */
504 message = simple_method_call ();
505 generate_from_message (data, expected_validity, message);
507 _dbus_string_set_byte (data, TYPE_OFFSET, 100);
509 *expected_validity = DBUS_VALID;
511 else if (item_seq == 8)
513 message = simple_method_call ();
514 generate_from_message (data, expected_validity, message);
516 _dbus_marshal_set_uint32 (data, BODY_LENGTH_OFFSET,
517 DBUS_MAXIMUM_MESSAGE_LENGTH / 2 + 4,
518 message->byte_order);
519 _dbus_marshal_set_uint32 (data, FIELDS_ARRAY_LENGTH_OFFSET,
520 DBUS_MAXIMUM_MESSAGE_LENGTH / 2 + 4,
521 message->byte_order);
522 *expected_validity = DBUS_INVALID_MESSAGE_TOO_LONG;
524 else if (item_seq == 9)
526 const char *v_STRING = "not a valid bus name";
527 message = simple_method_call ();
529 if (!_dbus_header_set_field_basic (&message->header,
530 DBUS_HEADER_FIELD_SENDER,
531 DBUS_TYPE_STRING, &v_STRING))
532 _dbus_assert_not_reached ("oom");
534 generate_from_message (data, expected_validity, message);
536 *expected_validity = DBUS_INVALID_BAD_SENDER;
538 else if (item_seq == 10)
540 message = simple_method_call ();
542 if (!dbus_message_set_interface (message, DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL))
543 _dbus_assert_not_reached ("oom");
545 generate_from_message (data, expected_validity, message);
547 *expected_validity = DBUS_INVALID_USES_LOCAL_INTERFACE;
549 else if (item_seq == 11)
551 message = simple_method_call ();
553 if (!dbus_message_set_path (message, DBUS_PATH_ORG_FREEDESKTOP_LOCAL))
554 _dbus_assert_not_reached ("oom");
556 generate_from_message (data, expected_validity, message);
558 *expected_validity = DBUS_INVALID_USES_LOCAL_PATH;
560 else if (item_seq == 12)
562 /* Method calls don't have to have interface */
563 message = simple_method_call ();
565 if (!dbus_message_set_interface (message, NULL))
566 _dbus_assert_not_reached ("oom");
568 generate_from_message (data, expected_validity, message);
570 *expected_validity = DBUS_VALID;
572 else if (item_seq == 13)
574 /* Signals require an interface */
575 message = simple_signal ();
577 if (!dbus_message_set_interface (message, NULL))
578 _dbus_assert_not_reached ("oom");
580 generate_from_message (data, expected_validity, message);
582 *expected_validity = DBUS_INVALID_MISSING_INTERFACE;
584 else if (item_seq == 14)
586 message = simple_method_return ();
588 if (!_dbus_header_delete_field (&message->header, DBUS_HEADER_FIELD_REPLY_SERIAL))
589 _dbus_assert_not_reached ("oom");
591 generate_from_message (data, expected_validity, message);
593 *expected_validity = DBUS_INVALID_MISSING_REPLY_SERIAL;
601 dbus_message_unref (message);
608 generate_wrong_length (DBusMessageDataIter *iter,
610 DBusValidity *expected_validity)
612 int lengths[] = { -42, -17, -16, -15, -9, -8, -7, -6, -5, -4, -3, -2, -1,
613 1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16, 30 };
618 len_seq = iter_get_sequence (iter);
619 if (len_seq == _DBUS_N_ELEMENTS (lengths))
622 _dbus_assert (len_seq < _DBUS_N_ELEMENTS (lengths));
625 if (!generate_many_bodies (iter, data, expected_validity))
627 iter_set_sequence (iter, 0); /* reset to first body */
628 iter_unrecurse (iter);
629 iter_next (iter); /* next length adjustment */
632 iter_unrecurse (iter);
634 adjust = lengths[len_seq];
638 if ((_dbus_string_get_length (data) + adjust) < DBUS_MINIMUM_HEADER_SIZE)
639 _dbus_string_set_length (data, DBUS_MINIMUM_HEADER_SIZE);
641 _dbus_string_shorten (data, - adjust);
642 *expected_validity = DBUS_INVALID_FOR_UNKNOWN_REASON;
646 if (!_dbus_string_lengthen (data, adjust))
647 _dbus_assert_not_reached ("oom");
648 *expected_validity = DBUS_INVALID_TOO_MUCH_DATA;
657 _dbus_assert (_dbus_string_get_length (data) >= DBUS_MINIMUM_HEADER_SIZE);
659 byte_order = _dbus_string_get_byte (data, BYTE_ORDER_OFFSET);
660 old_body_len = _dbus_marshal_read_uint32 (data,
664 _dbus_assert (old_body_len < _dbus_string_get_length (data));
665 new_body_len = old_body_len + adjust;
666 if (new_body_len < 0)
669 /* we just munged the header, and aren't sure how */
670 *expected_validity = DBUS_VALIDITY_UNKNOWN;
673 _dbus_verbose ("changing body len from %u to %u by adjust %d\n",
674 old_body_len, new_body_len, adjust);
676 _dbus_marshal_set_uint32 (data, BODY_LENGTH_OFFSET,
685 generate_byte_changed (DBusMessageDataIter *iter,
687 DBusValidity *expected_validity)
692 /* This is a little convoluted to make the bodies the
693 * outer loop and each byte of each body the inner
698 if (!generate_many_bodies (iter, data, expected_validity))
702 byte_seq = iter_get_sequence (iter);
704 iter_unrecurse (iter);
706 if (byte_seq == _dbus_string_get_length (data))
708 _dbus_string_set_length (data, 0);
709 /* reset byte count */
711 iter_set_sequence (iter, 0);
712 iter_unrecurse (iter);
717 /* Undo the "next" in generate_many_bodies */
718 iter_set_sequence (iter, iter_get_sequence (iter) - 1);
721 _dbus_assert (byte_seq < _dbus_string_get_length (data));
722 v_BYTE = _dbus_string_get_byte (data, byte_seq);
723 v_BYTE += byte_seq; /* arbitrary but deterministic change to the byte */
724 _dbus_string_set_byte (data, byte_seq, v_BYTE);
725 *expected_validity = DBUS_VALIDITY_UNKNOWN;
731 find_next_typecode (DBusMessageDataIter *iter,
733 DBusValidity *expected_validity)
739 base_depth = iter->depth;
742 _dbus_assert (iter->depth == (base_depth + 0));
743 _dbus_string_set_length (data, 0);
745 body_seq = iter_get_sequence (iter);
747 if (!generate_many_bodies (iter, data, expected_validity))
749 /* Undo the "next" in generate_many_bodies */
750 iter_set_sequence (iter, body_seq);
755 _dbus_assert (iter->depth == (base_depth + 1));
757 byte_seq = iter_get_sequence (iter);
759 _dbus_assert (byte_seq <= _dbus_string_get_length (data));
761 if (byte_seq == _dbus_string_get_length (data))
763 /* reset byte count */
764 iter_set_sequence (iter, 0);
765 iter_unrecurse (iter);
766 _dbus_assert (iter->depth == (base_depth + 0));
767 iter_next (iter); /* go to the next body */
771 _dbus_assert (byte_seq < _dbus_string_get_length (data));
773 if (_dbus_type_is_valid (_dbus_string_get_byte (data, byte_seq)))
779 _dbus_assert (byte_seq == iter_get_sequence (iter));
780 _dbus_assert (byte_seq < _dbus_string_get_length (data));
782 iter_unrecurse (iter);
784 _dbus_assert (iter->depth == (base_depth + 0));
789 static const int typecodes[] = {
801 DBUS_TYPE_OBJECT_PATH,
805 DBUS_STRUCT_BEGIN_CHAR,
806 DBUS_STRUCT_END_CHAR,
807 DBUS_DICT_ENTRY_BEGIN_CHAR,
808 DBUS_DICT_ENTRY_END_CHAR,
809 255 /* random invalid typecode */
813 generate_typecode_changed (DBusMessageDataIter *iter,
815 DBusValidity *expected_validity)
821 base_depth = iter->depth;
824 _dbus_assert (iter->depth == (base_depth + 0));
825 _dbus_string_set_length (data, 0);
827 if (!find_next_typecode (iter, data, expected_validity))
831 byte_seq = iter_get_sequence (iter);
833 _dbus_assert (byte_seq < _dbus_string_get_length (data));
836 typecode_seq = iter_get_sequence (iter);
839 _dbus_assert (typecode_seq <= _DBUS_N_ELEMENTS (typecodes));
841 if (typecode_seq == _DBUS_N_ELEMENTS (typecodes))
843 _dbus_assert (iter->depth == (base_depth + 2));
844 iter_set_sequence (iter, 0); /* reset typecode sequence */
845 iter_unrecurse (iter);
846 _dbus_assert (iter->depth == (base_depth + 1));
847 iter_next (iter); /* go to the next byte_seq */
848 iter_unrecurse (iter);
849 _dbus_assert (iter->depth == (base_depth + 0));
853 _dbus_assert (iter->depth == (base_depth + 2));
854 iter_unrecurse (iter);
855 _dbus_assert (iter->depth == (base_depth + 1));
856 iter_unrecurse (iter);
857 _dbus_assert (iter->depth == (base_depth + 0));
860 printf ("Changing byte %d in message %d to %c\n",
861 byte_seq, iter_get_sequence (iter), typecodes[typecode_seq]);
864 _dbus_string_set_byte (data, byte_seq, typecodes[typecode_seq]);
865 *expected_validity = DBUS_VALIDITY_UNKNOWN;
872 dbus_uint32_t value; /* cast to signed for adjusts */
875 static const UIntChange uint32_changes[] = {
876 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) -1 },
877 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) -2 },
878 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) -3 },
879 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) 1 },
880 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) 2 },
881 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) 3 },
882 { CHANGE_TYPE_ABSOLUTE, _DBUS_UINT32_MAX },
883 { CHANGE_TYPE_ABSOLUTE, 0 },
884 { CHANGE_TYPE_ABSOLUTE, 1 },
885 { CHANGE_TYPE_ABSOLUTE, _DBUS_UINT32_MAX - 1 },
886 { CHANGE_TYPE_ABSOLUTE, _DBUS_UINT32_MAX - 5 }
890 generate_uint32_changed (DBusMessageDataIter *iter,
892 DBusValidity *expected_validity)
897 dbus_uint32_t v_UINT32;
899 const UIntChange *change;
902 /* Outer loop is each body, next loop is each change,
903 * inner loop is each change location
906 base_depth = iter->depth;
909 _dbus_assert (iter->depth == (base_depth + 0));
910 _dbus_string_set_length (data, 0);
911 body_seq = iter_get_sequence (iter);
913 if (!generate_many_bodies (iter, data, expected_validity))
916 _dbus_assert (iter->depth == (base_depth + 0));
918 iter_set_sequence (iter, body_seq); /* undo the "next" from generate_many_bodies */
921 _dbus_assert (iter->depth == (base_depth + 1));
922 change_seq = iter_get_sequence (iter);
924 if (change_seq == _DBUS_N_ELEMENTS (uint32_changes))
926 /* Reset change count */
927 iter_set_sequence (iter, 0);
928 iter_unrecurse (iter);
933 _dbus_assert (iter->depth == (base_depth + 1));
936 _dbus_assert (iter->depth == (base_depth + 2));
937 byte_seq = iter_get_sequence (iter);
938 /* skip 4 bytes at a time */
943 iter_unrecurse (iter);
945 _dbus_assert (_DBUS_ALIGN_VALUE (byte_seq, 4) == (unsigned) byte_seq);
946 if (byte_seq >= (_dbus_string_get_length (data) - 4))
948 /* reset byte count */
949 _dbus_assert (iter->depth == (base_depth + 1));
951 _dbus_assert (iter->depth == (base_depth + 2));
952 iter_set_sequence (iter, 0);
953 iter_unrecurse (iter);
954 _dbus_assert (iter->depth == (base_depth + 1));
959 _dbus_assert (byte_seq <= (_dbus_string_get_length (data) - 4));
961 byte_order = _dbus_string_get_byte (data, BYTE_ORDER_OFFSET);
963 v_UINT32 = _dbus_marshal_read_uint32 (data, byte_seq, byte_order, NULL);
965 change = &uint32_changes[change_seq];
967 if (change->type == CHANGE_TYPE_ADJUST)
969 v_UINT32 += (int) change->value;
973 v_UINT32 = change->value;
977 printf ("body %d change %d pos %d ",
978 body_seq, change_seq, byte_seq);
980 if (change->type == CHANGE_TYPE_ADJUST)
981 printf ("adjust by %d", (int) change->value);
983 printf ("set to %u", change->value);
985 printf (" \t%u -> %u\n",
986 _dbus_marshal_read_uint32 (data, byte_seq, byte_order, NULL),
990 _dbus_marshal_set_uint32 (data, byte_seq, v_UINT32, byte_order);
991 *expected_validity = DBUS_VALIDITY_UNKNOWN;
993 _dbus_assert (iter->depth == (base_depth + 1));
994 iter_unrecurse (iter);
995 _dbus_assert (iter->depth == (base_depth + 0));
1003 DBusMessageGeneratorFunc func;
1004 } DBusMessageGenerator;
1006 static const DBusMessageGenerator generators[] = {
1007 { "trivial example of each message type", generate_trivial },
1008 { "assorted arguments", generate_many_bodies },
1009 { "assorted special cases", generate_special },
1010 { "each uint32 modified", generate_uint32_changed },
1011 { "wrong body lengths", generate_wrong_length },
1012 { "each byte modified", generate_byte_changed },
1014 /* This is really expensive and doesn't add too much coverage */
1015 { "change each typecode", generate_typecode_changed }
1020 _dbus_message_data_free (DBusMessageData *data)
1022 _dbus_string_free (&data->data);
1026 _dbus_message_data_iter_init (DBusMessageDataIter *iter)
1032 while (i < _DBUS_MESSAGE_DATA_MAX_NESTING)
1034 iter->sequence_nos[i] = 0;
1041 _dbus_message_data_iter_get_and_next (DBusMessageDataIter *iter,
1042 DBusMessageData *data)
1044 DBusMessageGeneratorFunc func;
1048 generator = iter_get_sequence (iter);
1050 if (generator == _DBUS_N_ELEMENTS (generators))
1053 iter_recurse (iter);
1055 if (iter_first_in_series (iter))
1057 printf (" testing message loading: %s ", generators[generator].name);
1061 func = generators[generator].func;
1063 if (!_dbus_string_init (&data->data))
1064 _dbus_assert_not_reached ("oom");
1066 if ((*func)(iter, &data->data, &data->expected_validity))
1070 iter_set_sequence (iter, 0);
1071 iter_unrecurse (iter);
1072 iter_next (iter); /* next generator */
1073 _dbus_string_free (&data->data);
1074 printf ("%d test loads cumulative\n", iter->count);
1077 iter_unrecurse (iter);
1083 #endif /* DBUS_BUILD_TESTS */