00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
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
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
00164
00165
00166
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
00259
00260
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
00368
00369 loader = _dbus_message_loader_new ();
00370
00371
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
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
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
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
00845
00846 if (our_double_array_len != 3)
00847 _dbus_assert_not_reached ("double array had wrong length");
00848
00849
00850
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
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
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
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
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
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 (©->header.data));
01163
01164 _dbus_assert (_dbus_string_get_length (&message->body) ==
01165 _dbus_string_get_length (©->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
01182 _dbus_message_lock (message);
01183 loader = _dbus_message_loader_new ();
01184
01185
01186 _dbus_message_loader_ref (loader);
01187 _dbus_message_loader_unref (loader);
01188
01189
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
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
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
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
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