test: Move _dbus_list_test() here

Signed-off-by: Simon McVittie <smcv@collabora.com>

diff --git a/dbus/dbus-list.c b/dbus/dbus-list.c
index 1bf1e7a9774b237698e2529d6a7fabf6242c1ca4..d3ca20f7dfa319547f7e1244c3586411e0553ea3 100644 (file)
--- a/dbus/dbus-list.c
+++ b/dbus/dbus-list.c
@@ -815,579 +815,3 @@ _dbus_list_length_is_one (DBusList **list)
 }
 
 /** @} */
-
-#ifdef DBUS_ENABLE_EMBEDDED_TESTS
-#include "dbus-test.h"
-#include <stdio.h>
-
-static void
-verify_list (DBusList **list)
-{
-  DBusList *link;
-  int length;
-  
-  link = *list;
-
-  if (link == NULL)
-    return;
-
-  if (link->next == link)
-    {
-      _dbus_assert (link->prev == link);
-      _dbus_assert (*list == link);
-      return;
-    }
-
-  length = 0;
-  do
-    {
-      length += 1;
-      _dbus_assert (link->prev->next == link);
-      _dbus_assert (link->next->prev == link);
-      link = link->next;
-    }
-  while (link != *list);
-
-  _dbus_assert (length == _dbus_list_get_length (list));
-
-  if (length == 1)
-    _dbus_assert (_dbus_list_length_is_one (list));
-  else
-    _dbus_assert (!_dbus_list_length_is_one (list));
-}
-
-static dbus_bool_t
-is_ascending_sequence (DBusList **list)
-{
-  DBusList *link;
-  int prev;
-
-  prev = _DBUS_INT_MIN;
-  
-  link = _dbus_list_get_first_link (list);
-  while (link != NULL)
-    {
-      int v = _DBUS_POINTER_TO_INT (link->data);
-      
-      if (v <= prev)
-        return FALSE;
-
-      prev = v;
-      
-      link = _dbus_list_get_next_link (list, link);
-    }
-
-  return TRUE;
-}
-
-static dbus_bool_t
-is_descending_sequence (DBusList **list)
-{
-  DBusList *link;
-  int prev;
-
-  prev = _DBUS_INT_MAX;
-  
-  link = _dbus_list_get_first_link (list);
-  while (link != NULL)
-    {
-      int v = _DBUS_POINTER_TO_INT (link->data);
-
-      if (v >= prev)
-        return FALSE;
-
-      prev = v;
-      
-      link = _dbus_list_get_next_link (list, link);
-    }
-
-  return TRUE;
-}
-
-static dbus_bool_t
-all_even_values (DBusList **list)
-{
-  DBusList *link;
-  
-  link = _dbus_list_get_first_link (list);
-  while (link != NULL)
-    {
-      int v = _DBUS_POINTER_TO_INT (link->data);
-
-      if ((v % 2) != 0)
-        return FALSE;
-      
-      link = _dbus_list_get_next_link (list, link);
-    }
-
-  return TRUE;
-}
-
-static dbus_bool_t
-all_odd_values (DBusList **list)
-{
-  DBusList *link;
-  
-  link = _dbus_list_get_first_link (list);
-  while (link != NULL)
-    {
-      int v = _DBUS_POINTER_TO_INT (link->data);
-
-      if ((v % 2) == 0)
-        return FALSE;
-      
-      link = _dbus_list_get_next_link (list, link);
-    }
-
-  return TRUE;
-}
-
-static dbus_bool_t
-lists_equal (DBusList **list1,
-             DBusList **list2)
-{
-  DBusList *link1;
-  DBusList *link2;
-  
-  link1 = _dbus_list_get_first_link (list1);
-  link2 = _dbus_list_get_first_link (list2);
-  while (link1 && link2)
-    {
-      if (link1->data != link2->data)
-        return FALSE;
-      
-      link1 = _dbus_list_get_next_link (list1, link1);
-      link2 = _dbus_list_get_next_link (list2, link2);
-    }
-
-  if (link1 || link2)
-    return FALSE;
-
-  return TRUE;
-}
-
-/**
- * @ingroup DBusListInternals
- * Unit test for DBusList
- * @returns #TRUE on success.
- */
-dbus_bool_t
-_dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
-{
-  DBusList *list1;
-  DBusList *list2;
-  DBusList *link1;
-  DBusList *link2;
-  DBusList *copy1;
-  DBusList *copy2;
-  int i;
-  
-  list1 = NULL;
-  list2 = NULL;
-
-  /* Test append and prepend */
-  
-  i = 0;
-  while (i < 10)
-    {
-      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for append");
-
-      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("count not allocate for prepend");
-      ++i;
-
-      verify_list (&list1);
-      verify_list (&list2);
-      
-      _dbus_assert (_dbus_list_get_length (&list1) == i);
-      _dbus_assert (_dbus_list_get_length (&list2) == i);
-    }
-
-  _dbus_assert (is_ascending_sequence (&list1));
-  _dbus_assert (is_descending_sequence (&list2));
-
-  /* Test list clear */
-  _dbus_list_clear (&list1);
-  _dbus_list_clear (&list2);
-
-  verify_list (&list1);
-  verify_list (&list2);
-
-  /* Test get_first, get_last, pop_first, pop_last */
-  
-  i = 0;
-  while (i < 10)
-    {
-      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for append");
-      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for prepend");
-      ++i;
-    }
-
-  --i;
-  while (i >= 0)
-    {
-      void *got_data1;
-      void *got_data2;
-      
-      void *data1;
-      void *data2;
-
-      got_data1 = _dbus_list_get_last (&list1);
-      got_data2 = _dbus_list_get_first (&list2);
-      
-      data1 = _dbus_list_pop_last (&list1);
-      data2 = _dbus_list_pop_first (&list2);
-
-      _dbus_assert (got_data1 == data1);
-      _dbus_assert (got_data2 == data2);
-      
-      _dbus_assert (_DBUS_POINTER_TO_INT (data1) == i);
-      _dbus_assert (_DBUS_POINTER_TO_INT (data2) == i);
-
-      verify_list (&list1);
-      verify_list (&list2);
-
-      _dbus_assert (is_ascending_sequence (&list1));
-      _dbus_assert (is_descending_sequence (&list2));
-      
-      --i;
-    }
-
-  _dbus_assert (list1 == NULL);
-  _dbus_assert (list2 == NULL);
-
-  /* Test get_first_link, get_last_link, pop_first_link, pop_last_link */
-  
-  i = 0;
-  while (i < 10)
-    {
-      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for append");
-      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for prepend");
-      ++i;
-    }
-
-  --i;
-  while (i >= 0)
-    {
-      DBusList *got_link1;
-      DBusList *got_link2;
-      
-      void *data1_indirect;
-      void *data1;
-      void *data2;
-      
-      got_link1 = _dbus_list_get_last_link (&list1);
-      got_link2 = _dbus_list_get_first_link (&list2);
-
-      link2 = _dbus_list_pop_first_link (&list2);
-
-      _dbus_assert (got_link2 == link2);
-
-      data1_indirect = got_link1->data;
-      /* this call makes got_link1 invalid */
-      data1 = _dbus_list_pop_last (&list1);
-      _dbus_assert (data1 == data1_indirect);
-      data2 = link2->data;
-
-      _dbus_list_free_link (link2);
-      
-      _dbus_assert (_DBUS_POINTER_TO_INT (data1) == i);
-      _dbus_assert (_DBUS_POINTER_TO_INT (data2) == i);
-
-      verify_list (&list1);
-      verify_list (&list2);
-
-      _dbus_assert (is_ascending_sequence (&list1));
-      _dbus_assert (is_descending_sequence (&list2));
-      
-      --i;
-    }
-
-  _dbus_assert (list1 == NULL);
-  _dbus_assert (list2 == NULL);
-  
-  /* Test iteration */
-
-  i = 0;
-  while (i < 10)
-    {
-      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for append");
-      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for prepend");
-      ++i;
-
-      verify_list (&list1);
-      verify_list (&list2);
-      
-      _dbus_assert (_dbus_list_get_length (&list1) == i);
-      _dbus_assert (_dbus_list_get_length (&list2) == i);
-    }
-
-  _dbus_assert (is_ascending_sequence (&list1));
-  _dbus_assert (is_descending_sequence (&list2));
-
-  --i;
-  link2 = _dbus_list_get_first_link (&list2);
-  while (link2 != NULL)
-    {
-      verify_list (&link2); /* pretend this link is the head */
-      
-      _dbus_assert (_DBUS_POINTER_TO_INT (link2->data) == i);
-      
-      link2 = _dbus_list_get_next_link (&list2, link2);
-      --i;
-    }
-
-  i = 0;
-  link1 = _dbus_list_get_first_link (&list1);
-  while (link1 != NULL)
-    {
-      verify_list (&link1); /* pretend this link is the head */
-      
-      _dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
-      
-      link1 = _dbus_list_get_next_link (&list1, link1);
-      ++i;
-    }
-
-  --i;
-  link1 = _dbus_list_get_last_link (&list1);
-  while (link1 != NULL)
-    {
-      verify_list (&link1); /* pretend this link is the head */
-
-      _dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
-      
-      link1 = _dbus_list_get_prev_link (&list1, link1);
-      --i;
-    }
-
-  _dbus_list_clear (&list1);
-  _dbus_list_clear (&list2);
-
-  /* Test remove */
-  
-  i = 0;
-  while (i < 10)
-    {
-      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for append");
-      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for prepend");
-      ++i;
-    }
-
-  --i;
-  while (i >= 0)
-    {
-      if ((i % 2) == 0)
-        {
-          if (!_dbus_list_remove (&list1, _DBUS_INT_TO_POINTER (i)))
-            _dbus_test_fatal ("element should have been in list");
-          if (!_dbus_list_remove (&list2, _DBUS_INT_TO_POINTER (i)))
-            _dbus_test_fatal ("element should have been in list");
-
-          verify_list (&list1);
-          verify_list (&list2);
-        }
-      --i;
-    }
-
-  _dbus_assert (all_odd_values (&list1));
-  _dbus_assert (all_odd_values (&list2));
-
-  _dbus_list_clear (&list1);
-  _dbus_list_clear (&list2);
-
-  /* test removing the other half of the elements */
-  
-  i = 0;
-  while (i < 10)
-    {
-      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for append");
-      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for prepend");
-      ++i;
-    }
-
-  --i;
-  while (i >= 0)
-    {
-      if ((i % 2) != 0)
-        {
-          if (!_dbus_list_remove (&list1, _DBUS_INT_TO_POINTER (i)))
-            _dbus_test_fatal ("element should have been in list");
-          if (!_dbus_list_remove (&list2, _DBUS_INT_TO_POINTER (i)))
-            _dbus_test_fatal ("element should have been in list");
-
-          verify_list (&list1);
-          verify_list (&list2);
-        }
-      --i;
-    }
-
-  _dbus_assert (all_even_values (&list1));
-  _dbus_assert (all_even_values (&list2));
-
-  /* clear list using remove_link */
-  while (list1 != NULL)
-    {
-      _dbus_list_remove_link (&list1, list1);
-      verify_list (&list1);
-    }
-  while (list2 != NULL)
-    {
-      _dbus_list_remove_link (&list2, list2);
-      verify_list (&list2);
-    }
-
-  /* Test remove link more generally */
-  i = 0;
-  while (i < 10)
-    {
-      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for append");
-      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for prepend");
-      ++i;
-    }
-
-  --i;
-  link2 = _dbus_list_get_first_link (&list2);
-  while (link2 != NULL)
-    {
-      DBusList *next = _dbus_list_get_next_link (&list2, link2);
-      
-      _dbus_assert (_DBUS_POINTER_TO_INT (link2->data) == i);
-
-      if ((i % 2) == 0)
-        _dbus_list_remove_link (&list2, link2);
-
-      verify_list (&list2);
-      
-      link2 = next;
-      --i;
-    }
-
-  _dbus_assert (all_odd_values (&list2));  
-  _dbus_list_clear (&list2);
-  
-  i = 0;
-  link1 = _dbus_list_get_first_link (&list1);
-  while (link1 != NULL)
-    {
-      DBusList *next = _dbus_list_get_next_link (&list1, link1);
-
-      _dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
-
-      if ((i % 2) != 0)
-        _dbus_list_remove_link (&list1, link1);
-
-      verify_list (&list1);
-      
-      link1 = next;
-      ++i;
-    }
-
-  _dbus_assert (all_even_values (&list1));
-  _dbus_list_clear (&list1);
-
-  /* Test copying a list */
-  i = 0;
-  while (i < 10)
-    {
-      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for append");
-      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
-        _dbus_test_fatal ("could not allocate for prepend");
-      ++i;
-    }
-
-  /* bad pointers, because they are allowed in the copy dest */
-  copy1 = _DBUS_INT_TO_POINTER (0x342234);
-  copy2 = _DBUS_INT_TO_POINTER (23);
-  
-  _dbus_list_copy (&list1, &copy1);
-  verify_list (&list1);
-  verify_list (&copy1);
-  _dbus_assert (lists_equal (&list1, &copy1));
-  
-  _dbus_list_copy (&list2, &copy2);
-  verify_list (&list2);
-  verify_list (&copy2);
-  _dbus_assert (lists_equal (&list2, &copy2));
-
-  /* Now test copying empty lists */
-  _dbus_list_clear (&list1);
-  _dbus_list_clear (&list2);
-  _dbus_list_clear (&copy1);
-  _dbus_list_clear (&copy2);
-  
-  /* bad pointers, because they are allowed in the copy dest */
-  copy1 = _DBUS_INT_TO_POINTER (0x342234);
-  copy2 = _DBUS_INT_TO_POINTER (23);
-  
-  _dbus_list_copy (&list1, &copy1);
-  verify_list (&list1);
-  verify_list (&copy1);
-  _dbus_assert (lists_equal (&list1, &copy1));
-  
-  _dbus_list_copy (&list2, &copy2);
-  verify_list (&list2);
-  verify_list (&copy2);
-  _dbus_assert (lists_equal (&list2, &copy2));
-
-  _dbus_list_clear (&list1);
-  _dbus_list_clear (&list2);
-
-  /* insert_after on empty list */
-  _dbus_list_insert_after (&list1, NULL,
-                           _DBUS_INT_TO_POINTER (0));
-  verify_list (&list1);
-
-  /* inserting after first element */
-  _dbus_list_insert_after (&list1, list1,
-                           _DBUS_INT_TO_POINTER (1));
-  verify_list (&list1);
-  _dbus_assert (is_ascending_sequence (&list1));
-
-  /* inserting at the end */
-  _dbus_list_insert_after (&list1, list1->next,
-                           _DBUS_INT_TO_POINTER (2));
-  verify_list (&list1);
-  _dbus_assert (is_ascending_sequence (&list1));
-
-  /* using insert_after to prepend */
-  _dbus_list_insert_after (&list1, NULL,
-                           _DBUS_INT_TO_POINTER (-1));
-  verify_list (&list1);
-  _dbus_assert (is_ascending_sequence (&list1));
-  
-  _dbus_list_clear (&list1);
-
-  /* using remove_last */
-  if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (2)))
-    _dbus_test_fatal ("could not allocate for append");
-  if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (1)))
-    _dbus_test_fatal ("could not allocate for append");
-  if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (3)))
-    _dbus_test_fatal ("could not allocate for append");
-
-  _dbus_list_remove_last (&list1, _DBUS_INT_TO_POINTER (2));
-  
-  verify_list (&list1);
-  _dbus_assert (is_ascending_sequence (&list1));
-  
-  _dbus_list_clear (&list1);
-  
-  return TRUE;
-}
-
-#endif

diff --git a/dbus/dbus-test.h b/dbus/dbus-test.h
index c20bf05fcaeb910fa2ffb509ff05aab4496278ec..197e0dc7aa7826cf5450200d8823517b75897ee4 100644 (file)
--- a/dbus/dbus-test.h
+++ b/dbus/dbus-test.h
@@ -37,9 +37,6 @@
  * then you have added too many.
  */
 
-DBUS_PRIVATE_EXPORT
-dbus_bool_t _dbus_list_test              (const char *test_data_dir);
-
 DBUS_PRIVATE_EXPORT
 dbus_bool_t _dbus_marshal_test           (const char *test_data_dir);
 

diff --git a/test/internals/misc-internals.c b/test/internals/misc-internals.c
index 138cd353693e206864d7e56ada0d392a3656f833..7661853fa24f5ca4b7341429d4eae4e4865fc53b 100644 (file)
--- a/test/internals/misc-internals.c
+++ b/test/internals/misc-internals.c
@@ -34,6 +34,576 @@
 
 #include "misc-internals.h"
 
+static void
+verify_list (DBusList **list)
+{
+  DBusList *link;
+  int length;
+
+  link = *list;
+
+  if (link == NULL)
+    return;
+
+  if (link->next == link)
+    {
+      _dbus_assert (link->prev == link);
+      _dbus_assert (*list == link);
+      return;
+    }
+
+  length = 0;
+  do
+    {
+      length += 1;
+      _dbus_assert (link->prev->next == link);
+      _dbus_assert (link->next->prev == link);
+      link = link->next;
+    }
+  while (link != *list);
+
+  _dbus_assert (length == _dbus_list_get_length (list));
+
+  if (length == 1)
+    _dbus_assert (_dbus_list_length_is_one (list));
+  else
+    _dbus_assert (!_dbus_list_length_is_one (list));
+}
+
+static dbus_bool_t
+is_ascending_sequence (DBusList **list)
+{
+  DBusList *link;
+  int prev;
+
+  prev = _DBUS_INT_MIN;
+
+  link = _dbus_list_get_first_link (list);
+  while (link != NULL)
+    {
+      int v = _DBUS_POINTER_TO_INT (link->data);
+
+      if (v <= prev)
+        return FALSE;
+
+      prev = v;
+
+      link = _dbus_list_get_next_link (list, link);
+    }
+
+  return TRUE;
+}
+
+static dbus_bool_t
+is_descending_sequence (DBusList **list)
+{
+  DBusList *link;
+  int prev;
+
+  prev = _DBUS_INT_MAX;
+
+  link = _dbus_list_get_first_link (list);
+  while (link != NULL)
+    {
+      int v = _DBUS_POINTER_TO_INT (link->data);
+
+      if (v >= prev)
+        return FALSE;
+
+      prev = v;
+
+      link = _dbus_list_get_next_link (list, link);
+    }
+
+  return TRUE;
+}
+
+static dbus_bool_t
+all_even_values (DBusList **list)
+{
+  DBusList *link;
+
+  link = _dbus_list_get_first_link (list);
+  while (link != NULL)
+    {
+      int v = _DBUS_POINTER_TO_INT (link->data);
+
+      if ((v % 2) != 0)
+        return FALSE;
+
+      link = _dbus_list_get_next_link (list, link);
+    }
+
+  return TRUE;
+}
+
+static dbus_bool_t
+all_odd_values (DBusList **list)
+{
+  DBusList *link;
+
+  link = _dbus_list_get_first_link (list);
+  while (link != NULL)
+    {
+      int v = _DBUS_POINTER_TO_INT (link->data);
+
+      if ((v % 2) == 0)
+        return FALSE;
+
+      link = _dbus_list_get_next_link (list, link);
+    }
+
+  return TRUE;
+}
+
+static dbus_bool_t
+lists_equal (DBusList **list1,
+             DBusList **list2)
+{
+  DBusList *link1;
+  DBusList *link2;
+
+  link1 = _dbus_list_get_first_link (list1);
+  link2 = _dbus_list_get_first_link (list2);
+  while (link1 && link2)
+    {
+      if (link1->data != link2->data)
+        return FALSE;
+
+      link1 = _dbus_list_get_next_link (list1, link1);
+      link2 = _dbus_list_get_next_link (list2, link2);
+    }
+
+  if (link1 || link2)
+    return FALSE;
+
+  return TRUE;
+}
+
+/**
+ * @ingroup DBusListInternals
+ * Unit test for DBusList
+ * @returns #TRUE on success.
+ */
+static dbus_bool_t
+_dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
+{
+  DBusList *list1;
+  DBusList *list2;
+  DBusList *link1;
+  DBusList *link2;
+  DBusList *copy1;
+  DBusList *copy2;
+  int i;
+
+  list1 = NULL;
+  list2 = NULL;
+
+  /* Test append and prepend */
+
+  i = 0;
+  while (i < 10)
+    {
+      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for append");
+
+      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("count not allocate for prepend");
+      ++i;
+
+      verify_list (&list1);
+      verify_list (&list2);
+
+      _dbus_assert (_dbus_list_get_length (&list1) == i);
+      _dbus_assert (_dbus_list_get_length (&list2) == i);
+    }
+
+  _dbus_assert (is_ascending_sequence (&list1));
+  _dbus_assert (is_descending_sequence (&list2));
+
+  /* Test list clear */
+  _dbus_list_clear (&list1);
+  _dbus_list_clear (&list2);
+
+  verify_list (&list1);
+  verify_list (&list2);
+
+  /* Test get_first, get_last, pop_first, pop_last */
+
+  i = 0;
+  while (i < 10)
+    {
+      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for append");
+      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for prepend");
+      ++i;
+    }
+
+  --i;
+  while (i >= 0)
+    {
+      void *got_data1;
+      void *got_data2;
+
+      void *data1;
+      void *data2;
+
+      got_data1 = _dbus_list_get_last (&list1);
+      got_data2 = _dbus_list_get_first (&list2);
+
+      data1 = _dbus_list_pop_last (&list1);
+      data2 = _dbus_list_pop_first (&list2);
+
+      _dbus_assert (got_data1 == data1);
+      _dbus_assert (got_data2 == data2);
+
+      _dbus_assert (_DBUS_POINTER_TO_INT (data1) == i);
+      _dbus_assert (_DBUS_POINTER_TO_INT (data2) == i);
+
+      verify_list (&list1);
+      verify_list (&list2);
+
+      _dbus_assert (is_ascending_sequence (&list1));
+      _dbus_assert (is_descending_sequence (&list2));
+
+      --i;
+    }
+
+  _dbus_assert (list1 == NULL);
+  _dbus_assert (list2 == NULL);
+
+  /* Test get_first_link, get_last_link, pop_first_link, pop_last_link */
+
+  i = 0;
+  while (i < 10)
+    {
+      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for append");
+      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for prepend");
+      ++i;
+    }
+
+  --i;
+  while (i >= 0)
+    {
+      DBusList *got_link1;
+      DBusList *got_link2;
+
+      void *data1_indirect;
+      void *data1;
+      void *data2;
+
+      got_link1 = _dbus_list_get_last_link (&list1);
+      got_link2 = _dbus_list_get_first_link (&list2);
+
+      link2 = _dbus_list_pop_first_link (&list2);
+
+      _dbus_assert (got_link2 == link2);
+
+      data1_indirect = got_link1->data;
+      /* this call makes got_link1 invalid */
+      data1 = _dbus_list_pop_last (&list1);
+      _dbus_assert (data1 == data1_indirect);
+      data2 = link2->data;
+
+      _dbus_list_free_link (link2);
+
+      _dbus_assert (_DBUS_POINTER_TO_INT (data1) == i);
+      _dbus_assert (_DBUS_POINTER_TO_INT (data2) == i);
+
+      verify_list (&list1);
+      verify_list (&list2);
+
+      _dbus_assert (is_ascending_sequence (&list1));
+      _dbus_assert (is_descending_sequence (&list2));
+
+      --i;
+    }
+
+  _dbus_assert (list1 == NULL);
+  _dbus_assert (list2 == NULL);
+
+  /* Test iteration */
+
+  i = 0;
+  while (i < 10)
+    {
+      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for append");
+      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for prepend");
+      ++i;
+
+      verify_list (&list1);
+      verify_list (&list2);
+
+      _dbus_assert (_dbus_list_get_length (&list1) == i);
+      _dbus_assert (_dbus_list_get_length (&list2) == i);
+    }
+
+  _dbus_assert (is_ascending_sequence (&list1));
+  _dbus_assert (is_descending_sequence (&list2));
+
+  --i;
+  link2 = _dbus_list_get_first_link (&list2);
+  while (link2 != NULL)
+    {
+      verify_list (&link2); /* pretend this link is the head */
+
+      _dbus_assert (_DBUS_POINTER_TO_INT (link2->data) == i);
+
+      link2 = _dbus_list_get_next_link (&list2, link2);
+      --i;
+    }
+
+  i = 0;
+  link1 = _dbus_list_get_first_link (&list1);
+  while (link1 != NULL)
+    {
+      verify_list (&link1); /* pretend this link is the head */
+
+      _dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
+
+      link1 = _dbus_list_get_next_link (&list1, link1);
+      ++i;
+    }
+
+  --i;
+  link1 = _dbus_list_get_last_link (&list1);
+  while (link1 != NULL)
+    {
+      verify_list (&link1); /* pretend this link is the head */
+
+      _dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
+
+      link1 = _dbus_list_get_prev_link (&list1, link1);
+      --i;
+    }
+
+  _dbus_list_clear (&list1);
+  _dbus_list_clear (&list2);
+
+  /* Test remove */
+
+  i = 0;
+  while (i < 10)
+    {
+      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for append");
+      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for prepend");
+      ++i;
+    }
+
+  --i;
+  while (i >= 0)
+    {
+      if ((i % 2) == 0)
+        {
+          if (!_dbus_list_remove (&list1, _DBUS_INT_TO_POINTER (i)))
+            _dbus_test_fatal ("element should have been in list");
+          if (!_dbus_list_remove (&list2, _DBUS_INT_TO_POINTER (i)))
+            _dbus_test_fatal ("element should have been in list");
+
+          verify_list (&list1);
+          verify_list (&list2);
+        }
+      --i;
+    }
+
+  _dbus_assert (all_odd_values (&list1));
+  _dbus_assert (all_odd_values (&list2));
+
+  _dbus_list_clear (&list1);
+  _dbus_list_clear (&list2);
+
+  /* test removing the other half of the elements */
+
+  i = 0;
+  while (i < 10)
+    {
+      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for append");
+      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for prepend");
+      ++i;
+    }
+
+  --i;
+  while (i >= 0)
+    {
+      if ((i % 2) != 0)
+        {
+          if (!_dbus_list_remove (&list1, _DBUS_INT_TO_POINTER (i)))
+            _dbus_test_fatal ("element should have been in list");
+          if (!_dbus_list_remove (&list2, _DBUS_INT_TO_POINTER (i)))
+            _dbus_test_fatal ("element should have been in list");
+
+          verify_list (&list1);
+          verify_list (&list2);
+        }
+      --i;
+    }
+
+  _dbus_assert (all_even_values (&list1));
+  _dbus_assert (all_even_values (&list2));
+
+  /* clear list using remove_link */
+  while (list1 != NULL)
+    {
+      _dbus_list_remove_link (&list1, list1);
+      verify_list (&list1);
+    }
+  while (list2 != NULL)
+    {
+      _dbus_list_remove_link (&list2, list2);
+      verify_list (&list2);
+    }
+
+  /* Test remove link more generally */
+  i = 0;
+  while (i < 10)
+    {
+      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for append");
+      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for prepend");
+      ++i;
+    }
+
+  --i;
+  link2 = _dbus_list_get_first_link (&list2);
+  while (link2 != NULL)
+    {
+      DBusList *next = _dbus_list_get_next_link (&list2, link2);
+
+      _dbus_assert (_DBUS_POINTER_TO_INT (link2->data) == i);
+
+      if ((i % 2) == 0)
+        _dbus_list_remove_link (&list2, link2);
+
+      verify_list (&list2);
+
+      link2 = next;
+      --i;
+    }
+
+  _dbus_assert (all_odd_values (&list2));
+  _dbus_list_clear (&list2);
+
+  i = 0;
+  link1 = _dbus_list_get_first_link (&list1);
+  while (link1 != NULL)
+    {
+      DBusList *next = _dbus_list_get_next_link (&list1, link1);
+
+      _dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
+
+      if ((i % 2) != 0)
+        _dbus_list_remove_link (&list1, link1);
+
+      verify_list (&list1);
+
+      link1 = next;
+      ++i;
+    }
+
+  _dbus_assert (all_even_values (&list1));
+  _dbus_list_clear (&list1);
+
+  /* Test copying a list */
+  i = 0;
+  while (i < 10)
+    {
+      if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for append");
+      if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
+        _dbus_test_fatal ("could not allocate for prepend");
+      ++i;
+    }
+
+  /* bad pointers, because they are allowed in the copy dest */
+  copy1 = _DBUS_INT_TO_POINTER (0x342234);
+  copy2 = _DBUS_INT_TO_POINTER (23);
+
+  _dbus_list_copy (&list1, &copy1);
+  verify_list (&list1);
+  verify_list (&copy1);
+  _dbus_assert (lists_equal (&list1, &copy1));
+
+  _dbus_list_copy (&list2, &copy2);
+  verify_list (&list2);
+  verify_list (&copy2);
+  _dbus_assert (lists_equal (&list2, &copy2));
+
+  /* Now test copying empty lists */
+  _dbus_list_clear (&list1);
+  _dbus_list_clear (&list2);
+  _dbus_list_clear (&copy1);
+  _dbus_list_clear (&copy2);
+
+  /* bad pointers, because they are allowed in the copy dest */
+  copy1 = _DBUS_INT_TO_POINTER (0x342234);
+  copy2 = _DBUS_INT_TO_POINTER (23);
+
+  _dbus_list_copy (&list1, &copy1);
+  verify_list (&list1);
+  verify_list (&copy1);
+  _dbus_assert (lists_equal (&list1, &copy1));
+
+  _dbus_list_copy (&list2, &copy2);
+  verify_list (&list2);
+  verify_list (&copy2);
+  _dbus_assert (lists_equal (&list2, &copy2));
+
+  _dbus_list_clear (&list1);
+  _dbus_list_clear (&list2);
+
+  /* insert_after on empty list */
+  _dbus_list_insert_after (&list1, NULL,
+                           _DBUS_INT_TO_POINTER (0));
+  verify_list (&list1);
+
+  /* inserting after first element */
+  _dbus_list_insert_after (&list1, list1,
+                           _DBUS_INT_TO_POINTER (1));
+  verify_list (&list1);
+  _dbus_assert (is_ascending_sequence (&list1));
+
+  /* inserting at the end */
+  _dbus_list_insert_after (&list1, list1->next,
+                           _DBUS_INT_TO_POINTER (2));
+  verify_list (&list1);
+  _dbus_assert (is_ascending_sequence (&list1));
+
+  /* using insert_after to prepend */
+  _dbus_list_insert_after (&list1, NULL,
+                           _DBUS_INT_TO_POINTER (-1));
+  verify_list (&list1);
+  _dbus_assert (is_ascending_sequence (&list1));
+
+  _dbus_list_clear (&list1);
+
+  /* using remove_last */
+  if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (2)))
+    _dbus_test_fatal ("could not allocate for append");
+  if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (1)))
+    _dbus_test_fatal ("could not allocate for append");
+  if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (3)))
+    _dbus_test_fatal ("could not allocate for append");
+
+  _dbus_list_remove_last (&list1, _DBUS_INT_TO_POINTER (2));
+
+  verify_list (&list1);
+  _dbus_assert (is_ascending_sequence (&list1));
+
+  _dbus_list_clear (&list1);
+
+  return TRUE;
+}
+
 static dbus_bool_t
 _dbus_misc_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
 {