dbus/dbus-message-util.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* dbus-message-util.c Would be in dbus-message.c, but only used by bus/tests
   3  *
   4  * Copyright (C) 2002, 2003, 2004, 2005  Red Hat Inc.
   5  * Copyright (C) 2002, 2003  CodeFactory AB
   6  *
   7  * Licensed under the Academic Free License version 2.1
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  */
  24
  25 #include "dbus-internals.h"
  26 #include "dbus-test.h"
  27 #include "dbus-message-private.h"
  28 #include "dbus-marshal-recursive.h"
  29 #include "dbus-string.h"
  30
  31 /**
  32  * @addtogroup DBusMessage
  33  * @{
  34  */
  35
  36 #ifdef DBUS_BUILD_TESTS
  37 /**
  38  * Reads arguments from a message iterator given a variable argument
  39  * list. Only arguments of basic type and arrays of fixed-length
  40  * basic type may be read with this function. See
  41  * dbus_message_get_args() for more details.
  42  *
  43  * @todo this is static for now because there's no corresponding
  44  * iter_append_args() and I'm not sure we need this function to be
  45  * public since dbus_message_get_args() is what you usually want
  46  *
  47  * @param iter the message iterator
  48  * @param error error to be filled in on failure
  49  * @param first_arg_type the first argument type
  50  * @param ... location for first argument value, then list of type-location pairs
  51  * @returns #FALSE if the error was set
  52  */
  53 static dbus_bool_t
  54 dbus_message_iter_get_args (DBusMessageIter *iter,
  55                             DBusError       *error,
  56                             int              first_arg_type,
  57                             ...)
  58 {
  59   dbus_bool_t retval;
  60   va_list var_args;
  61
  62   _dbus_return_val_if_fail (iter != NULL, FALSE);
  63   _dbus_return_val_if_error_is_set (error, FALSE);
  64
  65   va_start (var_args, first_arg_type);
  66   retval = _dbus_message_iter_get_args_valist (iter, error, first_arg_type, var_args);
  67   va_end (var_args);
  68
  69   return retval;
  70 }
  71 #endif /* DBUS_BUILD_TESTS */
  72
  73 /** @} */
  74
  75 #ifdef DBUS_BUILD_TESTS
  76 #include "dbus-test.h"
  77 #include <stdio.h>
  78 #include <stdlib.h>
  79
  80 static dbus_bool_t
  81 check_have_valid_message (DBusMessageLoader *loader)
  82 {
  83   DBusMessage *message;
  84   dbus_bool_t retval;
  85
  86   message = NULL;
  87   retval = FALSE;
  88
  89   if (!_dbus_message_loader_queue_messages (loader))
  90     _dbus_assert_not_reached ("no memory to queue messages");
  91
  92   if (_dbus_message_loader_get_is_corrupted (loader))
  93     {
  94       _dbus_warn ("loader corrupted on message that was expected to be valid\n");
  95       goto failed;
  96     }
  97
  98   message = _dbus_message_loader_pop_message (loader);
  99   if (message == NULL)
 100     {
 101       _dbus_warn ("didn't load message that was expected to be valid (message not popped)\n");
 102       goto failed;
 103     }
 104
 105   if (_dbus_string_get_length (&loader->data) > 0)
 106     {
 107       _dbus_warn ("had leftover bytes from expected-to-be-valid single message\n");
 108       goto failed;
 109     }
 110
 111 #if 0
 112   /* FIXME */
 113   /* Verify that we're able to properly deal with the message.
 114    * For example, this would detect improper handling of messages
 115    * in nonstandard byte order.
 116    */
 117   if (!check_message_handling (message))
 118     goto failed;
 119 #endif
 120
 121   retval = TRUE;
 122
 123  failed:
 124   if (message)
 125     dbus_message_unref (message);
 126
 127   return retval;
 128 }
 129
 130 static dbus_bool_t
 131 check_invalid_message (DBusMessageLoader *loader)
 132 {
 133   dbus_bool_t retval;
 134
 135   retval = FALSE;
 136
 137   if (!_dbus_message_loader_queue_messages (loader))
 138     _dbus_assert_not_reached ("no memory to queue messages");
 139
 140   if (!_dbus_message_loader_get_is_corrupted (loader))
 141     {
 142       _dbus_warn ("loader not corrupted on message that was expected to be invalid\n");
 143       goto failed;
 144     }
 145
 146   retval = TRUE;
 147
 148  failed:
 149   return retval;
 150 }
 151
 152 static dbus_bool_t
 153 check_incomplete_message (DBusMessageLoader *loader)
 154 {
 155   DBusMessage *message;
 156   dbus_bool_t retval;
 157
 158   message = NULL;
 159   retval = FALSE;
 160
 161   if (!_dbus_message_loader_queue_messages (loader))
 162     _dbus_assert_not_reached ("no memory to queue messages");
 163
 164   if (_dbus_message_loader_get_is_corrupted (loader))
 165     {
 166       _dbus_warn ("loader corrupted on message that was expected to be valid (but incomplete)\n");
 167       goto failed;
 168     }
 169
 170   message = _dbus_message_loader_pop_message (loader);
 171   if (message != NULL)
 172     {
 173       _dbus_warn ("loaded message that was expected to be incomplete\n");
 174       goto failed;
 175     }
 176
 177   retval = TRUE;
 178
 179  failed:
 180   if (message)
 181     dbus_message_unref (message);
 182   return retval;
 183 }
 184
 185 static dbus_bool_t
 186 check_loader_results (DBusMessageLoader      *loader,
 187                       DBusMessageValidity     validity)
 188 {
 189   if (!_dbus_message_loader_queue_messages (loader))
 190     _dbus_assert_not_reached ("no memory to queue messages");
 191
 192   switch (validity)
 193     {
 194     case _DBUS_MESSAGE_VALID:
 195       return check_have_valid_message (loader);
 196     case _DBUS_MESSAGE_INVALID:
 197       return check_invalid_message (loader);
 198     case _DBUS_MESSAGE_INCOMPLETE:
 199       return check_incomplete_message (loader);
 200     case _DBUS_MESSAGE_UNKNOWN:
 201       return TRUE;
 202     }
 203
 204   _dbus_assert_not_reached ("bad DBusMessageValidity");
 205   return FALSE;
 206 }
 207
 208
 209 /**
 210  * Loads the message in the given message file.
 211  *
 212  * @param filename filename to load
 213  * @param is_raw if #TRUE load as binary data, if #FALSE as message builder language
 214  * @param data string to load message into
 215  * @returns #TRUE if the message was loaded
 216  */
 217 dbus_bool_t
 218 dbus_internal_do_not_use_load_message_file (const DBusString    *filename,
 219                                             dbus_bool_t          is_raw,
 220                                             DBusString          *data)
 221 {
 222   dbus_bool_t retval;
 223
 224   retval = FALSE;
 225
 226   if (is_raw)
 227     {
 228       DBusError error;
 229
 230       _dbus_verbose ("Loading raw %s\n", _dbus_string_get_const_data (filename));
 231       dbus_error_init (&error);
 232       if (!_dbus_file_get_contents (data, filename, &error))
 233         {
 234           _dbus_warn ("Could not load message file %s: %s\n",
 235                       _dbus_string_get_const_data (filename),
 236                       error.message);
 237           dbus_error_free (&error);
 238           goto failed;
 239         }
 240     }
 241   else
 242     {
 243       if (FALSE) /* Message builder disabled, probably permanently,
 244                   * I want to do it another way
 245                   */
 246         {
 247           _dbus_warn ("Could not load message file %s\n",
 248                       _dbus_string_get_const_data (filename));
 249           goto failed;
 250         }
 251     }
 252
 253   retval = TRUE;
 254
 255  failed:
 256
 257   return retval;
 258 }
 259
 260 /**
 261  * Tries loading the message in the given message file
 262  * and verifies that DBusMessageLoader can handle it.
 263  *
 264  * @param filename filename to load
 265  * @param is_raw if #TRUE load as binary data, if #FALSE as message builder language
 266  * @param expected_validity what the message has to be like to return #TRUE
 267  * @returns #TRUE if the message has the expected validity
 268  */
 269 dbus_bool_t
 270 dbus_internal_do_not_use_try_message_file (const DBusString    *filename,
 271                                            dbus_bool_t          is_raw,
 272                                            DBusMessageValidity  expected_validity)
 273 {
 274   DBusString data;
 275   dbus_bool_t retval;
 276
 277   retval = FALSE;
 278
 279   if (!_dbus_string_init (&data))
 280     _dbus_assert_not_reached ("could not allocate string\n");
 281
 282   if (!dbus_internal_do_not_use_load_message_file (filename, is_raw,
 283                                                    &data))
 284     goto failed;
 285
 286   retval = dbus_internal_do_not_use_try_message_data (&data, expected_validity);
 287
 288  failed:
 289
 290   if (!retval)
 291     {
 292       if (_dbus_string_get_length (&data) > 0)
 293         _dbus_verbose_bytes_of_string (&data, 0,
 294                                        _dbus_string_get_length (&data));
 295
 296       _dbus_warn ("Failed message loader test on %s\n",
 297                   _dbus_string_get_const_data (filename));
 298     }
 299
 300   _dbus_string_free (&data);
 301
 302   return retval;
 303 }
 304
 305 /**
 306  * Tries loading the given message data.
 307  *
 308  *
 309  * @param data the message data
 310  * @param expected_validity what the message has to be like to return #TRUE
 311  * @returns #TRUE if the message has the expected validity
 312  */
 313 dbus_bool_t
 314 dbus_internal_do_not_use_try_message_data (const DBusString    *data,
 315                                            DBusMessageValidity  expected_validity)
 316 {
 317   DBusMessageLoader *loader;
 318   dbus_bool_t retval;
 319   int len;
 320   int i;
 321
 322   loader = NULL;
 323   retval = FALSE;
 324
 325   /* Write the data one byte at a time */
 326
 327   loader = _dbus_message_loader_new ();
 328
 329   /* check some trivial loader functions */
 330   _dbus_message_loader_ref (loader);
 331   _dbus_message_loader_unref (loader);
 332   _dbus_message_loader_get_max_message_size (loader);
 333
 334   len = _dbus_string_get_length (data);
 335   for (i = 0; i < len; i++)
 336     {
 337       DBusString *buffer;
 338
 339       _dbus_message_loader_get_buffer (loader, &buffer);
 340       _dbus_string_append_byte (buffer,
 341                                 _dbus_string_get_byte (data, i));
 342       _dbus_message_loader_return_buffer (loader, buffer, 1);
 343     }
 344
 345   if (!check_loader_results (loader, expected_validity))
 346     goto failed;
 347
 348   _dbus_message_loader_unref (loader);
 349   loader = NULL;
 350
 351   /* Write the data all at once */
 352
 353   loader = _dbus_message_loader_new ();
 354
 355   {
 356     DBusString *buffer;
 357
 358     _dbus_message_loader_get_buffer (loader, &buffer);
 359     _dbus_string_copy (data, 0, buffer,
 360                        _dbus_string_get_length (buffer));
 361     _dbus_message_loader_return_buffer (loader, buffer, 1);
 362   }
 363
 364   if (!check_loader_results (loader, expected_validity))
 365     goto failed;
 366
 367   _dbus_message_loader_unref (loader);
 368   loader = NULL;
 369
 370   /* Write the data 2 bytes at a time */
 371
 372   loader = _dbus_message_loader_new ();
 373
 374   len = _dbus_string_get_length (data);
 375   for (i = 0; i < len; i += 2)
 376     {
 377       DBusString *buffer;
 378
 379       _dbus_message_loader_get_buffer (loader, &buffer);
 380       _dbus_string_append_byte (buffer,
 381                                 _dbus_string_get_byte (data, i));
 382       if ((i+1) < len)
 383         _dbus_string_append_byte (buffer,
 384                                   _dbus_string_get_byte (data, i+1));
 385       _dbus_message_loader_return_buffer (loader, buffer, 1);
 386     }
 387
 388   if (!check_loader_results (loader, expected_validity))
 389     goto failed;
 390
 391   _dbus_message_loader_unref (loader);
 392   loader = NULL;
 393
 394   retval = TRUE;
 395
 396  failed:
 397
 398   if (loader)
 399     _dbus_message_loader_unref (loader);
 400
 401   return retval;
 402 }
 403
 404 static dbus_bool_t
 405 process_test_subdir (const DBusString          *test_base_dir,
 406                      const char                *subdir,
 407                      DBusMessageValidity        validity,
 408                      DBusForeachMessageFileFunc function,
 409                      void                      *user_data)
 410 {
 411   DBusString test_directory;
 412   DBusString filename;
 413   DBusDirIter *dir;
 414   dbus_bool_t retval;
 415   DBusError error;
 416
 417   retval = FALSE;
 418   dir = NULL;
 419
 420   if (!_dbus_string_init (&test_directory))
 421     _dbus_assert_not_reached ("didn't allocate test_directory\n");
 422
 423   _dbus_string_init_const (&filename, subdir);
 424
 425   if (!_dbus_string_copy (test_base_dir, 0,
 426                           &test_directory, 0))
 427     _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
 428
 429   if (!_dbus_concat_dir_and_file (&test_directory, &filename))
 430     _dbus_assert_not_reached ("couldn't allocate full path");
 431
 432   _dbus_string_free (&filename);
 433   if (!_dbus_string_init (&filename))
 434     _dbus_assert_not_reached ("didn't allocate filename string\n");
 435
 436   dbus_error_init (&error);
 437   dir = _dbus_directory_open (&test_directory, &error);
 438   if (dir == NULL)
 439     {
 440       _dbus_warn ("Could not open %s: %s\n",
 441                   _dbus_string_get_const_data (&test_directory),
 442                   error.message);
 443       dbus_error_free (&error);
 444       goto failed;
 445     }
 446
 447   printf ("Testing %s:\n", subdir);
 448
 449  next:
 450   while (_dbus_directory_get_next_file (dir, &filename, &error))
 451     {
 452       DBusString full_path;
 453       dbus_bool_t is_raw;
 454
 455       if (!_dbus_string_init (&full_path))
 456         _dbus_assert_not_reached ("couldn't init string");
 457
 458       if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
 459         _dbus_assert_not_reached ("couldn't copy dir to full_path");
 460
 461       if (!_dbus_concat_dir_and_file (&full_path, &filename))
 462         _dbus_assert_not_reached ("couldn't concat file to dir");
 463
 464       if (_dbus_string_ends_with_c_str (&filename, ".message"))
 465         is_raw = FALSE;
 466       else if (_dbus_string_ends_with_c_str (&filename, ".message-raw"))
 467         is_raw = TRUE;
 468       else
 469         {
 470           _dbus_verbose ("Skipping non-.message file %s\n",
 471                          _dbus_string_get_const_data (&filename));
 472           _dbus_string_free (&full_path);
 473           goto next;
 474         }
 475
 476       printf ("    %s\n",
 477               _dbus_string_get_const_data (&filename));
 478
 479       _dbus_verbose (" expecting %s for %s\n",
 480                      validity == _DBUS_MESSAGE_VALID ? "valid" :
 481                      (validity == _DBUS_MESSAGE_INVALID ? "invalid" :
 482                       (validity == _DBUS_MESSAGE_INCOMPLETE ? "incomplete" : "unknown")),
 483                      _dbus_string_get_const_data (&filename));
 484
 485       if (! (*function) (&full_path, is_raw, validity, user_data))
 486         {
 487           _dbus_string_free (&full_path);
 488           goto failed;
 489         }
 490       else
 491         _dbus_string_free (&full_path);
 492     }
 493
 494   if (dbus_error_is_set (&error))
 495     {
 496       _dbus_warn ("Could not get next file in %s: %s\n",
 497                   _dbus_string_get_const_data (&test_directory),
 498                   error.message);
 499       dbus_error_free (&error);
 500       goto failed;
 501     }
 502
 503   retval = TRUE;
 504
 505  failed:
 506
 507   if (dir)
 508     _dbus_directory_close (dir);
 509   _dbus_string_free (&test_directory);
 510   _dbus_string_free (&filename);
 511
 512   return retval;
 513 }
 514
 515 /**
 516  * Runs the given function on every message file in the test suite.
 517  * The function should return #FALSE on test failure or fatal error.
 518  *
 519  * @param test_data_dir root dir of the test suite data files (top_srcdir/test/data)
 520  * @param func the function to run
 521  * @param user_data data for function
 522  * @returns #FALSE if there's a failure
 523  */
 524 dbus_bool_t
 525 dbus_internal_do_not_use_foreach_message_file (const char                *test_data_dir,
 526                                                DBusForeachMessageFileFunc func,
 527                                                void                      *user_data)
 528 {
 529   DBusString test_directory;
 530   dbus_bool_t retval;
 531
 532   retval = FALSE;
 533
 534   _dbus_string_init_const (&test_directory, test_data_dir);
 535
 536   if (!process_test_subdir (&test_directory, "valid-messages",
 537                             _DBUS_MESSAGE_VALID, func, user_data))
 538     goto failed;
 539
 540   if (!process_test_subdir (&test_directory, "invalid-messages",
 541                             _DBUS_MESSAGE_INVALID, func, user_data))
 542     goto failed;
 543
 544   if (!process_test_subdir (&test_directory, "incomplete-messages",
 545                             _DBUS_MESSAGE_INCOMPLETE, func, user_data))
 546     goto failed;
 547
 548   retval = TRUE;
 549
 550  failed:
 551
 552   _dbus_string_free (&test_directory);
 553
 554   return retval;
 555 }
 556
 557 #define GET_AND_CHECK(iter, typename, literal)                                  \
 558   do {                                                                          \
 559     if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename)         \
 560       _dbus_assert_not_reached ("got wrong argument type from message iter");   \
 561     dbus_message_iter_get_basic (&iter, &v_##typename);                         \
 562     if (v_##typename != literal)                                                \
 563       _dbus_assert_not_reached ("got wrong value from message iter");           \
 564   } while (0)
 565
 566 #define GET_AND_CHECK_STRCMP(iter, typename, literal)                           \
 567   do {                                                                          \
 568     if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename)         \
 569       _dbus_assert_not_reached ("got wrong argument type from message iter");   \
 570     dbus_message_iter_get_basic (&iter, &v_##typename);                         \
 571     if (strcmp (v_##typename, literal) != 0)                                    \
 572       _dbus_assert_not_reached ("got wrong value from message iter");           \
 573   } while (0)
 574
 575 #define GET_AND_CHECK_AND_NEXT(iter, typename, literal)         \
 576   do {                                                          \
 577     GET_AND_CHECK(iter, typename, literal);                     \
 578     if (!dbus_message_iter_next (&iter))                        \
 579       _dbus_assert_not_reached ("failed to move iter to next"); \
 580   } while (0)
 581
 582 #define GET_AND_CHECK_STRCMP_AND_NEXT(iter, typename, literal)  \
 583   do {                                                          \
 584     GET_AND_CHECK_STRCMP(iter, typename, literal);              \
 585     if (!dbus_message_iter_next (&iter))                        \
 586       _dbus_assert_not_reached ("failed to move iter to next"); \
 587   } while (0)
 588
 589 static void
 590 message_iter_test (DBusMessage *message)
 591 {
 592   DBusMessageIter iter, array, array2;
 593   const char *v_STRING;
 594   double v_DOUBLE;
 595   dbus_int32_t v_INT32;
 596   dbus_uint32_t v_UINT32;
 597 #ifdef DBUS_HAVE_INT64
 598   dbus_int64_t v_INT64;
 599   dbus_uint64_t v_UINT64;
 600 #endif
 601   unsigned char v_BYTE;
 602   dbus_bool_t v_BOOLEAN;
 603
 604   const dbus_int32_t *our_int_array;
 605   int len;
 606
 607   dbus_message_iter_init (message, &iter);
 608
 609   GET_AND_CHECK_STRCMP_AND_NEXT (iter, STRING, "Test string");
 610   GET_AND_CHECK_AND_NEXT (iter, INT32, -0x12345678);
 611   GET_AND_CHECK_AND_NEXT (iter, UINT32, 0xedd1e);
 612   GET_AND_CHECK_AND_NEXT (iter, DOUBLE, 3.14159);
 613
 614   if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
 615     _dbus_assert_not_reached ("Argument type not an array");
 616
 617   if (dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_DOUBLE)
 618     _dbus_assert_not_reached ("Array type not double");
 619
 620   dbus_message_iter_recurse (&iter, &array);
 621
 622   GET_AND_CHECK_AND_NEXT (array, DOUBLE, 1.5);
 623   GET_AND_CHECK (array, DOUBLE, 2.5);
 624
 625   if (dbus_message_iter_next (&array))
 626     _dbus_assert_not_reached ("Didn't reach end of array");
 627
 628   if (!dbus_message_iter_next (&iter))
 629     _dbus_assert_not_reached ("Reached end of arguments");
 630
 631   GET_AND_CHECK_AND_NEXT (iter, BYTE, 0xF0);
 632
 633   if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
 634     _dbus_assert_not_reached ("no array");
 635
 636   if (dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_INT32)
 637     _dbus_assert_not_reached ("Array type not int32");
 638
 639   /* Empty array */
 640   dbus_message_iter_recurse (&iter, &array);
 641
 642   if (dbus_message_iter_next (&array))
 643     _dbus_assert_not_reached ("Didn't reach end of array");
 644
 645   if (!dbus_message_iter_next (&iter))
 646     _dbus_assert_not_reached ("Reached end of arguments");
 647
 648   GET_AND_CHECK (iter, BYTE, 0xF0);
 649
 650   if (dbus_message_iter_next (&iter))
 651     _dbus_assert_not_reached ("Didn't reach end of arguments");
 652 }
 653
 654 static void
 655 verify_test_message (DBusMessage *message)
 656 {
 657   DBusMessageIter iter;
 658   DBusError error;
 659   dbus_int32_t our_int;
 660   const char *our_str;
 661   double our_double;
 662   dbus_bool_t our_bool;
 663   unsigned char our_byte_1, our_byte_2;
 664   dbus_uint32_t our_uint32;
 665   const dbus_int32_t *our_uint32_array = (void*)0xdeadbeef;
 666   int our_uint32_array_len;
 667   dbus_int32_t *our_int32_array = (void*)0xdeadbeef;
 668   int our_int32_array_len;
 669 #ifdef DBUS_HAVE_INT64
 670   dbus_int64_t our_int64;
 671   dbus_uint64_t our_uint64;
 672   dbus_int64_t *our_uint64_array = (void*)0xdeadbeef;
 673   int our_uint64_array_len;
 674   const dbus_int64_t *our_int64_array = (void*)0xdeadbeef;
 675   int our_int64_array_len;
 676 #endif
 677   const double *our_double_array = (void*)0xdeadbeef;
 678   int our_double_array_len;
 679   const unsigned char *our_byte_array = (void*)0xdeadbeef;
 680   int our_byte_array_len;
 681   const dbus_bool_t *our_boolean_array = (void*)0xdeadbeef;
 682   int our_boolean_array_len;
 683
 684   dbus_message_iter_init (message, &iter);
 685
 686   dbus_error_init (&error);
 687   if (!dbus_message_iter_get_args (&iter, &error,
 688                                    DBUS_TYPE_INT32, &our_int,
 689 #ifdef DBUS_HAVE_INT64
 690                                    DBUS_TYPE_INT64, &our_int64,
 691                                    DBUS_TYPE_UINT64, &our_uint64,
 692 #endif
 693                                    DBUS_TYPE_STRING, &our_str,
 694                                    DBUS_TYPE_DOUBLE, &our_double,
 695                                    DBUS_TYPE_BOOLEAN, &our_bool,
 696                                    DBUS_TYPE_BYTE, &our_byte_1,
 697                                    DBUS_TYPE_BYTE, &our_byte_2,
 698                                    DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
 699                                    &our_uint32_array, &our_uint32_array_len,
 700                                    DBUS_TYPE_ARRAY, DBUS_TYPE_INT32,
 701                                    &our_int32_array, &our_int32_array_len,
 702 #ifdef DBUS_HAVE_INT64
 703                                    DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64,
 704                                    &our_uint64_array, &our_uint64_array_len,
 705                                    DBUS_TYPE_ARRAY, DBUS_TYPE_INT64,
 706                                    &our_int64_array, &our_int64_array_len,
 707 #endif
 708                                    DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE,
 709                                    &our_double_array, &our_double_array_len,
 710                                    DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
 711                                    &our_byte_array, &our_byte_array_len,
 712                                    DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN,
 713                                    &our_boolean_array, &our_boolean_array_len,
 714                                    0))
 715     {
 716       _dbus_warn ("error: %s - %s\n", error.name,
 717                   (error.message != NULL) ? error.message : "no message");
 718       _dbus_assert_not_reached ("Could not get arguments");
 719     }
 720
 721   if (our_int != -0x12345678)
 722     _dbus_assert_not_reached ("integers differ!");
 723
 724 #ifdef DBUS_HAVE_INT64
 725   if (our_int64 != DBUS_INT64_CONSTANT (-0x123456789abcd))
 726     _dbus_assert_not_reached ("64-bit integers differ!");
 727   if (our_uint64 != DBUS_UINT64_CONSTANT (0x123456789abcd))
 728     _dbus_assert_not_reached ("64-bit unsigned integers differ!");
 729 #endif
 730
 731   if (our_double != 3.14159)
 732     _dbus_assert_not_reached ("doubles differ!");
 733
 734   if (strcmp (our_str, "Test string") != 0)
 735     _dbus_assert_not_reached ("strings differ!");
 736
 737   if (!our_bool)
 738     _dbus_assert_not_reached ("booleans differ");
 739
 740   if (our_byte_1 != 42)
 741     _dbus_assert_not_reached ("bytes differ!");
 742
 743   if (our_byte_2 != 24)
 744     _dbus_assert_not_reached ("bytes differ!");
 745
 746   if (our_uint32_array_len != 4 ||
 747       our_uint32_array[0] != 0x12345678 ||
 748       our_uint32_array[1] != 0x23456781 ||
 749       our_uint32_array[2] != 0x34567812 ||
 750       our_uint32_array[3] != 0x45678123)
 751     _dbus_assert_not_reached ("uint array differs");
 752
 753   if (our_int32_array_len != 4 ||
 754       our_int32_array[0] != 0x12345678 ||
 755       our_int32_array[1] != -0x23456781 ||
 756       our_int32_array[2] != 0x34567812 ||
 757       our_int32_array[3] != -0x45678123)
 758     _dbus_assert_not_reached ("int array differs");
 759
 760 #ifdef DBUS_HAVE_INT64
 761   if (our_uint64_array_len != 4 ||
 762       our_uint64_array[0] != 0x12345678 ||
 763       our_uint64_array[1] != 0x23456781 ||
 764       our_uint64_array[2] != 0x34567812 ||
 765       our_uint64_array[3] != 0x45678123)
 766     _dbus_assert_not_reached ("uint64 array differs");
 767
 768   if (our_int64_array_len != 4 ||
 769       our_int64_array[0] != 0x12345678 ||
 770       our_int64_array[1] != -0x23456781 ||
 771       our_int64_array[2] != 0x34567812 ||
 772       our_int64_array[3] != -0x45678123)
 773     _dbus_assert_not_reached ("int64 array differs");
 774 #endif /* DBUS_HAVE_INT64 */
 775
 776   if (our_double_array_len != 3)
 777     _dbus_assert_not_reached ("double array had wrong length");
 778
 779   /* On all IEEE machines (i.e. everything sane) exact equality
 780    * should be preserved over the wire
 781    */
 782   if (our_double_array[0] != 0.1234 ||
 783       our_double_array[1] != 9876.54321 ||
 784       our_double_array[2] != -300.0)
 785     _dbus_assert_not_reached ("double array had wrong values");
 786
 787   if (our_byte_array_len != 4)
 788     _dbus_assert_not_reached ("byte array had wrong length");
 789
 790   if (our_byte_array[0] != 'a' ||
 791       our_byte_array[1] != 'b' ||
 792       our_byte_array[2] != 'c' ||
 793       our_byte_array[3] != 234)
 794     _dbus_assert_not_reached ("byte array had wrong values");
 795
 796   if (our_boolean_array_len != 5)
 797     _dbus_assert_not_reached ("bool array had wrong length");
 798
 799   if (our_boolean_array[0] != TRUE ||
 800       our_boolean_array[1] != FALSE ||
 801       our_boolean_array[2] != TRUE ||
 802       our_boolean_array[3] != TRUE ||
 803       our_boolean_array[4] != FALSE)
 804     _dbus_assert_not_reached ("bool array had wrong values");
 805
 806   if (dbus_message_iter_next (&iter))
 807     _dbus_assert_not_reached ("Didn't reach end of arguments");
 808 }
 809
 810 /**
 811  * @ingroup DBusMessageInternals
 812  * Unit test for DBusMessage.
 813  *
 814  * @returns #TRUE on success.
 815  */
 816 dbus_bool_t
 817 _dbus_message_test (const char *test_data_dir)
 818 {
 819   DBusMessage *message;
 820   DBusMessageLoader *loader;
 821   DBusMessageIter iter, child_iter, child_iter2, child_iter3;
 822   int i;
 823   const char *data;
 824   DBusMessage *copy;
 825   const char *name1;
 826   const char *name2;
 827   const dbus_uint32_t our_uint32_array[] =
 828     { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
 829   const dbus_uint32_t our_int32_array[] =
 830     { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
 831   const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
 832   const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
 833 #ifdef DBUS_HAVE_INT64
 834   const dbus_uint64_t our_uint64_array[] =
 835     { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
 836   const dbus_uint64_t our_int64_array[] =
 837     { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
 838   const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
 839   const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
 840 #endif
 841   const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
 842   const char **v_ARRAY_STRING = our_string_array;
 843   const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
 844   const double *v_ARRAY_DOUBLE = our_double_array;
 845   const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 };
 846   const unsigned char *v_ARRAY_BYTE = our_byte_array;
 847   const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
 848   const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
 849   char sig[64];
 850   const char *s;
 851   char *t;
 852   DBusError error;
 853   const char *v_STRING;
 854   double v_DOUBLE;
 855   dbus_int32_t v_INT32;
 856   dbus_uint32_t v_UINT32;
 857 #ifdef DBUS_HAVE_INT64
 858   dbus_int64_t v_INT64;
 859   dbus_uint64_t v_UINT64;
 860 #endif
 861   unsigned char v_BYTE;
 862   unsigned char v2_BYTE;
 863   dbus_bool_t v_BOOLEAN;
 864
 865   message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
 866                                           "/org/freedesktop/TestPath",
 867                                           "Foo.TestInterface",
 868                                           "TestMethod");
 869   _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
 870   _dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface",
 871                                              "TestMethod"));
 872   _dbus_assert (strcmp (dbus_message_get_path (message),
 873                         "/org/freedesktop/TestPath") == 0);
 874   _dbus_message_set_serial (message, 1234);
 875
 876   /* string length including nul byte not a multiple of 4 */
 877   if (!dbus_message_set_sender (message, "org.foo.bar1"))
 878     _dbus_assert_not_reached ("out of memory");
 879
 880   _dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
 881   dbus_message_set_reply_serial (message, 5678);
 882
 883   _dbus_verbose_bytes_of_string (&message->header.data, 0,
 884                                  _dbus_string_get_length (&message->header.data));
 885   _dbus_verbose_bytes_of_string (&message->body, 0,
 886                                  _dbus_string_get_length (&message->body));
 887
 888   if (!dbus_message_set_sender (message, NULL))
 889     _dbus_assert_not_reached ("out of memory");
 890
 891
 892   _dbus_verbose_bytes_of_string (&message->header.data, 0,
 893                                  _dbus_string_get_length (&message->header.data));
 894   _dbus_verbose_bytes_of_string (&message->body, 0,
 895                                  _dbus_string_get_length (&message->body));
 896
 897
 898   _dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1"));
 899   _dbus_assert (dbus_message_get_serial (message) == 1234);
 900   _dbus_assert (dbus_message_get_reply_serial (message) == 5678);
 901   _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
 902
 903   _dbus_assert (dbus_message_get_no_reply (message) == FALSE);
 904   dbus_message_set_no_reply (message, TRUE);
 905   _dbus_assert (dbus_message_get_no_reply (message) == TRUE);
 906   dbus_message_set_no_reply (message, FALSE);
 907   _dbus_assert (dbus_message_get_no_reply (message) == FALSE);
 908
 909   /* Set/get some header fields */
 910
 911   if (!dbus_message_set_path (message, "/foo"))
 912     _dbus_assert_not_reached ("out of memory");
 913   _dbus_assert (strcmp (dbus_message_get_path (message),
 914                         "/foo") == 0);
 915
 916   if (!dbus_message_set_interface (message, "org.Foo"))
 917     _dbus_assert_not_reached ("out of memory");
 918   _dbus_assert (strcmp (dbus_message_get_interface (message),
 919                         "org.Foo") == 0);
 920
 921   if (!dbus_message_set_member (message, "Bar"))
 922     _dbus_assert_not_reached ("out of memory");
 923   _dbus_assert (strcmp (dbus_message_get_member (message),
 924                         "Bar") == 0);
 925
 926   /* Set/get them with longer values */
 927   if (!dbus_message_set_path (message, "/foo/bar"))
 928     _dbus_assert_not_reached ("out of memory");
 929   _dbus_assert (strcmp (dbus_message_get_path (message),
 930                         "/foo/bar") == 0);
 931
 932   if (!dbus_message_set_interface (message, "org.Foo.Bar"))
 933     _dbus_assert_not_reached ("out of memory");
 934   _dbus_assert (strcmp (dbus_message_get_interface (message),
 935                         "org.Foo.Bar") == 0);
 936
 937   if (!dbus_message_set_member (message, "BarFoo"))
 938     _dbus_assert_not_reached ("out of memory");
 939   _dbus_assert (strcmp (dbus_message_get_member (message),
 940                         "BarFoo") == 0);
 941
 942   /* Realloc shorter again */
 943
 944   if (!dbus_message_set_path (message, "/foo"))
 945     _dbus_assert_not_reached ("out of memory");
 946   _dbus_assert (strcmp (dbus_message_get_path (message),
 947                         "/foo") == 0);
 948
 949   if (!dbus_message_set_interface (message, "org.Foo"))
 950     _dbus_assert_not_reached ("out of memory");
 951   _dbus_assert (strcmp (dbus_message_get_interface (message),
 952                         "org.Foo") == 0);
 953
 954   if (!dbus_message_set_member (message, "Bar"))
 955     _dbus_assert_not_reached ("out of memory");
 956   _dbus_assert (strcmp (dbus_message_get_member (message),
 957                         "Bar") == 0);
 958
 959   dbus_message_unref (message);
 960
 961   /* Test the vararg functions */
 962   message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
 963                                           "/org/freedesktop/TestPath",
 964                                           "Foo.TestInterface",
 965                                           "TestMethod");
 966   _dbus_message_set_serial (message, 1);
 967
 968   v_INT32 = -0x12345678;
 969 #ifdef DBUS_HAVE_INT64
 970   v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
 971   v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
 972 #endif
 973   v_STRING = "Test string";
 974   v_DOUBLE = 3.14159;
 975   v_BOOLEAN = TRUE;
 976   v_BYTE = 42;
 977   v2_BYTE = 24;
 978
 979   dbus_message_append_args (message,
 980                             DBUS_TYPE_INT32, &v_INT32,
 981 #ifdef DBUS_HAVE_INT64
 982                             DBUS_TYPE_INT64, &v_INT64,
 983                             DBUS_TYPE_UINT64, &v_UINT64,
 984 #endif
 985                             DBUS_TYPE_STRING, &v_STRING,
 986                             DBUS_TYPE_DOUBLE, &v_DOUBLE,
 987                             DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
 988                             DBUS_TYPE_BYTE, &v_BYTE,
 989                             DBUS_TYPE_BYTE, &v2_BYTE,
 990                             DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32,
 991                             _DBUS_N_ELEMENTS (our_uint32_array),
 992                             DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
 993                             _DBUS_N_ELEMENTS (our_int32_array),
 994 #ifdef DBUS_HAVE_INT64
 995                             DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
 996                             _DBUS_N_ELEMENTS (our_uint64_array),
 997                             DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
 998                             _DBUS_N_ELEMENTS (our_int64_array),
 999 #endif
1000                             DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
1001                             _DBUS_N_ELEMENTS (our_double_array),
1002                             DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
1003                             _DBUS_N_ELEMENTS (our_byte_array),
1004                             DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN,
1005                             _DBUS_N_ELEMENTS (our_boolean_array),
1006                             DBUS_TYPE_INVALID);
1007
1008   i = 0;
1009   sig[i++] = DBUS_TYPE_INT32;
1010 #ifdef DBUS_HAVE_INT64
1011   sig[i++] = DBUS_TYPE_INT64;
1012   sig[i++] = DBUS_TYPE_UINT64;
1013 #endif
1014   sig[i++] = DBUS_TYPE_STRING;
1015   sig[i++] = DBUS_TYPE_DOUBLE;
1016   sig[i++] = DBUS_TYPE_BOOLEAN;
1017   sig[i++] = DBUS_TYPE_BYTE;
1018   sig[i++] = DBUS_TYPE_BYTE;
1019   sig[i++] = DBUS_TYPE_ARRAY;
1020   sig[i++] = DBUS_TYPE_UINT32;
1021   sig[i++] = DBUS_TYPE_ARRAY;
1022   sig[i++] = DBUS_TYPE_INT32;
1023 #ifdef DBUS_HAVE_INT64
1024   sig[i++] = DBUS_TYPE_ARRAY;
1025   sig[i++] = DBUS_TYPE_UINT64;
1026   sig[i++] = DBUS_TYPE_ARRAY;
1027   sig[i++] = DBUS_TYPE_INT64;
1028 #endif
1029   sig[i++] = DBUS_TYPE_ARRAY;
1030   sig[i++] = DBUS_TYPE_DOUBLE;
1031   sig[i++] = DBUS_TYPE_ARRAY;
1032   sig[i++] = DBUS_TYPE_BYTE;
1033   sig[i++] = DBUS_TYPE_ARRAY;
1034   sig[i++] = DBUS_TYPE_BOOLEAN;
1035   sig[i++] = DBUS_TYPE_INVALID;
1036
1037   _dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
1038
1039   _dbus_verbose ("HEADER\n");
1040   _dbus_verbose_bytes_of_string (&message->header.data, 0,
1041                                  _dbus_string_get_length (&message->header.data));
1042   _dbus_verbose ("BODY\n");
1043   _dbus_verbose_bytes_of_string (&message->body, 0,
1044                                  _dbus_string_get_length (&message->body));
1045
1046   _dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n",
1047                  sig, dbus_message_get_signature (message));
1048
1049   s = dbus_message_get_signature (message);
1050
1051   _dbus_assert (dbus_message_has_signature (message, sig));
1052   _dbus_assert (strcmp (s, sig) == 0);
1053
1054   verify_test_message (message);
1055
1056   copy = dbus_message_copy (message);
1057
1058   _dbus_assert (dbus_message_get_reply_serial (message) ==
1059                 dbus_message_get_reply_serial (copy));
1060   _dbus_assert (message->header.padding == copy->header.padding);
1061
1062   _dbus_assert (_dbus_string_get_length (&message->header.data) ==
1063                 _dbus_string_get_length (&copy->header.data));
1064
1065   _dbus_assert (_dbus_string_get_length (&message->body) ==
1066                 _dbus_string_get_length (&copy->body));
1067
1068   verify_test_message (copy);
1069
1070   name1 = dbus_message_get_interface (message);
1071   name2 = dbus_message_get_interface (copy);
1072
1073   _dbus_assert (strcmp (name1, name2) == 0);
1074
1075   name1 = dbus_message_get_member (message);
1076   name2 = dbus_message_get_member (copy);
1077
1078   _dbus_assert (strcmp (name1, name2) == 0);
1079
1080   dbus_message_unref (message);
1081   dbus_message_unref (copy);
1082
1083 #if 0
1084   /* FIXME */
1085   message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
1086                                           "/org/freedesktop/TestPath",
1087                                           "Foo.TestInterface",
1088                                           "TestMethod");
1089
1090   _dbus_message_set_serial (message, 1);
1091   dbus_message_set_reply_serial (message, 0x12345678);
1092
1093   dbus_message_iter_init_append (message, &iter);
1094   dbus_message_iter_append_string (&iter, "Test string");
1095   dbus_message_iter_append_int32 (&iter, -0x12345678);
1096   dbus_message_iter_append_uint32 (&iter, 0xedd1e);
1097   dbus_message_iter_append_double (&iter, 3.14159);
1098
1099   dbus_message_iter_append_array (&iter, &child_iter, DBUS_TYPE_DOUBLE);
1100   dbus_message_iter_append_double (&child_iter, 1.5);
1101   dbus_message_iter_append_double (&child_iter, 2.5);
1102
1103   /* dict */
1104   dbus_message_iter_append_dict (&iter, &child_iter);
1105   dbus_message_iter_append_dict_key (&child_iter, "test");
1106   dbus_message_iter_append_uint32 (&child_iter, 0xDEADBEEF);
1107
1108   /* dict (in dict) */
1109   dbus_message_iter_append_dict_key (&child_iter, "testdict");
1110   dbus_message_iter_append_dict (&child_iter, &child_iter2);
1111
1112   dbus_message_iter_append_dict_key (&child_iter2, "dictkey");
1113   dbus_message_iter_append_string (&child_iter2, "dictvalue");
1114
1115   /* array of array of int32  (in dict) */
1116   dbus_message_iter_append_dict_key (&child_iter, "array");
1117   dbus_message_iter_append_array (&child_iter, &child_iter2, DBUS_TYPE_ARRAY);
1118   dbus_message_iter_append_array (&child_iter2, &child_iter3, DBUS_TYPE_INT32);
1119   dbus_message_iter_append_int32 (&child_iter3, 0x12345678);
1120   dbus_message_iter_append_int32 (&child_iter3, 0x23456781);
1121   _dbus_warn ("next call expected to fail with wrong array type\n");
1122   _dbus_assert (!dbus_message_iter_append_array (&child_iter2, &child_iter3, DBUS_TYPE_UINT32));
1123   dbus_message_iter_append_array (&child_iter2, &child_iter3, DBUS_TYPE_INT32);
1124   dbus_message_iter_append_int32 (&child_iter3, 0x34567812);
1125   dbus_message_iter_append_int32 (&child_iter3, 0x45678123);
1126   dbus_message_iter_append_int32 (&child_iter3, 0x56781234);
1127
1128   dbus_message_iter_append_byte (&iter, 0xF0);
1129
1130   dbus_message_iter_append_nil (&iter);
1131
1132   dbus_message_iter_append_custom (&iter, "MyTypeName",
1133                                    "data", 5);
1134
1135   dbus_message_iter_append_byte (&iter, 0xF0);
1136
1137   dbus_message_iter_append_array (&iter, &child_iter, DBUS_TYPE_INT32);
1138
1139   dbus_message_iter_append_byte (&iter, 0xF0);
1140
1141   dbus_message_iter_append_dict (&iter, &child_iter);
1142
1143   dbus_message_iter_append_byte (&iter, 0xF0);
1144
1145   message_iter_test (message);
1146
1147   /* Message loader test */
1148   _dbus_message_lock (message);
1149   loader = _dbus_message_loader_new ();
1150
1151   /* check ref/unref */
1152   _dbus_message_loader_ref (loader);
1153   _dbus_message_loader_unref (loader);
1154
1155   /* Write the header data one byte at a time */
1156   data = _dbus_string_get_const_data (&message->header);
1157   for (i = 0; i < _dbus_string_get_length (&message->header); i++)
1158     {
1159       DBusString *buffer;
1160
1161       _dbus_message_loader_get_buffer (loader, &buffer);
1162       _dbus_string_append_byte (buffer, data[i]);
1163       _dbus_message_loader_return_buffer (loader, buffer, 1);
1164     }
1165
1166   /* Write the body data one byte at a time */
1167   data = _dbus_string_get_const_data (&message->body);
1168   for (i = 0; i < _dbus_string_get_length (&message->body); i++)
1169     {
1170       DBusString *buffer;
1171
1172       _dbus_message_loader_get_buffer (loader, &buffer);
1173       _dbus_string_append_byte (buffer, data[i]);
1174       _dbus_message_loader_return_buffer (loader, buffer, 1);
1175     }
1176
1177   copy = dbus_message_copy (message); /* save for tests below */
1178   dbus_message_unref (message);
1179
1180   /* Now pop back the message */
1181   if (!_dbus_message_loader_queue_messages (loader))
1182     _dbus_assert_not_reached ("no memory to queue messages");
1183
1184   if (_dbus_message_loader_get_is_corrupted (loader))
1185     _dbus_assert_not_reached ("message loader corrupted");
1186
1187   message = _dbus_message_loader_pop_message (loader);
1188   if (!message)
1189     _dbus_assert_not_reached ("received a NULL message");
1190
1191   if (dbus_message_get_reply_serial (message) != 0x12345678)
1192     _dbus_assert_not_reached ("reply serial fields differ");
1193
1194   message_iter_test (message);
1195
1196   dbus_message_unref (message);
1197   _dbus_message_loader_unref (loader);
1198
1199   message = dbus_message_new_method_return (copy);
1200   if (message == NULL)
1201     _dbus_assert_not_reached ("out of memory\n");
1202   dbus_message_unref (copy);
1203
1204   if (!dbus_message_append_args (message,
1205                                  DBUS_TYPE_STRING, "hello",
1206                                  DBUS_TYPE_INVALID))
1207     _dbus_assert_not_reached ("no memory");
1208
1209   if (!dbus_message_has_signature (message, "s"))
1210     _dbus_assert_not_reached ("method return has wrong signature");
1211
1212   dbus_error_init (&error);
1213   if (!dbus_message_get_args (message, &error, DBUS_TYPE_STRING,
1214                               &t, DBUS_TYPE_INVALID))
1215
1216     {
1217       _dbus_warn ("Failed to get expected string arg: %s\n", error.message);
1218       exit (1);
1219     }
1220   dbus_free (t);
1221
1222   dbus_message_unref (message);
1223
1224   /* This ServiceAcquired message used to trigger a bug in
1225    * setting header fields, adding to regression test.
1226    */
1227   message = dbus_message_new_signal (DBUS_PATH_ORG_FREEDESKTOP_DBUS,
1228                                      DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
1229                                      "ServiceAcquired");
1230
1231   if (message == NULL)
1232     _dbus_assert_not_reached ("out of memory");
1233
1234   _dbus_verbose ("Bytes after creation\n");
1235   _dbus_verbose_bytes_of_string (&message->header, 0,
1236                                  _dbus_string_get_length (&message->header));
1237
1238   if (!dbus_message_set_destination (message, ":1.0") ||
1239       !dbus_message_append_args (message,
1240                                  DBUS_TYPE_STRING, ":1.0",
1241                                  DBUS_TYPE_INVALID))
1242     _dbus_assert_not_reached ("out of memory");
1243
1244   _dbus_verbose ("Bytes after set_destination() and append_args()\n");
1245   _dbus_verbose_bytes_of_string (&message->header, 0,
1246                                  _dbus_string_get_length (&message->header));
1247
1248   if (!dbus_message_set_sender (message, "org.freedesktop.DBus"))
1249     _dbus_assert_not_reached ("out of memory");
1250
1251   _dbus_verbose ("Bytes after set_sender()\n");
1252   _dbus_verbose_bytes_of_string (&message->header, 0,
1253                                  _dbus_string_get_length (&message->header));
1254
1255   /* When the bug happened the above set_destination() would
1256    * corrupt the signature
1257    */
1258   if (!dbus_message_has_signature (message, "s"))
1259     {
1260       _dbus_warn ("Signature should be 's' but is '%s'\n",
1261                   dbus_message_get_signature (message));
1262       _dbus_assert_not_reached ("signal has wrong signature");
1263     }
1264
1265   /* have to set destination again to reproduce the bug */
1266   if (!dbus_message_set_destination (message, ":1.0"))
1267     _dbus_assert_not_reached ("out of memory");
1268
1269   _dbus_verbose ("Bytes after set_destination()\n");
1270   _dbus_verbose_bytes_of_string (&message->header, 0,
1271                                  _dbus_string_get_length (&message->header));
1272
1273   /* When the bug happened the above set_destination() would
1274    * corrupt the signature
1275    */
1276   if (!dbus_message_has_signature (message, "s"))
1277     {
1278       _dbus_warn ("Signature should be 's' but is '%s'\n",
1279                   dbus_message_get_signature (message));
1280       _dbus_assert_not_reached ("signal has wrong signature");
1281     }
1282
1283   dbus_error_init (&error);
1284   if (!dbus_message_get_args (message, &error, DBUS_TYPE_STRING,
1285                               &t, DBUS_TYPE_INVALID))
1286
1287     {
1288       _dbus_warn ("Failed to get expected string arg for signal: %s\n", error.message);
1289       exit (1);
1290     }
1291   dbus_free (t);
1292
1293   dbus_message_unref (message);
1294
1295   /* Now load every message in test_data_dir if we have one */
1296   if (test_data_dir == NULL)
1297     return TRUE;
1298
1299   return dbus_internal_do_not_use_foreach_message_file (test_data_dir,
1300                                                         (DBusForeachMessageFileFunc)
1301                                                         dbus_internal_do_not_use_try_message_file,
1302                                                         NULL);
1303
1304 #endif /* Commented out most tests for now */
1305
1306   return TRUE;
1307 }
1308
1309 #endif /* DBUS_BUILD_TESTS */