25 #ifndef DOXYGEN_SHOULD_SKIP_THIS 
   27 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 
   28 #include "dbus-message-factory.h" 
   29 #include "dbus-message-private.h" 
   30 #include "dbus-signature.h" 
   31 #include "dbus-test.h" 
   40 #define BYTE_ORDER_OFFSET  0 
   42 #define BODY_LENGTH_OFFSET 4 
   43 #define FIELDS_ARRAY_LENGTH_OFFSET 12 
   46 iter_recurse (DBusMessageDataIter *iter)
 
   49   _dbus_assert (iter->depth < _DBUS_MESSAGE_DATA_MAX_NESTING);
 
   54 iter_get_sequence (DBusMessageDataIter *iter)
 
   57   return iter->sequence_nos[iter->depth];
 
   61 iter_set_sequence (DBusMessageDataIter *iter,
 
   65   iter->sequence_nos[iter->depth] = sequence;
 
   69 iter_unrecurse (DBusMessageDataIter *iter)
 
   76 iter_next (DBusMessageDataIter *iter)
 
   78   iter->sequence_nos[iter->depth] += 1;
 
   82 iter_first_in_series (DBusMessageDataIter *iter)
 
   87   while (i < _DBUS_MESSAGE_DATA_MAX_NESTING)
 
   89       if (iter->sequence_nos[i] != 0)
 
   96 typedef dbus_bool_t (* DBusInnerGeneratorFunc)   (DBusMessageDataIter *iter,
 
   98 typedef dbus_bool_t (* DBusMessageGeneratorFunc) (DBusMessageDataIter *iter,
 
  112 generate_trivial_inner (DBusMessageDataIter *iter,
 
  117   switch (iter_get_sequence (iter))
 
  122                                               "org.freedesktop.DocumentFactory",
 
  127       set_reply_serial (message);
 
  131                                          "org.freedesktop.DocumentFactory",
 
  138                                         "org.freedesktop.TestErrorName"))
 
  143         const char *v_STRING = 
"This is an error";
 
  152       set_reply_serial (message);
 
  161   *message_p = message;
 
  167 generate_many_bodies_inner (DBusMessageDataIter *iter,
 
  185   set_reply_serial (message);
 
  190   if (dbus_internal_do_not_use_generate_bodies (iter_get_sequence (iter),
 
  194       const char *v_SIGNATURE;
 
  196       v_SIGNATURE = _dbus_string_get_const_data (&signature);
 
  207                                 _dbus_string_get_length (&message->
body),
 
  210       *message_p = message;
 
  221   return *message_p != 
NULL;
 
  240                           data, _dbus_string_get_length (data)))
 
  245 generate_outer (DBusMessageDataIter   *iter,
 
  248                 DBusInnerGeneratorFunc func)
 
  253   if (!(*func)(iter, &message))
 
  260   generate_from_message (data, expected_validity, message);
 
  268 generate_trivial (DBusMessageDataIter   *iter,
 
  272   return generate_outer (iter, data, expected_validity,
 
  273                          generate_trivial_inner);
 
  277 generate_many_bodies (DBusMessageDataIter   *iter,
 
  281   return generate_outer (iter, data, expected_validity,
 
  282                          generate_many_bodies_inner);
 
  286 simple_method_call (
void)
 
  312 simple_method_return (
void)
 
  319   set_reply_serial (message);
 
  335   set_reply_serial (message);
 
  341 message_with_nesting_levels (
int levels)
 
  359   message = simple_method_call ();
 
  372       parents[i] = children[i-1];
 
  393 generate_special (DBusMessageDataIter   *iter,
 
  407   item_seq = iter_get_sequence (iter);
 
  411       message = simple_method_call ();
 
  422       generate_from_message (data, expected_validity, message);
 
  425       _dbus_string_set_byte (data, pos + 1, 
'$');
 
  427       *expected_validity = DBUS_INVALID_UNKNOWN_TYPECODE;
 
  429   else if (item_seq == 1)
 
  432       const char *v_STRING;
 
  435       message = simple_method_call ();
 
  461       generate_from_message (data, expected_validity, message);
 
  463       *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION;
 
  465   else if (item_seq == 2)
 
  468       const char *v_STRING;
 
  471       message = simple_method_call ();
 
  506       generate_from_message (data, expected_validity, message);
 
  508       *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION;
 
  510   else if (item_seq == 3)
 
  512       message = simple_method_call ();
 
  523       generate_from_message (data, expected_validity, message);
 
  527       *expected_validity = DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED;
 
  529   else if (item_seq == 4)
 
  531       message = simple_method_call ();
 
  542       generate_from_message (data, expected_validity, message);
 
  546       *expected_validity = DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED;
 
  548   else if (item_seq == 5)
 
  550       message = simple_method_call ();
 
  561       generate_from_message (data, expected_validity, message);
 
  566       *expected_validity = DBUS_INVALID_STRUCT_HAS_NO_FIELDS;
 
  568   else if (item_seq == 6)
 
  570       message = simple_method_call ();
 
  571       generate_from_message (data, expected_validity, message);
 
  575       *expected_validity = DBUS_INVALID_BAD_MESSAGE_TYPE;
 
  577   else if (item_seq == 7)
 
  580       message = simple_method_call ();
 
  581       generate_from_message (data, expected_validity, message);
 
  587   else if (item_seq == 8)
 
  591       message = simple_method_call ();
 
  593       generate_from_message (data, expected_validity, message);
 
  601       *expected_validity = DBUS_INVALID_MESSAGE_TOO_LONG;
 
  603   else if (item_seq == 9)
 
  605       const char *v_STRING = 
"not a valid bus name";
 
  606       message = simple_method_call ();
 
  613       generate_from_message (data, expected_validity, message);
 
  615       *expected_validity = DBUS_INVALID_BAD_SENDER;
 
  617   else if (item_seq == 10)
 
  619       message = simple_method_call ();
 
  624       generate_from_message (data, expected_validity, message);
 
  626       *expected_validity = DBUS_INVALID_USES_LOCAL_INTERFACE;
 
  628   else if (item_seq == 11)
 
  630       message = simple_method_call ();
 
  635       generate_from_message (data, expected_validity, message);
 
  637       *expected_validity = DBUS_INVALID_USES_LOCAL_PATH;
 
  639   else if (item_seq == 12)
 
  642       message = simple_method_call ();
 
  647       generate_from_message (data, expected_validity, message);
 
  651   else if (item_seq == 13)
 
  654       message = simple_signal ();
 
  659       generate_from_message (data, expected_validity, message);
 
  661       *expected_validity = DBUS_INVALID_MISSING_INTERFACE;
 
  663   else if (item_seq == 14)
 
  665       message = simple_method_return ();
 
  670       generate_from_message (data, expected_validity, message);
 
  672       *expected_validity = DBUS_INVALID_MISSING_REPLY_SERIAL;
 
  674   else if (item_seq == 15)
 
  676       message = simple_error ();
 
  681       generate_from_message (data, expected_validity, message);
 
  683       *expected_validity = DBUS_INVALID_MISSING_ERROR_NAME;
 
  685   else if (item_seq == 16)
 
  688       const char *v_STRING;
 
  692       message = simple_method_call ();
 
  733       generate_from_message (data, expected_validity, message);
 
  735       *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_DICT_ENTRY_RECURSION;
 
  737   else if (item_seq == 17)
 
  739       message = simple_method_call ();
 
  750       generate_from_message (data, expected_validity, message);
 
  755       *expected_validity = DBUS_INVALID_DICT_ENTRY_STARTED_BUT_NOT_ENDED;
 
  757   else if (item_seq == 18)
 
  759       message = simple_method_call ();
 
  770       generate_from_message (data, expected_validity, message);
 
  774       *expected_validity = DBUS_INVALID_DICT_ENTRY_ENDED_BUT_NOT_STARTED;
 
  776   else if (item_seq == 19)
 
  778       message = simple_method_call ();
 
  789       generate_from_message (data, expected_validity, message);
 
  795       *expected_validity = DBUS_INVALID_DICT_ENTRY_HAS_NO_FIELDS;
 
  797   else if (item_seq == 20)
 
  800       message = message_with_nesting_levels(64);
 
  802       generate_from_message (data, expected_validity, message);
 
  806   else if (item_seq == 21)
 
  809       message = message_with_nesting_levels(65);
 
  811       generate_from_message (data, expected_validity, message);
 
  813       *expected_validity = DBUS_INVALID_NESTED_TOO_DEEPLY;
 
  828 generate_wrong_length (DBusMessageDataIter *iter,
 
  832   int lengths[] = { -42, -17, -16, -15, -9, -8, -7, -6, -5, -4, -3, -2, -1,
 
  833                     1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16, 30 };
 
  838   len_seq = iter_get_sequence (iter);
 
  845   if (!generate_many_bodies (iter, data, expected_validity))
 
  847       iter_set_sequence (iter, 0); 
 
  848       iter_unrecurse (iter);
 
  852   iter_unrecurse (iter);
 
  854   adjust = lengths[len_seq];
 
  862       *expected_validity = DBUS_INVALID_FOR_UNKNOWN_REASON;
 
  884     _dbus_assert (old_body_len < _dbus_string_get_length (data));
 
  885     new_body_len = old_body_len + adjust;
 
  886     if (new_body_len < 0)
 
  890         *expected_validity = DBUS_VALIDITY_UNKNOWN;
 
  893     _dbus_verbose (
"changing body len from %u to %u by adjust %d\n",
 
  894                    old_body_len, new_body_len, adjust);
 
  905 generate_byte_changed (DBusMessageDataIter *iter,
 
  918   if (!generate_many_bodies (iter, data, expected_validity))
 
  922   byte_seq = iter_get_sequence (iter);
 
  924   iter_unrecurse (iter);
 
  926   if (byte_seq == _dbus_string_get_length (data))
 
  931       iter_set_sequence (iter, 0);
 
  932       iter_unrecurse (iter);
 
  938       iter_set_sequence (iter, iter_get_sequence (iter) - 1);
 
  941   _dbus_assert (byte_seq < _dbus_string_get_length (data));
 
  942   v_BYTE = _dbus_string_get_byte (data, byte_seq);
 
  944   _dbus_string_set_byte (data, byte_seq, v_BYTE);
 
  945   *expected_validity = DBUS_VALIDITY_UNKNOWN;
 
  954 find_next_typecode (DBusMessageDataIter *iter,
 
  962   base_depth = iter->depth;
 
  968   body_seq = iter_get_sequence (iter);
 
  970   if (!generate_many_bodies (iter, data, expected_validity))
 
  973   iter_set_sequence (iter, body_seq);
 
  980       byte_seq = iter_get_sequence (iter);
 
  982       _dbus_assert (byte_seq <= _dbus_string_get_length (data));
 
  984       if (byte_seq == _dbus_string_get_length (data))
 
  987           iter_set_sequence (iter, 0);
 
  988           iter_unrecurse (iter);
 
  994       _dbus_assert (byte_seq < _dbus_string_get_length (data));
 
 1003   _dbus_assert (byte_seq < _dbus_string_get_length (data));
 
 1005   iter_unrecurse (iter);
 
 1012 static const int typecodes[] = {
 
 1037 generate_typecode_changed (DBusMessageDataIter *iter,
 
 1045   base_depth = iter->depth;
 
 1051   if (!find_next_typecode (iter, data, expected_validity))
 
 1054   iter_recurse (iter);
 
 1055   byte_seq = iter_get_sequence (iter);
 
 1057   _dbus_assert (byte_seq < _dbus_string_get_length (data));
 
 1059   iter_recurse (iter);
 
 1060   typecode_seq = iter_get_sequence (iter);
 
 1068       iter_set_sequence (iter, 0); 
 
 1069       iter_unrecurse (iter);
 
 1072       iter_unrecurse (iter);
 
 1078   iter_unrecurse (iter);
 
 1080   iter_unrecurse (iter);
 
 1084   printf (
"Changing byte %d in message %d to %c\n",
 
 1085           byte_seq, iter_get_sequence (iter), typecodes[typecode_seq]);
 
 1088   _dbus_string_set_byte (data, byte_seq, typecodes[typecode_seq]);
 
 1089   *expected_validity = DBUS_VALIDITY_UNKNOWN;
 
 1100 static const UIntChange uint32_changes[] = {
 
 1108   { CHANGE_TYPE_ABSOLUTE, 0 },
 
 1109   { CHANGE_TYPE_ABSOLUTE, 1 },
 
 1115 generate_uint32_changed (DBusMessageDataIter *iter,
 
 1124   const UIntChange *change;
 
 1131   base_depth = iter->depth;
 
 1136   body_seq = iter_get_sequence (iter);
 
 1138   if (!generate_many_bodies (iter, data, expected_validity))
 
 1143   iter_set_sequence (iter, body_seq); 
 
 1144   iter_recurse (iter);
 
 1147   change_seq = iter_get_sequence (iter);
 
 1152       iter_set_sequence (iter, 0);
 
 1153       iter_unrecurse (iter);
 
 1160   iter_recurse (iter);
 
 1162   byte_seq = iter_get_sequence (iter);
 
 1168   iter_unrecurse (iter);
 
 1170   _dbus_assert (_DBUS_ALIGN_VALUE (byte_seq, 4) == (
unsigned) byte_seq);
 
 1171   if (byte_seq >= (_dbus_string_get_length (data) - 4))
 
 1175       iter_recurse (iter);
 
 1177       iter_set_sequence (iter, 0);
 
 1178       iter_unrecurse (iter);
 
 1184   _dbus_assert (byte_seq <= (_dbus_string_get_length (data) - 4));
 
 1190   change = &uint32_changes[change_seq];
 
 1192   if (change->type == CHANGE_TYPE_ADJUST)
 
 1194       v_UINT32 += (int) change->value;
 
 1198       v_UINT32 = change->value;
 
 1202   printf (
"body %d change %d pos %d ",
 
 1203           body_seq, change_seq, byte_seq);
 
 1205   if (change->type == CHANGE_TYPE_ADJUST)
 
 1206     printf (
"adjust by %d", (
int) change->value);
 
 1208     printf (
"set to %u", change->value);
 
 1210   printf (
" \t%u -> %u\n",
 
 1216   *expected_validity = DBUS_VALIDITY_UNKNOWN;
 
 1219   iter_unrecurse (iter);
 
 1228   DBusMessageGeneratorFunc func;  
 
 1229 } DBusMessageGenerator;
 
 1231 static const DBusMessageGenerator generators[] = {
 
 1232   { 
"trivial example of each message type", generate_trivial },
 
 1233   { 
"assorted arguments", generate_many_bodies },
 
 1234   { 
"assorted special cases", generate_special },
 
 1235   { 
"each uint32 modified", generate_uint32_changed },
 
 1236   { 
"wrong body lengths", generate_wrong_length },
 
 1237   { 
"each byte modified", generate_byte_changed },
 
 1240   { 
"change each typecode", generate_typecode_changed }
 
 1245 _dbus_message_data_free (DBusMessageData *data)
 
 1251 _dbus_message_data_iter_init (DBusMessageDataIter *iter)
 
 1257   while (i < _DBUS_MESSAGE_DATA_MAX_NESTING)
 
 1259       iter->sequence_nos[i] = 0;
 
 1266 _dbus_message_data_iter_get_and_next (DBusMessageDataIter *iter,
 
 1267                                       DBusMessageData     *data)
 
 1269   DBusMessageGeneratorFunc func;
 
 1273   generator = iter_get_sequence (iter);
 
 1278   iter_recurse (iter);
 
 1280   if (iter_first_in_series (iter))
 
 1282       printf (
" testing message loading: %s ", generators[generator].name);
 
 1286   func = generators[generator].func;
 
 1291   if ((*func)(iter, &data->data, &data->expected_validity))
 
 1295       iter_set_sequence (iter, 0);
 
 1296       iter_unrecurse (iter);
 
 1299       printf (
"%d test loads cumulative\n", iter->count);
 
 1302   iter_unrecurse (iter);