00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
#include "dbus-internals.h"
00025
#include "dbus-list.h"
00026
#include "dbus-mempool.h"
00027
#include "dbus-threads.h"
00028
00037
static DBusMemPool *list_pool;
00038
_DBUS_DEFINE_GLOBAL_LOCK (list);
00039
00050
00051
00052
00053
static DBusList*
00054 alloc_link (
void *data)
00055 {
00056
DBusList *link;
00057
00058
if (!
_DBUS_LOCK (list))
00059
return NULL;
00060
00061
if (list_pool ==
NULL)
00062 {
00063 list_pool =
_dbus_mem_pool_new (
sizeof (
DBusList), TRUE);
00064
00065
if (list_pool ==
NULL)
00066 {
00067
_DBUS_UNLOCK (list);
00068
return NULL;
00069 }
00070
00071 link =
_dbus_mem_pool_alloc (list_pool);
00072
if (link ==
NULL)
00073 {
00074
_dbus_mem_pool_free (list_pool);
00075 list_pool =
NULL;
00076
_DBUS_UNLOCK (list);
00077
return NULL;
00078 }
00079 }
00080
else
00081 {
00082 link =
_dbus_mem_pool_alloc (list_pool);
00083 }
00084
00085
if (link)
00086 link->
data = data;
00087
00088
_DBUS_UNLOCK (list);
00089
00090
return link;
00091 }
00092
00093
static void
00094 free_link (
DBusList *link)
00095 {
00096
_DBUS_LOCK (list);
00097
if (
_dbus_mem_pool_dealloc (list_pool, link))
00098 {
00099
_dbus_mem_pool_free (list_pool);
00100 list_pool =
NULL;
00101 }
00102
00103
_DBUS_UNLOCK (list);
00104 }
00105
00106
static void
00107 link_before (
DBusList **list,
00108
DBusList *before_this_link,
00109
DBusList *link)
00110 {
00111
if (*list ==
NULL)
00112 {
00113 link->
prev = link;
00114 link->
next = link;
00115 *list = link;
00116 }
00117
else
00118 {
00119 link->
next = before_this_link;
00120 link->
prev = before_this_link->
prev;
00121 before_this_link->
prev = link;
00122 link->
prev->
next = link;
00123
00124
if (before_this_link == *list)
00125 *list = link;
00126 }
00127 }
00128
00129
static void
00130 link_after (
DBusList **list,
00131
DBusList *after_this_link,
00132
DBusList *link)
00133 {
00134
if (*list ==
NULL)
00135 {
00136 link->
prev = link;
00137 link->
next = link;
00138 *list = link;
00139 }
00140
else
00141 {
00142 link->
prev = after_this_link;
00143 link->
next = after_this_link->
next;
00144 after_this_link->
next = link;
00145 link->
next->
prev = link;
00146 }
00147 }
00148
00218
DBusList*
00219 _dbus_list_alloc_link (
void *data)
00220 {
00221
return alloc_link (data);
00222 }
00223
00230
void
00231 _dbus_list_free_link (
DBusList *link)
00232 {
00233 free_link (link);
00234 }
00235
00236
00246
dbus_bool_t
00247 _dbus_list_append (
DBusList **list,
00248
void *data)
00249 {
00250
if (!
_dbus_list_prepend (list, data))
00251
return FALSE;
00252
00253
00254 *list = (*list)->
next;
00255
00256
return TRUE;
00257 }
00258
00268
dbus_bool_t
00269 _dbus_list_prepend (
DBusList **list,
00270
void *data)
00271 {
00272
DBusList *link;
00273
00274 link = alloc_link (data);
00275
if (link ==
NULL)
00276
return FALSE;
00277
00278 link_before (list, *list, link);
00279
00280
return TRUE;
00281 }
00282
00291
void
00292 _dbus_list_append_link (
DBusList **list,
00293
DBusList *link)
00294 {
00295
_dbus_list_prepend_link (list, link);
00296
00297
00298 *list = (*list)->
next;
00299 }
00300
00309
void
00310 _dbus_list_prepend_link (
DBusList **list,
00311
DBusList *link)
00312 {
00313 link_before (list, *list, link);
00314 }
00315
00324
dbus_bool_t
00325 _dbus_list_insert_before (
DBusList **list,
00326
DBusList *before_this_link,
00327
void *data)
00328 {
00329
DBusList *link;
00330
00331
if (before_this_link ==
NULL)
00332
return _dbus_list_append (list, data);
00333
else
00334 {
00335 link = alloc_link (data);
00336
if (link ==
NULL)
00337
return FALSE;
00338
00339 link_before (list, before_this_link, link);
00340 }
00341
00342
return TRUE;
00343 }
00344
00353
dbus_bool_t
00354 _dbus_list_insert_after (
DBusList **list,
00355
DBusList *after_this_link,
00356
void *data)
00357 {
00358
DBusList *link;
00359
00360
if (after_this_link ==
NULL)
00361
return _dbus_list_prepend (list, data);
00362
else
00363 {
00364 link = alloc_link (data);
00365
if (link ==
NULL)
00366
return FALSE;
00367
00368 link_after (list, after_this_link, link);
00369 }
00370
00371
return TRUE;
00372 }
00373
00381
void
00382 _dbus_list_insert_before_link (
DBusList **list,
00383
DBusList *before_this_link,
00384
DBusList *link)
00385 {
00386
if (before_this_link ==
NULL)
00387
_dbus_list_append_link (list, link);
00388
else
00389 link_before (list, before_this_link, link);
00390 }
00391
00399
void
00400 _dbus_list_insert_after_link (
DBusList **list,
00401
DBusList *after_this_link,
00402
DBusList *link)
00403 {
00404
if (after_this_link ==
NULL)
00405
_dbus_list_prepend_link (list, link);
00406
else
00407 link_after (list, after_this_link, link);
00408 }
00409
00420
dbus_bool_t
00421 _dbus_list_remove (
DBusList **list,
00422
void *data)
00423 {
00424
DBusList *link;
00425
00426 link = *list;
00427
while (link !=
NULL)
00428 {
00429
if (link->
data == data)
00430 {
00431
_dbus_list_remove_link (list, link);
00432
return TRUE;
00433 }
00434
00435 link =
_dbus_list_get_next_link (list, link);
00436 }
00437
00438
return FALSE;
00439 }
00440
00451
dbus_bool_t
00452 _dbus_list_remove_last (
DBusList **list,
00453
void *data)
00454 {
00455
DBusList *link;
00456
00457 link =
_dbus_list_find_last (list, data);
00458
if (link)
00459 {
00460
_dbus_list_remove_link (list, link);
00461
return TRUE;
00462 }
00463
else
00464
return FALSE;
00465 }
00466
00477
DBusList*
00478 _dbus_list_find_last (
DBusList **list,
00479
void *data)
00480 {
00481
DBusList *link;
00482
00483 link =
_dbus_list_get_last_link (list);
00484
00485
while (link !=
NULL)
00486 {
00487
if (link->
data == data)
00488
return link;
00489
00490 link =
_dbus_list_get_prev_link (list, link);
00491 }
00492
00493
return NULL;
00494 }
00495
00504
void
00505 _dbus_list_unlink (
DBusList **list,
00506
DBusList *link)
00507 {
00508
if (link->
next == link)
00509 {
00510
00511 *list =
NULL;
00512 }
00513
else
00514 {
00515 link->
prev->
next = link->
next;
00516 link->
next->
prev = link->
prev;
00517
00518
if (*list == link)
00519 *list = link->
next;
00520 }
00521
00522 link->
next =
NULL;
00523 link->
prev =
NULL;
00524 }
00525
00532
void
00533 _dbus_list_remove_link (
DBusList **list,
00534
DBusList *link)
00535 {
00536
_dbus_list_unlink (list, link);
00537 free_link (link);
00538 }
00539
00547
void
00548 _dbus_list_clear (
DBusList **list)
00549 {
00550
DBusList *link;
00551
00552 link = *list;
00553
while (link !=
NULL)
00554 {
00555
DBusList *next =
_dbus_list_get_next_link (list, link);
00556
00557 free_link (link);
00558
00559 link = next;
00560 }
00561
00562 *list =
NULL;
00563 }
00564
00572
DBusList*
00573 _dbus_list_get_first_link (
DBusList **list)
00574 {
00575
return *list;
00576 }
00577
00585
DBusList*
00586 _dbus_list_get_last_link (
DBusList **list)
00587 {
00588
if (*list ==
NULL)
00589
return NULL;
00590
else
00591
return (*list)->prev;
00592 }
00593
00601
void*
00602 _dbus_list_get_last (
DBusList **list)
00603 {
00604
if (*list ==
NULL)
00605
return NULL;
00606
else
00607
return (*list)->prev->data;
00608 }
00609
00617
void*
00618 _dbus_list_get_first (
DBusList **list)
00619 {
00620
if (*list ==
NULL)
00621
return NULL;
00622
else
00623
return (*list)->data;
00624 }
00625
00633
DBusList*
00634 _dbus_list_pop_first_link (
DBusList **list)
00635 {
00636
DBusList *link;
00637
00638 link =
_dbus_list_get_first_link (list);
00639
if (link ==
NULL)
00640
return NULL;
00641
00642
_dbus_list_unlink (list, link);
00643
00644
return link;
00645 }
00646
00654
void*
00655 _dbus_list_pop_first (
DBusList **list)
00656 {
00657
DBusList *link;
00658
void *data;
00659
00660 link =
_dbus_list_get_first_link (list);
00661
if (link ==
NULL)
00662
return NULL;
00663
00664 data = link->
data;
00665
_dbus_list_remove_link (list, link);
00666
00667
return data;
00668 }
00669
00677
void*
00678 _dbus_list_pop_last (
DBusList **list)
00679 {
00680
DBusList *link;
00681
void *data;
00682
00683 link =
_dbus_list_get_last_link (list);
00684
if (link ==
NULL)
00685
return NULL;
00686
00687 data = link->
data;
00688
_dbus_list_remove_link (list, link);
00689
00690
return data;
00691 }
00692
00700
DBusList*
00701 _dbus_list_pop_last_link (
DBusList **list)
00702 {
00703
DBusList *link;
00704
00705 link =
_dbus_list_get_last_link (list);
00706
if (link ==
NULL)
00707
return NULL;
00708
00709
_dbus_list_unlink (list, link);
00710
00711
return link;
00712 }
00713
00723
dbus_bool_t
00724 _dbus_list_copy (
DBusList **list,
00725
DBusList **dest)
00726 {
00727
DBusList *link;
00728
00729
_dbus_assert (list != dest);
00730
00731 *dest =
NULL;
00732
00733 link = *list;
00734
while (link !=
NULL)
00735 {
00736
if (!
_dbus_list_append (dest, link->
data))
00737 {
00738
00739
_dbus_list_clear (dest);
00740
return FALSE;
00741 }
00742
00743 link =
_dbus_list_get_next_link (list, link);
00744 }
00745
00746
return TRUE;
00747 }
00748
00756
int
00757 _dbus_list_get_length (
DBusList **list)
00758 {
00759
DBusList *link;
00760
int length;
00761
00762 length = 0;
00763
00764 link = *list;
00765
while (link !=
NULL)
00766 {
00767 ++length;
00768
00769 link =
_dbus_list_get_next_link (list, link);
00770 }
00771
00772
return length;
00773 }
00774
00785
void
00786 _dbus_list_foreach (
DBusList **list,
00787 DBusForeachFunction function,
00788
void *data)
00789 {
00790
DBusList *link;
00791
00792 link = *list;
00793
while (link !=
NULL)
00794 {
00795
DBusList *next =
_dbus_list_get_next_link (list, link);
00796
00797 (* function) (link->
data, data);
00798
00799 link = next;
00800 }
00801 }
00802
00809
dbus_bool_t
00810 _dbus_list_length_is_one (
DBusList **list)
00811 {
00812
return (*list !=
NULL &&
00813 (*list)->next == *list);
00814 }
00815
00818
#ifdef DBUS_BUILD_TESTS
00819
#include "dbus-test.h"
00820
#include <stdio.h>
00821
00822
static void
00823 verify_list (
DBusList **list)
00824 {
00825
DBusList *link;
00826
int length;
00827
00828 link = *list;
00829
00830
if (link ==
NULL)
00831
return;
00832
00833
if (link->
next == link)
00834 {
00835
_dbus_assert (link->
prev == link);
00836
_dbus_assert (*list == link);
00837
return;
00838 }
00839
00840 length = 0;
00841
do
00842 {
00843 length += 1;
00844
_dbus_assert (link->
prev->
next == link);
00845
_dbus_assert (link->
next->
prev == link);
00846 link = link->
next;
00847 }
00848
while (link != *list);
00849
00850
_dbus_assert (length == _dbus_list_get_length (list));
00851
00852
if (length == 1)
00853
_dbus_assert (_dbus_list_length_is_one (list));
00854
else
00855
_dbus_assert (!_dbus_list_length_is_one (list));
00856 }
00857
00858
static dbus_bool_t
00859 is_ascending_sequence (
DBusList **list)
00860 {
00861
DBusList *link;
00862
int prev;
00863
00864 prev =
_DBUS_INT_MIN;
00865
00866 link =
_dbus_list_get_first_link (list);
00867
while (link !=
NULL)
00868 {
00869
int v =
_DBUS_POINTER_TO_INT (link->
data);
00870
00871
if (v <= prev)
00872
return FALSE;
00873
00874 prev = v;
00875
00876 link =
_dbus_list_get_next_link (list, link);
00877 }
00878
00879
return TRUE;
00880 }
00881
00882
static dbus_bool_t
00883 is_descending_sequence (
DBusList **list)
00884 {
00885
DBusList *link;
00886
int prev;
00887
00888 prev =
_DBUS_INT_MAX;
00889
00890 link =
_dbus_list_get_first_link (list);
00891
while (link !=
NULL)
00892 {
00893
int v =
_DBUS_POINTER_TO_INT (link->
data);
00894
00895
if (v >= prev)
00896
return FALSE;
00897
00898 prev = v;
00899
00900 link =
_dbus_list_get_next_link (list, link);
00901 }
00902
00903
return TRUE;
00904 }
00905
00906
static dbus_bool_t
00907 all_even_values (
DBusList **list)
00908 {
00909
DBusList *link;
00910
00911 link =
_dbus_list_get_first_link (list);
00912
while (link !=
NULL)
00913 {
00914
int v =
_DBUS_POINTER_TO_INT (link->
data);
00915
00916
if ((v % 2) != 0)
00917
return FALSE;
00918
00919 link =
_dbus_list_get_next_link (list, link);
00920 }
00921
00922
return TRUE;
00923 }
00924
00925
static dbus_bool_t
00926 all_odd_values (
DBusList **list)
00927 {
00928
DBusList *link;
00929
00930 link =
_dbus_list_get_first_link (list);
00931
while (link !=
NULL)
00932 {
00933
int v =
_DBUS_POINTER_TO_INT (link->
data);
00934
00935
if ((v % 2) == 0)
00936
return FALSE;
00937
00938 link =
_dbus_list_get_next_link (list, link);
00939 }
00940
00941
return TRUE;
00942 }
00943
00944
static dbus_bool_t
00945 lists_equal (
DBusList **list1,
00946
DBusList **list2)
00947 {
00948
DBusList *link1;
00949
DBusList *link2;
00950
00951 link1 =
_dbus_list_get_first_link (list1);
00952 link2 =
_dbus_list_get_first_link (list2);
00953
while (link1 && link2)
00954 {
00955
if (link1->
data != link2->
data)
00956
return FALSE;
00957
00958 link1 =
_dbus_list_get_next_link (list1, link1);
00959 link2 =
_dbus_list_get_next_link (list2, link2);
00960 }
00961
00962
if (link1 || link2)
00963
return FALSE;
00964
00965
return TRUE;
00966 }
00967
00973
dbus_bool_t
00974 _dbus_list_test (
void)
00975 {
00976
DBusList *list1;
00977
DBusList *list2;
00978
DBusList *link1;
00979
DBusList *link2;
00980
DBusList *copy1;
00981
DBusList *copy2;
00982
int i;
00983
00984 list1 =
NULL;
00985 list2 =
NULL;
00986
00987
00988
00989 i = 0;
00990
while (i < 10)
00991 {
00992
if (!
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
00993
_dbus_assert_not_reached (
"could not allocate for append");
00994
00995
if (!
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
00996
_dbus_assert_not_reached (
"count not allocate for prepend");
00997 ++i;
00998
00999 verify_list (&list1);
01000 verify_list (&list2);
01001
01002
_dbus_assert (_dbus_list_get_length (&list1) == i);
01003
_dbus_assert (_dbus_list_get_length (&list2) == i);
01004 }
01005
01006
_dbus_assert (is_ascending_sequence (&list1));
01007
_dbus_assert (is_descending_sequence (&list2));
01008
01009
01010
_dbus_list_clear (&list1);
01011
_dbus_list_clear (&list2);
01012
01013 verify_list (&list1);
01014 verify_list (&list2);
01015
01016
01017
01018 i = 0;
01019
while (i < 10)
01020 {
01021
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
01022
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
01023 ++i;
01024 }
01025
01026 --i;
01027
while (i >= 0)
01028 {
01029
void *got_data1;
01030
void *got_data2;
01031
01032
void *data1;
01033
void *data2;
01034
01035 got_data1 =
_dbus_list_get_last (&list1);
01036 got_data2 =
_dbus_list_get_first (&list2);
01037
01038 data1 =
_dbus_list_pop_last (&list1);
01039 data2 =
_dbus_list_pop_first (&list2);
01040
01041
_dbus_assert (got_data1 == data1);
01042
_dbus_assert (got_data2 == data2);
01043
01044
_dbus_assert (_DBUS_POINTER_TO_INT (data1) == i);
01045
_dbus_assert (_DBUS_POINTER_TO_INT (data2) == i);
01046
01047 verify_list (&list1);
01048 verify_list (&list2);
01049
01050
_dbus_assert (is_ascending_sequence (&list1));
01051
_dbus_assert (is_descending_sequence (&list2));
01052
01053 --i;
01054 }
01055
01056
_dbus_assert (list1 == NULL);
01057
_dbus_assert (list2 == NULL);
01058
01059
01060
01061 i = 0;
01062
while (i < 10)
01063 {
01064
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
01065
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
01066 ++i;
01067 }
01068
01069 --i;
01070
while (i >= 0)
01071 {
01072
DBusList *got_link1;
01073
DBusList *got_link2;
01074
01075
DBusList *link1;
01076
DBusList *link2;
01077
01078
void *data1;
01079
void *data2;
01080
01081 got_link1 =
_dbus_list_get_last_link (&list1);
01082 got_link2 =
_dbus_list_get_first_link (&list2);
01083
01084 link1 =
_dbus_list_pop_last_link (&list1);
01085 link2 =
_dbus_list_pop_first_link (&list2);
01086
01087
_dbus_assert (got_link1 == link1);
01088
_dbus_assert (got_link2 == link2);
01089
01090 data1 = link1->
data;
01091 data2 = link2->
data;
01092
01093
_dbus_list_free_link (link1);
01094
_dbus_list_free_link (link2);
01095
01096
_dbus_assert (_DBUS_POINTER_TO_INT (data1) == i);
01097
_dbus_assert (_DBUS_POINTER_TO_INT (data2) == i);
01098
01099 verify_list (&list1);
01100 verify_list (&list2);
01101
01102
_dbus_assert (is_ascending_sequence (&list1));
01103
_dbus_assert (is_descending_sequence (&list2));
01104
01105 --i;
01106 }
01107
01108
_dbus_assert (list1 == NULL);
01109
_dbus_assert (list2 == NULL);
01110
01111
01112
01113 i = 0;
01114
while (i < 10)
01115 {
01116
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
01117
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
01118 ++i;
01119
01120 verify_list (&list1);
01121 verify_list (&list2);
01122
01123
_dbus_assert (_dbus_list_get_length (&list1) == i);
01124
_dbus_assert (_dbus_list_get_length (&list2) == i);
01125 }
01126
01127
_dbus_assert (is_ascending_sequence (&list1));
01128
_dbus_assert (is_descending_sequence (&list2));
01129
01130 --i;
01131 link2 =
_dbus_list_get_first_link (&list2);
01132
while (link2 !=
NULL)
01133 {
01134 verify_list (&link2);
01135
01136
_dbus_assert (_DBUS_POINTER_TO_INT (link2->
data) == i);
01137
01138 link2 =
_dbus_list_get_next_link (&list2, link2);
01139 --i;
01140 }
01141
01142 i = 0;
01143 link1 =
_dbus_list_get_first_link (&list1);
01144
while (link1 !=
NULL)
01145 {
01146 verify_list (&link1);
01147
01148
_dbus_assert (_DBUS_POINTER_TO_INT (link1->
data) == i);
01149
01150 link1 =
_dbus_list_get_next_link (&list1, link1);
01151 ++i;
01152 }
01153
01154 --i;
01155 link1 =
_dbus_list_get_last_link (&list1);
01156
while (link1 !=
NULL)
01157 {
01158 verify_list (&link1);
01159
01160
_dbus_assert (_DBUS_POINTER_TO_INT (link1->
data) == i);
01161
01162 link1 =
_dbus_list_get_prev_link (&list1, link1);
01163 --i;
01164 }
01165
01166
_dbus_list_clear (&list1);
01167
_dbus_list_clear (&list2);
01168
01169
01170
01171 i = 0;
01172
while (i < 10)
01173 {
01174
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
01175
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
01176 ++i;
01177 }
01178
01179 --i;
01180
while (i >= 0)
01181 {
01182
if ((i % 2) == 0)
01183 {
01184
if (!
_dbus_list_remove (&list1, _DBUS_INT_TO_POINTER (i)))
01185
_dbus_assert_not_reached (
"element should have been in list");
01186
if (!
_dbus_list_remove (&list2, _DBUS_INT_TO_POINTER (i)))
01187
_dbus_assert_not_reached (
"element should have been in list");
01188
01189 verify_list (&list1);
01190 verify_list (&list2);
01191 }
01192 --i;
01193 }
01194
01195
_dbus_assert (all_odd_values (&list1));
01196
_dbus_assert (all_odd_values (&list2));
01197
01198
_dbus_list_clear (&list1);
01199
_dbus_list_clear (&list2);
01200
01201
01202
01203 i = 0;
01204
while (i < 10)
01205 {
01206
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
01207
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
01208 ++i;
01209 }
01210
01211 --i;
01212
while (i >= 0)
01213 {
01214
if ((i % 2) != 0)
01215 {
01216
if (!
_dbus_list_remove (&list1, _DBUS_INT_TO_POINTER (i)))
01217
_dbus_assert_not_reached (
"element should have been in list");
01218
if (!
_dbus_list_remove (&list2, _DBUS_INT_TO_POINTER (i)))
01219
_dbus_assert_not_reached (
"element should have been in list");
01220
01221 verify_list (&list1);
01222 verify_list (&list2);
01223 }
01224 --i;
01225 }
01226
01227
_dbus_assert (all_even_values (&list1));
01228
_dbus_assert (all_even_values (&list2));
01229
01230
01231
while (list1 !=
NULL)
01232 {
01233
_dbus_list_remove_link (&list1, list1);
01234 verify_list (&list1);
01235 }
01236
while (list2 !=
NULL)
01237 {
01238
_dbus_list_remove_link (&list2, list2);
01239 verify_list (&list2);
01240 }
01241
01242
01243 i = 0;
01244
while (i < 10)
01245 {
01246
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
01247
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
01248 ++i;
01249 }
01250
01251 --i;
01252 link2 =
_dbus_list_get_first_link (&list2);
01253
while (link2 !=
NULL)
01254 {
01255
DBusList *next =
_dbus_list_get_next_link (&list2, link2);
01256
01257
_dbus_assert (_DBUS_POINTER_TO_INT (link2->
data) == i);
01258
01259
if ((i % 2) == 0)
01260
_dbus_list_remove_link (&list2, link2);
01261
01262 verify_list (&list2);
01263
01264 link2 = next;
01265 --i;
01266 }
01267
01268
_dbus_assert (all_odd_values (&list2));
01269
_dbus_list_clear (&list2);
01270
01271 i = 0;
01272 link1 =
_dbus_list_get_first_link (&list1);
01273
while (link1 !=
NULL)
01274 {
01275
DBusList *next =
_dbus_list_get_next_link (&list1, link1);
01276
01277
_dbus_assert (_DBUS_POINTER_TO_INT (link1->
data) == i);
01278
01279
if ((i % 2) != 0)
01280
_dbus_list_remove_link (&list1, link1);
01281
01282 verify_list (&list1);
01283
01284 link1 = next;
01285 ++i;
01286 }
01287
01288
_dbus_assert (all_even_values (&list1));
01289
_dbus_list_clear (&list1);
01290
01291
01292 i = 0;
01293
while (i < 10)
01294 {
01295
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
01296
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
01297 ++i;
01298 }
01299
01300
01301 copy1 =
_DBUS_INT_TO_POINTER (0x342234);
01302 copy2 =
_DBUS_INT_TO_POINTER (23);
01303
01304
_dbus_list_copy (&list1, ©1);
01305 verify_list (&list1);
01306 verify_list (©1);
01307
_dbus_assert (lists_equal (&list1, ©1));
01308
01309
_dbus_list_copy (&list2, ©2);
01310 verify_list (&list2);
01311 verify_list (©2);
01312
_dbus_assert (lists_equal (&list2, ©2));
01313
01314
01315
_dbus_list_clear (&list1);
01316
_dbus_list_clear (&list2);
01317
_dbus_list_clear (©1);
01318
_dbus_list_clear (©2);
01319
01320
01321 copy1 =
_DBUS_INT_TO_POINTER (0x342234);
01322 copy2 =
_DBUS_INT_TO_POINTER (23);
01323
01324
_dbus_list_copy (&list1, ©1);
01325 verify_list (&list1);
01326 verify_list (©1);
01327
_dbus_assert (lists_equal (&list1, ©1));
01328
01329
_dbus_list_copy (&list2, ©2);
01330 verify_list (&list2);
01331 verify_list (©2);
01332
_dbus_assert (lists_equal (&list2, ©2));
01333
01334
_dbus_list_clear (&list1);
01335
_dbus_list_clear (&list2);
01336
01337
01338
_dbus_list_insert_before (&list1, NULL,
01339 _DBUS_INT_TO_POINTER (0));
01340 verify_list (&list1);
01341
01342
01343
_dbus_list_insert_before (&list1, list1,
01344 _DBUS_INT_TO_POINTER (2));
01345 verify_list (&list1);
01346
_dbus_assert (is_descending_sequence (&list1));
01347
01348
01349
_dbus_list_insert_before (&list1, list1->
next,
01350
_DBUS_INT_TO_POINTER (1));
01351 verify_list (&list1);
01352
_dbus_assert (is_descending_sequence (&list1));
01353
01354
01355
_dbus_list_insert_before (&list1, NULL,
01356 _DBUS_INT_TO_POINTER (-1));
01357 verify_list (&list1);
01358
_dbus_assert (is_descending_sequence (&list1));
01359
01360
_dbus_list_clear (&list1);
01361
01362
01363
_dbus_list_insert_after (&list1, NULL,
01364 _DBUS_INT_TO_POINTER (0));
01365 verify_list (&list1);
01366
01367
01368
_dbus_list_insert_after (&list1, list1,
01369 _DBUS_INT_TO_POINTER (1));
01370 verify_list (&list1);
01371
_dbus_assert (is_ascending_sequence (&list1));
01372
01373
01374
_dbus_list_insert_after (&list1, list1->
next,
01375
_DBUS_INT_TO_POINTER (2));
01376 verify_list (&list1);
01377
_dbus_assert (is_ascending_sequence (&list1));
01378
01379
01380
_dbus_list_insert_after (&list1, NULL,
01381 _DBUS_INT_TO_POINTER (-1));
01382 verify_list (&list1);
01383
_dbus_assert (is_ascending_sequence (&list1));
01384
01385
_dbus_list_clear (&list1);
01386
01387
01388
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (2));
01389
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (1));
01390
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (3));
01391
01392
_dbus_list_remove_last (&list1, _DBUS_INT_TO_POINTER (2));
01393
01394 verify_list (&list1);
01395
_dbus_assert (is_ascending_sequence (&list1));
01396
01397
_dbus_list_clear (&list1);
01398
01399
return TRUE;
01400 }
01401
01402
#endif