dbus-message-util.c

00001 /* -*- mode: C; c-file-style: "gnu" -*- */
00002 /* dbus-message-util.c Would be in dbus-message.c, but only used by bus/tests
00003  *
00004  * Copyright (C) 2002, 2003, 2004, 2005  Red Hat Inc.
00005  * Copyright (C) 2002, 2003  CodeFactory AB
00006  *
00007  * Licensed under the Academic Free License version 2.1
00008  *
00009  * This program is free software; you can redistribute it and/or modify
00010  * it under the terms of the GNU General Public License as published by
00011  * the Free Software Foundation; either version 2 of the License, or
00012  * (at your option) any later version.
00013  *
00014  * This program is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017  * GNU General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU General Public License
00020  * along with this program; if not, write to the Free Software
00021  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022  *
00023  */
00024 
00025 #include "dbus-internals.h"
00026 #include "dbus-test.h"
00027 #include "dbus-message-private.h"
00028 #include "dbus-marshal-recursive.h"
00029 #include "dbus-string.h"
00030 
00036 #ifdef DBUS_BUILD_TESTS
00037 
00053 static dbus_bool_t
00054 dbus_message_iter_get_args (DBusMessageIter *iter,
00055                             DBusError       *error,
00056                             int              first_arg_type,
00057                             ...)
00058 {
00059   dbus_bool_t retval;
00060   va_list var_args;
00061 
00062   _dbus_return_val_if_fail (iter != NULL, FALSE);
00063   _dbus_return_val_if_error_is_set (error, FALSE);
00064 
00065   va_start (var_args, first_arg_type);
00066   retval = _dbus_message_iter_get_args_valist (iter, error, first_arg_type, var_args);
00067   va_end (var_args);
00068 
00069   return retval;
00070 }
00071 #endif /* DBUS_BUILD_TESTS */
00072 
00075 #ifdef DBUS_BUILD_TESTS
00076 #include "dbus-test.h"
00077 #include "dbus-message-factory.h"
00078 #include <stdio.h>
00079 #include <stdlib.h>
00080 
00081 static int validities_seen[DBUS_VALIDITY_LAST + _DBUS_NEGATIVE_VALIDITY_COUNT];
00082 
00083 static void
00084 reset_validities_seen (void)
00085 {
00086   int i;
00087   i = 0;
00088   while (i < _DBUS_N_ELEMENTS (validities_seen))
00089     {
00090       validities_seen[i] = 0;
00091       ++i;
00092     }
00093 }
00094 
00095 static void
00096 record_validity_seen (DBusValidity validity)
00097 {
00098   validities_seen[validity + _DBUS_NEGATIVE_VALIDITY_COUNT] += 1;
00099 }
00100 
00101 static void
00102 print_validities_seen (dbus_bool_t not_seen)
00103 {
00104   int i;
00105   i = 0;
00106   while (i < _DBUS_N_ELEMENTS (validities_seen))
00107     {
00108       if ((i - _DBUS_NEGATIVE_VALIDITY_COUNT) == DBUS_VALIDITY_UNKNOWN ||
00109           (i - _DBUS_NEGATIVE_VALIDITY_COUNT) == DBUS_INVALID_FOR_UNKNOWN_REASON)
00110         ;
00111       else if ((not_seen && validities_seen[i] == 0) ||
00112                (!not_seen && validities_seen[i] > 0))
00113         printf ("validity %3d seen %d times\n",
00114                 i - _DBUS_NEGATIVE_VALIDITY_COUNT,
00115                 validities_seen[i]);
00116       ++i;
00117     }
00118 }
00119 
00120 static void
00121 check_memleaks (void)
00122 {
00123   dbus_shutdown ();
00124 
00125   if (_dbus_get_malloc_blocks_outstanding () != 0)
00126     {
00127       _dbus_warn ("%d dbus_malloc blocks were not freed in %s\n",
00128                   _dbus_get_malloc_blocks_outstanding (), __FILE__);
00129       _dbus_assert_not_reached ("memleaks");
00130     }
00131 }
00132 
00133 static dbus_bool_t
00134 check_have_valid_message (DBusMessageLoader *loader)
00135 {
00136   DBusMessage *message;
00137   dbus_bool_t retval;
00138 
00139   message = NULL;
00140   retval = FALSE;
00141 
00142   if (_dbus_message_loader_get_is_corrupted (loader))
00143     {
00144       _dbus_warn ("loader corrupted on message that was expected to be valid; invalid reason %d\n",
00145                   loader->corruption_reason);
00146       goto failed;
00147     }
00148 
00149   message = _dbus_message_loader_pop_message (loader);
00150   if (message == NULL)
00151     {
00152       _dbus_warn ("didn't load message that was expected to be valid (message not popped)\n");
00153       goto failed;
00154     }
00155 
00156   if (_dbus_string_get_length (&loader->data) > 0)
00157     {
00158       _dbus_warn ("had leftover bytes from expected-to-be-valid single message\n");
00159       goto failed;
00160     }
00161 
00162 #if 0
00163   /* FIXME */
00164   /* Verify that we're able to properly deal with the message.
00165    * For example, this would detect improper handling of messages
00166    * in nonstandard byte order.
00167    */
00168   if (!check_message_handling (message))
00169     goto failed;
00170 #endif
00171 
00172   record_validity_seen (DBUS_VALID);
00173   
00174   retval = TRUE;
00175 
00176  failed:
00177   if (message)
00178     dbus_message_unref (message);
00179 
00180   return retval;
00181 }
00182 
00183 static dbus_bool_t
00184 check_invalid_message (DBusMessageLoader *loader,
00185                        DBusValidity       expected_validity)
00186 {
00187   dbus_bool_t retval;
00188 
00189   retval = FALSE;
00190 
00191   if (!_dbus_message_loader_get_is_corrupted (loader))
00192     {
00193       _dbus_warn ("loader not corrupted on message that was expected to be invalid\n");
00194       goto failed;
00195     }
00196 
00197   record_validity_seen (loader->corruption_reason);
00198   
00199   if (expected_validity != DBUS_INVALID_FOR_UNKNOWN_REASON &&
00200       loader->corruption_reason != expected_validity)
00201     {
00202       _dbus_warn ("expected message to be corrupted for reason %d and was corrupted for %d instead\n",
00203                   expected_validity, loader->corruption_reason);
00204       goto failed;
00205     }
00206 
00207   retval = TRUE;
00208 
00209  failed:
00210   return retval;
00211 }
00212 
00213 static dbus_bool_t
00214 check_incomplete_message (DBusMessageLoader *loader)
00215 {
00216   DBusMessage *message;
00217   dbus_bool_t retval;
00218 
00219   message = NULL;
00220   retval = FALSE;
00221 
00222   if (_dbus_message_loader_get_is_corrupted (loader))
00223     {
00224       _dbus_warn ("loader corrupted on message that was expected to be valid (but incomplete), corruption reason %d\n",
00225                   loader->corruption_reason);
00226       goto failed;
00227     }
00228 
00229   message = _dbus_message_loader_pop_message (loader);
00230   if (message != NULL)
00231     {
00232       _dbus_warn ("loaded message that was expected to be incomplete\n");
00233       goto failed;
00234     }
00235 
00236   record_validity_seen (DBUS_VALID_BUT_INCOMPLETE);
00237   retval = TRUE;
00238 
00239  failed:
00240   if (message)
00241     dbus_message_unref (message);
00242   return retval;
00243 }
00244 
00245 static dbus_bool_t
00246 check_loader_results (DBusMessageLoader      *loader,
00247                       DBusValidity            expected_validity)
00248 {
00249   if (!_dbus_message_loader_queue_messages (loader))
00250     _dbus_assert_not_reached ("no memory to queue messages");
00251 
00252   if (expected_validity == DBUS_VALID)
00253     return check_have_valid_message (loader);
00254   else if (expected_validity == DBUS_VALID_BUT_INCOMPLETE)
00255     return check_incomplete_message (loader);
00256   else if (expected_validity == DBUS_VALIDITY_UNKNOWN)
00257     {
00258       /* here we just know we didn't segfault and that was the
00259        * only test. Also, we record that we got coverage
00260        * for the validity reason.
00261        */
00262       if (_dbus_message_loader_get_is_corrupted (loader))
00263         record_validity_seen (loader->corruption_reason);
00264       
00265       return TRUE;
00266     }
00267   else
00268     return check_invalid_message (loader, expected_validity);
00269 }
00270 
00278 dbus_bool_t
00279 dbus_internal_do_not_use_load_message_file (const DBusString    *filename,
00280                                             DBusString          *data)
00281 {
00282   dbus_bool_t retval;
00283   DBusError error;
00284   
00285   retval = FALSE;
00286 
00287   _dbus_verbose ("Loading raw %s\n", _dbus_string_get_const_data (filename));
00288   dbus_error_init (&error);
00289   if (!_dbus_file_get_contents (data, filename, &error))
00290     {
00291       _dbus_warn ("Could not load message file %s: %s\n",
00292                   _dbus_string_get_const_data (filename),
00293                   error.message);
00294       dbus_error_free (&error);
00295       goto failed;
00296     }
00297 
00298   retval = TRUE;
00299 
00300  failed:
00301 
00302   return retval;
00303 }
00304 
00313 dbus_bool_t
00314 dbus_internal_do_not_use_try_message_file (const DBusString    *filename,
00315                                            DBusValidity         expected_validity)
00316 {
00317   DBusString data;
00318   dbus_bool_t retval;
00319 
00320   retval = FALSE;
00321 
00322   if (!_dbus_string_init (&data))
00323     _dbus_assert_not_reached ("could not allocate string\n");
00324 
00325   if (!dbus_internal_do_not_use_load_message_file (filename, &data))
00326     goto failed;
00327 
00328   retval = dbus_internal_do_not_use_try_message_data (&data, expected_validity);
00329 
00330  failed:
00331 
00332   if (!retval)
00333     {
00334       if (_dbus_string_get_length (&data) > 0)
00335         _dbus_verbose_bytes_of_string (&data, 0,
00336                                        _dbus_string_get_length (&data));
00337 
00338       _dbus_warn ("Failed message loader test on %s\n",
00339                   _dbus_string_get_const_data (filename));
00340     }
00341 
00342   _dbus_string_free (&data);
00343 
00344   return retval;
00345 }
00346 
00355 dbus_bool_t
00356 dbus_internal_do_not_use_try_message_data (const DBusString    *data,
00357                                            DBusValidity         expected_validity)
00358 {
00359   DBusMessageLoader *loader;
00360   dbus_bool_t retval;
00361   int len;
00362   int i;
00363 
00364   loader = NULL;
00365   retval = FALSE;
00366 
00367   /* Write the data one byte at a time */
00368 
00369   loader = _dbus_message_loader_new ();
00370 
00371   /* check some trivial loader functions */
00372   _dbus_message_loader_ref (loader);
00373   _dbus_message_loader_unref (loader);
00374   _dbus_message_loader_get_max_message_size (loader);
00375 
00376   len = _dbus_string_get_length (data);
00377   for (i = 0; i < len; i++)
00378     {
00379       DBusString *buffer;
00380 
00381       _dbus_message_loader_get_buffer (loader, &buffer);
00382       _dbus_string_append_byte (buffer,
00383                                 _dbus_string_get_byte (data, i));
00384       _dbus_message_loader_return_buffer (loader, buffer, 1);
00385     }
00386 
00387   if (!check_loader_results (loader, expected_validity))
00388     goto failed;
00389 
00390   _dbus_message_loader_unref (loader);
00391   loader = NULL;
00392 
00393   /* Write the data all at once */
00394 
00395   loader = _dbus_message_loader_new ();
00396 
00397   {
00398     DBusString *buffer;
00399 
00400     _dbus_message_loader_get_buffer (loader, &buffer);
00401     _dbus_string_copy (data, 0, buffer,
00402                        _dbus_string_get_length (buffer));
00403     _dbus_message_loader_return_buffer (loader, buffer, 1);
00404   }
00405 
00406   if (!check_loader_results (loader, expected_validity))
00407     goto failed;
00408 
00409   _dbus_message_loader_unref (loader);
00410   loader = NULL;
00411 
00412   /* Write the data 2 bytes at a time */
00413 
00414   loader = _dbus_message_loader_new ();
00415 
00416   len = _dbus_string_get_length (data);
00417   for (i = 0; i < len; i += 2)
00418     {
00419       DBusString *buffer;
00420 
00421       _dbus_message_loader_get_buffer (loader, &buffer);
00422       _dbus_string_append_byte (buffer,
00423                                 _dbus_string_get_byte (data, i));
00424       if ((i+1) < len)
00425         _dbus_string_append_byte (buffer,
00426                                   _dbus_string_get_byte (data, i+1));
00427       _dbus_message_loader_return_buffer (loader, buffer, 1);
00428     }
00429 
00430   if (!check_loader_results (loader, expected_validity))
00431     goto failed;
00432 
00433   _dbus_message_loader_unref (loader);
00434   loader = NULL;
00435 
00436   retval = TRUE;
00437 
00438  failed:
00439 
00440   if (loader)
00441     _dbus_message_loader_unref (loader);
00442 
00443   return retval;
00444 }
00445 
00446 static dbus_bool_t
00447 process_test_subdir (const DBusString          *test_base_dir,
00448                      const char                *subdir,
00449                      DBusValidity               expected_validity,
00450                      DBusForeachMessageFileFunc function,
00451                      void                      *user_data)
00452 {
00453   DBusString test_directory;
00454   DBusString filename;
00455   DBusDirIter *dir;
00456   dbus_bool_t retval;
00457   DBusError error;
00458 
00459   retval = FALSE;
00460   dir = NULL;
00461 
00462   if (!_dbus_string_init (&test_directory))
00463     _dbus_assert_not_reached ("didn't allocate test_directory\n");
00464 
00465   _dbus_string_init_const (&filename, subdir);
00466 
00467   if (!_dbus_string_copy (test_base_dir, 0,
00468                           &test_directory, 0))
00469     _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
00470 
00471   if (!_dbus_concat_dir_and_file (&test_directory, &filename))
00472     _dbus_assert_not_reached ("couldn't allocate full path");
00473 
00474   _dbus_string_free (&filename);
00475   if (!_dbus_string_init (&filename))
00476     _dbus_assert_not_reached ("didn't allocate filename string\n");
00477 
00478   dbus_error_init (&error);
00479   dir = _dbus_directory_open (&test_directory, &error);
00480   if (dir == NULL)
00481     {
00482       _dbus_warn ("Could not open %s: %s\n",
00483                   _dbus_string_get_const_data (&test_directory),
00484                   error.message);
00485       dbus_error_free (&error);
00486       goto failed;
00487     }
00488 
00489   printf ("Testing %s:\n", subdir);
00490 
00491  next:
00492   while (_dbus_directory_get_next_file (dir, &filename, &error))
00493     {
00494       DBusString full_path;
00495 
00496       if (!_dbus_string_init (&full_path))
00497         _dbus_assert_not_reached ("couldn't init string");
00498 
00499       if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
00500         _dbus_assert_not_reached ("couldn't copy dir to full_path");
00501 
00502       if (!_dbus_concat_dir_and_file (&full_path, &filename))
00503         _dbus_assert_not_reached ("couldn't concat file to dir");
00504 
00505       if (_dbus_string_ends_with_c_str (&filename, ".message-raw"))
00506         ;
00507       else
00508         {
00509           if (_dbus_string_ends_with_c_str (&filename, ".message"))
00510             {
00511               _dbus_warn ("Could not load %s, message builder language no longer supported\n",
00512                           _dbus_string_get_const_data (&filename));
00513             }
00514           
00515           _dbus_verbose ("Skipping non-.message file %s\n",
00516                          _dbus_string_get_const_data (&filename));
00517           _dbus_string_free (&full_path);
00518           goto next;
00519         }
00520 
00521       printf ("    %s\n",
00522               _dbus_string_get_const_data (&filename));
00523 
00524       if (! (*function) (&full_path,
00525                          expected_validity, user_data))
00526         {
00527           _dbus_string_free (&full_path);
00528           goto failed;
00529         }
00530       else
00531         _dbus_string_free (&full_path);
00532     }
00533 
00534   if (dbus_error_is_set (&error))
00535     {
00536       _dbus_warn ("Could not get next file in %s: %s\n",
00537                   _dbus_string_get_const_data (&test_directory),
00538                   error.message);
00539       dbus_error_free (&error);
00540       goto failed;
00541     }
00542 
00543   retval = TRUE;
00544 
00545  failed:
00546 
00547   if (dir)
00548     _dbus_directory_close (dir);
00549   _dbus_string_free (&test_directory);
00550   _dbus_string_free (&filename);
00551 
00552   return retval;
00553 }
00554 
00564 dbus_bool_t
00565 dbus_internal_do_not_use_foreach_message_file (const char                *test_data_dir,
00566                                                DBusForeachMessageFileFunc func,
00567                                                void                      *user_data)
00568 {
00569   DBusString test_directory;
00570   dbus_bool_t retval;
00571 
00572   retval = FALSE;
00573 
00574   _dbus_string_init_const (&test_directory, test_data_dir);
00575   
00576   if (!process_test_subdir (&test_directory, "valid-messages",
00577                             DBUS_VALID, func, user_data))
00578     goto failed;
00579 
00580   check_memleaks ();
00581   
00582   if (!process_test_subdir (&test_directory, "invalid-messages",
00583                             DBUS_INVALID_FOR_UNKNOWN_REASON, func, user_data))
00584     goto failed;
00585 
00586   check_memleaks ();
00587   
00588   if (!process_test_subdir (&test_directory, "incomplete-messages",
00589                             DBUS_VALID_BUT_INCOMPLETE, func, user_data))
00590     goto failed;
00591 
00592   check_memleaks ();
00593   
00594   retval = TRUE;
00595   
00596  failed:
00597 
00598   _dbus_string_free (&test_directory);
00599 
00600   return retval;
00601 }
00602 
00603 #if 0
00604 #define GET_AND_CHECK(iter, typename, literal)                                  \
00605   do {                                                                          \
00606     if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename)         \
00607       _dbus_assert_not_reached ("got wrong argument type from message iter");   \
00608     dbus_message_iter_get_basic (&iter, &v_##typename);                         \
00609     if (v_##typename != literal)                                                \
00610       _dbus_assert_not_reached ("got wrong value from message iter");           \
00611   } while (0)
00612 
00613 #define GET_AND_CHECK_STRCMP(iter, typename, literal)                           \
00614   do {                                                                          \
00615     if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename)         \
00616       _dbus_assert_not_reached ("got wrong argument type from message iter");   \
00617     dbus_message_iter_get_basic (&iter, &v_##typename);                         \
00618     if (strcmp (v_##typename, literal) != 0)                                    \
00619       _dbus_assert_not_reached ("got wrong value from message iter");           \
00620   } while (0)
00621 
00622 #define GET_AND_CHECK_AND_NEXT(iter, typename, literal)         \
00623   do {                                                          \
00624     GET_AND_CHECK(iter, typename, literal);                     \
00625     if (!dbus_message_iter_next (&iter))                        \
00626       _dbus_assert_not_reached ("failed to move iter to next"); \
00627   } while (0)
00628 
00629 #define GET_AND_CHECK_STRCMP_AND_NEXT(iter, typename, literal)  \
00630   do {                                                          \
00631     GET_AND_CHECK_STRCMP(iter, typename, literal);              \
00632     if (!dbus_message_iter_next (&iter))                        \
00633       _dbus_assert_not_reached ("failed to move iter to next"); \
00634   } while (0)
00635 
00636 static void
00637 message_iter_test (DBusMessage *message)
00638 {
00639   DBusMessageIter iter, array, array2;
00640   const char *v_STRING;
00641   double v_DOUBLE;
00642   dbus_int16_t v_INT16;
00643   dbus_uint16_t v_UINT16;
00644   dbus_int32_t v_INT32;
00645   dbus_uint32_t v_UINT32;
00646 #ifdef DBUS_HAVE_INT64
00647   dbus_int64_t v_INT64;
00648   dbus_uint64_t v_UINT64;
00649 #endif
00650   unsigned char v_BYTE;
00651   dbus_bool_t v_BOOLEAN;
00652 
00653   const dbus_int32_t *our_int_array;
00654   int len;
00655 
00656   dbus_message_iter_init (message, &iter);
00657 
00658   GET_AND_CHECK_STRCMP_AND_NEXT (iter, STRING, "Test string");
00659   GET_AND_CHECK_AND_NEXT (iter, INT32, -0x12345678);
00660   GET_AND_CHECK_AND_NEXT (iter, UINT32, 0xedd1e);
00661   GET_AND_CHECK_AND_NEXT (iter, DOUBLE, 3.14159);
00662 
00663   if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
00664     _dbus_assert_not_reached ("Argument type not an array");
00665 
00666   if (dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_DOUBLE)
00667     _dbus_assert_not_reached ("Array type not double");
00668 
00669   dbus_message_iter_recurse (&iter, &array);
00670 
00671   GET_AND_CHECK_AND_NEXT (array, DOUBLE, 1.5);
00672   GET_AND_CHECK (array, DOUBLE, 2.5);
00673 
00674   if (dbus_message_iter_next (&array))
00675     _dbus_assert_not_reached ("Didn't reach end of array");
00676 
00677   if (!dbus_message_iter_next (&iter))
00678     _dbus_assert_not_reached ("Reached end of arguments");
00679 
00680   GET_AND_CHECK_AND_NEXT (iter, BYTE, 0xF0);
00681 
00682   if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
00683     _dbus_assert_not_reached ("no array");
00684 
00685   if (dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_INT32)
00686     _dbus_assert_not_reached ("Array type not int32");
00687 
00688   /* Empty array */
00689   dbus_message_iter_recurse (&iter, &array);
00690 
00691   if (dbus_message_iter_next (&array))
00692     _dbus_assert_not_reached ("Didn't reach end of array");
00693 
00694   if (!dbus_message_iter_next (&iter))
00695     _dbus_assert_not_reached ("Reached end of arguments");
00696 
00697   GET_AND_CHECK (iter, BYTE, 0xF0);
00698 
00699   if (dbus_message_iter_next (&iter))
00700     _dbus_assert_not_reached ("Didn't reach end of arguments");
00701 }
00702 #endif
00703 
00704 static void
00705 verify_test_message (DBusMessage *message)
00706 {
00707   DBusMessageIter iter;
00708   DBusError error;
00709   dbus_int16_t our_int16;
00710   dbus_uint16_t our_uint16;
00711   dbus_int32_t our_int;
00712   dbus_uint32_t our_uint;
00713   const char *our_str;
00714   double our_double;
00715   double v_DOUBLE;
00716   dbus_bool_t our_bool;
00717   unsigned char our_byte_1, our_byte_2;
00718   const dbus_uint32_t *our_uint32_array = (void*)0xdeadbeef;
00719   int our_uint32_array_len;
00720   dbus_int32_t *our_int32_array = (void*)0xdeadbeef;
00721   int our_int32_array_len;
00722 #ifdef DBUS_HAVE_INT64
00723   dbus_int64_t our_int64;
00724   dbus_uint64_t our_uint64;
00725   dbus_int64_t *our_uint64_array = (void*)0xdeadbeef;
00726   int our_uint64_array_len;
00727   const dbus_int64_t *our_int64_array = (void*)0xdeadbeef;
00728   int our_int64_array_len;
00729 #endif
00730   const double *our_double_array = (void*)0xdeadbeef;
00731   int our_double_array_len;
00732   const unsigned char *our_byte_array = (void*)0xdeadbeef;
00733   int our_byte_array_len;
00734   const dbus_bool_t *our_boolean_array = (void*)0xdeadbeef;
00735   int our_boolean_array_len;
00736   char **our_string_array;
00737   int our_string_array_len;
00738 
00739   dbus_message_iter_init (message, &iter);
00740 
00741   dbus_error_init (&error);
00742   if (!dbus_message_iter_get_args (&iter, &error,
00743                                    DBUS_TYPE_INT16, &our_int16,
00744                                    DBUS_TYPE_UINT16, &our_uint16,
00745                                    DBUS_TYPE_INT32, &our_int,
00746                                    DBUS_TYPE_UINT32, &our_uint,
00747 #ifdef DBUS_HAVE_INT64
00748                                    DBUS_TYPE_INT64, &our_int64,
00749                                    DBUS_TYPE_UINT64, &our_uint64,
00750 #endif
00751                                    DBUS_TYPE_STRING, &our_str,
00752                                    DBUS_TYPE_DOUBLE, &our_double,
00753                                    DBUS_TYPE_BOOLEAN, &our_bool,
00754                                    DBUS_TYPE_BYTE, &our_byte_1,
00755                                    DBUS_TYPE_BYTE, &our_byte_2,
00756                                    DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
00757                                    &our_uint32_array, &our_uint32_array_len,
00758                                    DBUS_TYPE_ARRAY, DBUS_TYPE_INT32,
00759                                    &our_int32_array, &our_int32_array_len,
00760 #ifdef DBUS_HAVE_INT64
00761                                    DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64,
00762                                    &our_uint64_array, &our_uint64_array_len,
00763                                    DBUS_TYPE_ARRAY, DBUS_TYPE_INT64,
00764                                    &our_int64_array, &our_int64_array_len,
00765 #endif
00766                                    DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE,
00767                                    &our_double_array, &our_double_array_len,
00768                                    DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
00769                                    &our_byte_array, &our_byte_array_len,
00770                                    DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN,
00771                                    &our_boolean_array, &our_boolean_array_len,
00772                                    DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
00773                                    &our_string_array, &our_string_array_len,
00774                                    0))
00775     {
00776       _dbus_warn ("error: %s - %s\n", error.name,
00777                   (error.message != NULL) ? error.message : "no message");
00778       _dbus_assert_not_reached ("Could not get arguments");
00779     }
00780 
00781   if (our_int16 != -0x123)
00782     _dbus_assert_not_reached ("16-bit integers differ!");
00783 
00784   if (our_uint16 != 0x123)
00785     _dbus_assert_not_reached ("16-bit uints differ!");
00786   
00787   if (our_int != -0x12345678)
00788     _dbus_assert_not_reached ("integers differ!");
00789 
00790   if (our_uint != 0x12300042)
00791     _dbus_assert_not_reached ("uints differ!");
00792 
00793 #ifdef DBUS_HAVE_INT64
00794   if (our_int64 != DBUS_INT64_CONSTANT (-0x123456789abcd))
00795     _dbus_assert_not_reached ("64-bit integers differ!");
00796   if (our_uint64 != DBUS_UINT64_CONSTANT (0x123456789abcd))
00797     _dbus_assert_not_reached ("64-bit unsigned integers differ!");
00798 #endif
00799 
00800   v_DOUBLE = 3.14159;
00801   if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double, v_DOUBLE))
00802     _dbus_assert_not_reached ("doubles differ!");
00803 
00804   if (strcmp (our_str, "Test string") != 0)
00805     _dbus_assert_not_reached ("strings differ!");
00806 
00807   if (!our_bool)
00808     _dbus_assert_not_reached ("booleans differ");
00809 
00810   if (our_byte_1 != 42)
00811     _dbus_assert_not_reached ("bytes differ!");
00812 
00813   if (our_byte_2 != 24)
00814     _dbus_assert_not_reached ("bytes differ!");
00815 
00816   if (our_uint32_array_len != 4 ||
00817       our_uint32_array[0] != 0x12345678 ||
00818       our_uint32_array[1] != 0x23456781 ||
00819       our_uint32_array[2] != 0x34567812 ||
00820       our_uint32_array[3] != 0x45678123)
00821     _dbus_assert_not_reached ("uint array differs");
00822 
00823   if (our_int32_array_len != 4 ||
00824       our_int32_array[0] != 0x12345678 ||
00825       our_int32_array[1] != -0x23456781 ||
00826       our_int32_array[2] != 0x34567812 ||
00827       our_int32_array[3] != -0x45678123)
00828     _dbus_assert_not_reached ("int array differs");
00829 
00830 #ifdef DBUS_HAVE_INT64
00831   if (our_uint64_array_len != 4 ||
00832       our_uint64_array[0] != 0x12345678 ||
00833       our_uint64_array[1] != 0x23456781 ||
00834       our_uint64_array[2] != 0x34567812 ||
00835       our_uint64_array[3] != 0x45678123)
00836     _dbus_assert_not_reached ("uint64 array differs");
00837 
00838   if (our_int64_array_len != 4 ||
00839       our_int64_array[0] != 0x12345678 ||
00840       our_int64_array[1] != -0x23456781 ||
00841       our_int64_array[2] != 0x34567812 ||
00842       our_int64_array[3] != -0x45678123)
00843     _dbus_assert_not_reached ("int64 array differs");
00844 #endif /* DBUS_HAVE_INT64 */
00845 
00846   if (our_double_array_len != 3)
00847     _dbus_assert_not_reached ("double array had wrong length");
00848 
00849   /* On all IEEE machines (i.e. everything sane) exact equality
00850    * should be preserved over the wire
00851    */
00852   v_DOUBLE = 0.1234;
00853   if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[0], v_DOUBLE))
00854     _dbus_assert_not_reached ("double array had wrong values");
00855   v_DOUBLE = 9876.54321;
00856   if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[1], v_DOUBLE))
00857     _dbus_assert_not_reached ("double array had wrong values");
00858   v_DOUBLE = -300.0;
00859   if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[2], v_DOUBLE))
00860     _dbus_assert_not_reached ("double array had wrong values");
00861 
00862   if (our_byte_array_len != 4)
00863     _dbus_assert_not_reached ("byte array had wrong length");
00864 
00865   if (our_byte_array[0] != 'a' ||
00866       our_byte_array[1] != 'b' ||
00867       our_byte_array[2] != 'c' ||
00868       our_byte_array[3] != 234)
00869     _dbus_assert_not_reached ("byte array had wrong values");
00870 
00871   if (our_boolean_array_len != 5)
00872     _dbus_assert_not_reached ("bool array had wrong length");
00873 
00874   if (our_boolean_array[0] != TRUE ||
00875       our_boolean_array[1] != FALSE ||
00876       our_boolean_array[2] != TRUE ||
00877       our_boolean_array[3] != TRUE ||
00878       our_boolean_array[4] != FALSE)
00879     _dbus_assert_not_reached ("bool array had wrong values");
00880 
00881   if (our_string_array_len != 4)
00882     _dbus_assert_not_reached ("string array was wrong length");
00883 
00884   if (strcmp (our_string_array[0], "Foo") != 0 ||
00885       strcmp (our_string_array[1], "bar") != 0 ||
00886       strcmp (our_string_array[2], "") != 0 ||
00887       strcmp (our_string_array[3], "woo woo woo woo") != 0)
00888     _dbus_assert_not_reached ("string array had wrong values");
00889 
00890   dbus_free_string_array (our_string_array);
00891   
00892   if (dbus_message_iter_next (&iter))
00893     _dbus_assert_not_reached ("Didn't reach end of arguments");
00894 }
00895 
00902 dbus_bool_t
00903 _dbus_message_test (const char *test_data_dir)
00904 {
00905   DBusMessage *message;
00906   DBusMessageLoader *loader;
00907   int i;
00908   const char *data;
00909   DBusMessage *copy;
00910   const char *name1;
00911   const char *name2;
00912   const dbus_uint32_t our_uint32_array[] =
00913     { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
00914   const dbus_int32_t our_int32_array[] =
00915     { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
00916   const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
00917   const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
00918 #ifdef DBUS_HAVE_INT64
00919   const dbus_uint64_t our_uint64_array[] =
00920     { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
00921   const dbus_int64_t our_int64_array[] =
00922     { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
00923   const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
00924   const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
00925 #endif
00926   const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
00927   const char **v_ARRAY_STRING = our_string_array;
00928   const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
00929   const double *v_ARRAY_DOUBLE = our_double_array;
00930   const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 };
00931   const unsigned char *v_ARRAY_BYTE = our_byte_array;
00932   const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
00933   const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
00934   char sig[64];
00935   const char *s;
00936   const char *v_STRING;
00937   double v_DOUBLE;
00938   dbus_int16_t v_INT16;
00939   dbus_uint16_t v_UINT16;
00940   dbus_int32_t v_INT32;
00941   dbus_uint32_t v_UINT32;
00942 #ifdef DBUS_HAVE_INT64
00943   dbus_int64_t v_INT64;
00944   dbus_uint64_t v_UINT64;
00945 #endif
00946   unsigned char v_BYTE;
00947   unsigned char v2_BYTE;
00948   dbus_bool_t v_BOOLEAN;
00949 
00950   message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
00951                                           "/org/freedesktop/TestPath",
00952                                           "Foo.TestInterface",
00953                                           "TestMethod");
00954   _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
00955   _dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface",
00956                                              "TestMethod"));
00957   _dbus_assert (strcmp (dbus_message_get_path (message),
00958                         "/org/freedesktop/TestPath") == 0);
00959   _dbus_message_set_serial (message, 1234);
00960 
00961   /* string length including nul byte not a multiple of 4 */
00962   if (!dbus_message_set_sender (message, "org.foo.bar1"))
00963     _dbus_assert_not_reached ("out of memory");
00964 
00965   _dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
00966   dbus_message_set_reply_serial (message, 5678);
00967 
00968   _dbus_verbose_bytes_of_string (&message->header.data, 0,
00969                                  _dbus_string_get_length (&message->header.data));
00970   _dbus_verbose_bytes_of_string (&message->body, 0,
00971                                  _dbus_string_get_length (&message->body));
00972 
00973   if (!dbus_message_set_sender (message, NULL))
00974     _dbus_assert_not_reached ("out of memory");
00975 
00976 
00977   _dbus_verbose_bytes_of_string (&message->header.data, 0,
00978                                  _dbus_string_get_length (&message->header.data));
00979   _dbus_verbose_bytes_of_string (&message->body, 0,
00980                                  _dbus_string_get_length (&message->body));
00981 
00982 
00983   _dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1"));
00984   _dbus_assert (dbus_message_get_serial (message) == 1234);
00985   _dbus_assert (dbus_message_get_reply_serial (message) == 5678);
00986   _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
00987 
00988   _dbus_assert (dbus_message_get_no_reply (message) == FALSE);
00989   dbus_message_set_no_reply (message, TRUE);
00990   _dbus_assert (dbus_message_get_no_reply (message) == TRUE);
00991   dbus_message_set_no_reply (message, FALSE);
00992   _dbus_assert (dbus_message_get_no_reply (message) == FALSE);
00993 
00994   /* Set/get some header fields */
00995 
00996   if (!dbus_message_set_path (message, "/foo"))
00997     _dbus_assert_not_reached ("out of memory");
00998   _dbus_assert (strcmp (dbus_message_get_path (message),
00999                         "/foo") == 0);
01000 
01001   if (!dbus_message_set_interface (message, "org.Foo"))
01002     _dbus_assert_not_reached ("out of memory");
01003   _dbus_assert (strcmp (dbus_message_get_interface (message),
01004                         "org.Foo") == 0);
01005 
01006   if (!dbus_message_set_member (message, "Bar"))
01007     _dbus_assert_not_reached ("out of memory");
01008   _dbus_assert (strcmp (dbus_message_get_member (message),
01009                         "Bar") == 0);
01010 
01011   /* Set/get them with longer values */
01012   if (!dbus_message_set_path (message, "/foo/bar"))
01013     _dbus_assert_not_reached ("out of memory");
01014   _dbus_assert (strcmp (dbus_message_get_path (message),
01015                         "/foo/bar") == 0);
01016 
01017   if (!dbus_message_set_interface (message, "org.Foo.Bar"))
01018     _dbus_assert_not_reached ("out of memory");
01019   _dbus_assert (strcmp (dbus_message_get_interface (message),
01020                         "org.Foo.Bar") == 0);
01021 
01022   if (!dbus_message_set_member (message, "BarFoo"))
01023     _dbus_assert_not_reached ("out of memory");
01024   _dbus_assert (strcmp (dbus_message_get_member (message),
01025                         "BarFoo") == 0);
01026 
01027   /* Realloc shorter again */
01028 
01029   if (!dbus_message_set_path (message, "/foo"))
01030     _dbus_assert_not_reached ("out of memory");
01031   _dbus_assert (strcmp (dbus_message_get_path (message),
01032                         "/foo") == 0);
01033 
01034   if (!dbus_message_set_interface (message, "org.Foo"))
01035     _dbus_assert_not_reached ("out of memory");
01036   _dbus_assert (strcmp (dbus_message_get_interface (message),
01037                         "org.Foo") == 0);
01038 
01039   if (!dbus_message_set_member (message, "Bar"))
01040     _dbus_assert_not_reached ("out of memory");
01041   _dbus_assert (strcmp (dbus_message_get_member (message),
01042                         "Bar") == 0);
01043 
01044   dbus_message_unref (message);
01045 
01046   /* Test the vararg functions */
01047   message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
01048                                           "/org/freedesktop/TestPath",
01049                                           "Foo.TestInterface",
01050                                           "TestMethod");
01051   _dbus_message_set_serial (message, 1);
01052   dbus_message_set_reply_serial (message, 5678);
01053 
01054   v_INT16 = -0x123;
01055   v_UINT16 = 0x123;
01056   v_INT32 = -0x12345678;
01057   v_UINT32 = 0x12300042;
01058 #ifdef DBUS_HAVE_INT64
01059   v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
01060   v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
01061 #endif
01062   v_STRING = "Test string";
01063   v_DOUBLE = 3.14159;
01064   v_BOOLEAN = TRUE;
01065   v_BYTE = 42;
01066   v2_BYTE = 24;
01067 
01068   dbus_message_append_args (message,
01069                             DBUS_TYPE_INT16, &v_INT16,
01070                             DBUS_TYPE_UINT16, &v_UINT16,
01071                             DBUS_TYPE_INT32, &v_INT32,
01072                             DBUS_TYPE_UINT32, &v_UINT32,
01073 #ifdef DBUS_HAVE_INT64
01074                             DBUS_TYPE_INT64, &v_INT64,
01075                             DBUS_TYPE_UINT64, &v_UINT64,
01076 #endif
01077                             DBUS_TYPE_STRING, &v_STRING,
01078                             DBUS_TYPE_DOUBLE, &v_DOUBLE,
01079                             DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
01080                             DBUS_TYPE_BYTE, &v_BYTE,
01081                             DBUS_TYPE_BYTE, &v2_BYTE,
01082                             DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32,
01083                             _DBUS_N_ELEMENTS (our_uint32_array),
01084                             DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
01085                             _DBUS_N_ELEMENTS (our_int32_array),
01086 #ifdef DBUS_HAVE_INT64
01087                             DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
01088                             _DBUS_N_ELEMENTS (our_uint64_array),
01089                             DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
01090                             _DBUS_N_ELEMENTS (our_int64_array),
01091 #endif
01092                             DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
01093                             _DBUS_N_ELEMENTS (our_double_array),
01094                             DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
01095                             _DBUS_N_ELEMENTS (our_byte_array),
01096                             DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN,
01097                             _DBUS_N_ELEMENTS (our_boolean_array),
01098                             DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
01099                             _DBUS_N_ELEMENTS (our_string_array),
01100                             DBUS_TYPE_INVALID);
01101 
01102   i = 0;
01103   sig[i++] = DBUS_TYPE_INT16;
01104   sig[i++] = DBUS_TYPE_UINT16;
01105   sig[i++] = DBUS_TYPE_INT32;
01106   sig[i++] = DBUS_TYPE_UINT32;
01107 #ifdef DBUS_HAVE_INT64
01108   sig[i++] = DBUS_TYPE_INT64;
01109   sig[i++] = DBUS_TYPE_UINT64;
01110 #endif
01111   sig[i++] = DBUS_TYPE_STRING;
01112   sig[i++] = DBUS_TYPE_DOUBLE;
01113   sig[i++] = DBUS_TYPE_BOOLEAN;
01114   sig[i++] = DBUS_TYPE_BYTE;
01115   sig[i++] = DBUS_TYPE_BYTE;
01116   sig[i++] = DBUS_TYPE_ARRAY;
01117   sig[i++] = DBUS_TYPE_UINT32;
01118   sig[i++] = DBUS_TYPE_ARRAY;
01119   sig[i++] = DBUS_TYPE_INT32;
01120 #ifdef DBUS_HAVE_INT64
01121   sig[i++] = DBUS_TYPE_ARRAY;
01122   sig[i++] = DBUS_TYPE_UINT64;
01123   sig[i++] = DBUS_TYPE_ARRAY;
01124   sig[i++] = DBUS_TYPE_INT64;
01125 #endif
01126   sig[i++] = DBUS_TYPE_ARRAY;
01127   sig[i++] = DBUS_TYPE_DOUBLE;
01128   sig[i++] = DBUS_TYPE_ARRAY;
01129   sig[i++] = DBUS_TYPE_BYTE;
01130   sig[i++] = DBUS_TYPE_ARRAY;
01131   sig[i++] = DBUS_TYPE_BOOLEAN;
01132   sig[i++] = DBUS_TYPE_ARRAY;
01133   sig[i++] = DBUS_TYPE_STRING;
01134   sig[i++] = DBUS_TYPE_INVALID;  
01135 
01136   _dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
01137 
01138   _dbus_verbose ("HEADER\n");
01139   _dbus_verbose_bytes_of_string (&message->header.data, 0,
01140                                  _dbus_string_get_length (&message->header.data));
01141   _dbus_verbose ("BODY\n");
01142   _dbus_verbose_bytes_of_string (&message->body, 0,
01143                                  _dbus_string_get_length (&message->body));
01144 
01145   _dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n",
01146                  sig, dbus_message_get_signature (message));
01147 
01148   s = dbus_message_get_signature (message);
01149 
01150   _dbus_assert (dbus_message_has_signature (message, sig));
01151   _dbus_assert (strcmp (s, sig) == 0);
01152 
01153   verify_test_message (message);
01154 
01155   copy = dbus_message_copy (message);
01156 
01157   _dbus_assert (dbus_message_get_reply_serial (message) ==
01158                 dbus_message_get_reply_serial (copy));
01159   _dbus_assert (message->header.padding == copy->header.padding);
01160 
01161   _dbus_assert (_dbus_string_get_length (&message->header.data) ==
01162                 _dbus_string_get_length (&copy->header.data));
01163 
01164   _dbus_assert (_dbus_string_get_length (&message->body) ==
01165                 _dbus_string_get_length (&copy->body));
01166 
01167   verify_test_message (copy);
01168 
01169   name1 = dbus_message_get_interface (message);
01170   name2 = dbus_message_get_interface (copy);
01171 
01172   _dbus_assert (strcmp (name1, name2) == 0);
01173 
01174   name1 = dbus_message_get_member (message);
01175   name2 = dbus_message_get_member (copy);
01176 
01177   _dbus_assert (strcmp (name1, name2) == 0);
01178 
01179   dbus_message_unref (copy);
01180 
01181   /* Message loader test */
01182   _dbus_message_lock (message);
01183   loader = _dbus_message_loader_new ();
01184   
01185   /* check ref/unref */
01186   _dbus_message_loader_ref (loader);
01187   _dbus_message_loader_unref (loader);
01188 
01189   /* Write the header data one byte at a time */
01190   data = _dbus_string_get_const_data (&message->header.data);
01191   for (i = 0; i < _dbus_string_get_length (&message->header.data); i++)
01192     {
01193       DBusString *buffer;
01194 
01195       _dbus_message_loader_get_buffer (loader, &buffer);
01196       _dbus_string_append_byte (buffer, data[i]);
01197       _dbus_message_loader_return_buffer (loader, buffer, 1);
01198     }
01199 
01200   /* Write the body data one byte at a time */
01201   data = _dbus_string_get_const_data (&message->body);
01202   for (i = 0; i < _dbus_string_get_length (&message->body); i++)
01203     {
01204       DBusString *buffer;
01205 
01206       _dbus_message_loader_get_buffer (loader, &buffer);
01207       _dbus_string_append_byte (buffer, data[i]);
01208       _dbus_message_loader_return_buffer (loader, buffer, 1);
01209     }
01210 
01211   dbus_message_unref (message);
01212 
01213   /* Now pop back the message */
01214   if (!_dbus_message_loader_queue_messages (loader))
01215     _dbus_assert_not_reached ("no memory to queue messages");
01216 
01217   if (_dbus_message_loader_get_is_corrupted (loader))
01218     _dbus_assert_not_reached ("message loader corrupted");
01219 
01220   message = _dbus_message_loader_pop_message (loader);
01221   if (!message)
01222     _dbus_assert_not_reached ("received a NULL message");
01223 
01224   if (dbus_message_get_reply_serial (message) != 5678)
01225     _dbus_assert_not_reached ("reply serial fields differ");
01226 
01227   verify_test_message (message);
01228 
01229   dbus_message_unref (message);
01230   _dbus_message_loader_unref (loader);
01231 
01232   check_memleaks ();
01233 
01234   /* Load all the sample messages from the message factory */
01235   {
01236     DBusMessageDataIter diter;
01237     DBusMessageData mdata;
01238     int count;
01239 
01240     reset_validities_seen ();
01241     
01242     count = 0;
01243     _dbus_message_data_iter_init (&diter);
01244     
01245     while (_dbus_message_data_iter_get_and_next (&diter,
01246                                                  &mdata))
01247       {
01248         if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
01249                                                         mdata.expected_validity))
01250           {
01251             _dbus_warn ("expected validity %d and did not get it\n",
01252                         mdata.expected_validity);
01253             _dbus_assert_not_reached ("message data failed");
01254           }
01255 
01256         _dbus_message_data_free (&mdata);
01257 
01258         count += 1;
01259       }
01260 
01261     printf ("%d sample messages tested\n", count);
01262 
01263     print_validities_seen (FALSE);
01264     print_validities_seen (TRUE);
01265   }
01266   
01267   check_memleaks ();
01268   
01269   /* Now load every message in test_data_dir if we have one */
01270   if (test_data_dir == NULL)
01271     return TRUE;
01272 
01273   return dbus_internal_do_not_use_foreach_message_file (test_data_dir,
01274                                                         (DBusForeachMessageFileFunc)
01275                                                         dbus_internal_do_not_use_try_message_file,
01276                                                         NULL);  
01277 }
01278 
01279 #endif /* DBUS_BUILD_TESTS */

Generated on Tue Jul 7 15:13:59 2009 for D-BUS by  doxygen 1.4.6