Move the APR test suite from CuTest to abts. The output is cleaner,

and it prints output while running the test.  Also, if a test fails the
rest of the test function is run, allowing for proper cleanup.  Finally,
it is possible to call the same function multiple times with different
data, and each call is considered a separate test.

This is the first of a multi-step process to get a more useful test suite.


git-svn-id: https://svn.apache.org/repos/asf/apr/apr/trunk@65091 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 136 insertions, 136 deletions

diff --git a/test/testpoll.c b/test/testpoll.c
index 440d0a030..f96268e4b 100644
--- a/test/testpoll.c
+++ b/test/testpoll.c
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-#include "test_apr.h"
+#include "testutil.h"
 #include "apr_strings.h"
 #include "apr_errno.h"
 #include "apr_general.h"
@@ -41,24 +41,24 @@ static apr_pollfd_t *pollarray_large;
 #endif
 
 static void make_socket(apr_socket_t **sock, apr_sockaddr_t **sa, 
-                        apr_port_t port, apr_pool_t *p, CuTest *tc)
+                        apr_port_t port, apr_pool_t *p, abts_case *tc)
 {
     apr_status_t rv;
 
     rv = apr_sockaddr_info_get(sa, "127.0.0.1", APR_UNSPEC, port, 0, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     rv = apr_socket_create(sock, (*sa)->family, SOCK_DGRAM, 0, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     rv =apr_socket_bind((*sock), (*sa));
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 }
 
 #ifdef OLD_POLL_INTERFACE
 static void check_sockets(const apr_pollfd_t *pollarray, 
                           apr_socket_t **sockarray, int which, int pollin, 
-                          CuTest *tc)
+                          abts_case *tc)
 {
     apr_status_t rv;
     apr_int16_t event;
@@ -66,52 +66,52 @@ static void check_sockets(const apr_pollfd_t *pollarray,
 
     rv = apr_poll_revents_get(&event, sockarray[which], 
                               (apr_pollfd_t *)pollarray);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     if (pollin) {
         str = apr_psprintf(p, "Socket %d not signalled when it should be",
                            which);
-        CuAssert(tc, str, event & APR_POLLIN);
+        abts_assert(tc, str, event & APR_POLLIN);
     } else {
         str = apr_psprintf(p, "Socket %d signalled when it should not be",
                            which);
-        CuAssert(tc, str, !(event & APR_POLLIN));
+        abts_assert(tc, str, !(event & APR_POLLIN));
     }
 }
 #endif
 
 static void send_msg(apr_socket_t **sockarray, apr_sockaddr_t **sas, int which,
-                     CuTest *tc)
+                     abts_case *tc)
 {
     apr_size_t len = 5;
     apr_status_t rv;
 
-    CuAssertPtrNotNull(tc, sockarray[which]);
+    abts_ptr_notnull(tc, sockarray[which]);
 
     rv = apr_socket_sendto(sockarray[which], sas[which], 0, "hello", &len);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, strlen("hello"), len);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, strlen("hello"), len);
 }
 
 static void recv_msg(apr_socket_t **sockarray, int which, apr_pool_t *p, 
-                     CuTest *tc)
+                     abts_case *tc)
 {
     apr_size_t buflen = 5;
     char *buffer = apr_pcalloc(p, sizeof(char) * (buflen + 1));
     apr_sockaddr_t *recsa;
     apr_status_t rv;
 
-    CuAssertPtrNotNull(tc, sockarray[which]);
+    abts_ptr_notnull(tc, sockarray[which]);
 
     apr_sockaddr_info_get(&recsa, "127.0.0.1", APR_UNSPEC, 7770, 0, p);
 
     rv = apr_socket_recvfrom(recsa, sockarray[which], 0, buffer, &buflen);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, strlen("hello"), buflen);
-    CuAssertStrEquals(tc, "hello", buffer);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, strlen("hello"), buflen);
+    abts_str_equal(tc, "hello", buffer);
 }
 
     
-static void create_all_sockets(CuTest *tc)
+static void create_all_sockets(abts_case *tc, void *data)
 {
     int i;
 
@@ -121,55 +121,55 @@ static void create_all_sockets(CuTest *tc)
 }
        
 #ifdef OLD_POLL_INTERFACE
-static void setup_small_poll(CuTest *tc)
+static void setup_small_poll(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int i;
 
     rv = apr_poll_setup(&pollarray, SMALL_NUM_SOCKETS, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     
     for (i = 0; i < SMALL_NUM_SOCKETS;i++){
-        CuAssertIntEquals(tc, 0, pollarray[i].reqevents);
-        CuAssertIntEquals(tc, 0, pollarray[i].rtnevents);
+        abts_int_equal(tc, 0, pollarray[i].reqevents);
+        abts_int_equal(tc, 0, pollarray[i].rtnevents);
 
         rv = apr_poll_socket_add(pollarray, s[i], APR_POLLIN);
-        CuAssertIntEquals(tc, APR_SUCCESS, rv);
-        CuAssertPtrEquals(tc, s[i], pollarray[i].desc.s);
+        abts_int_equal(tc, APR_SUCCESS, rv);
+        abts_ptr_equal(tc, s[i], pollarray[i].desc.s);
     }
 }
 
-static void setup_large_poll(CuTest *tc)
+static void setup_large_poll(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int i;
 
     rv = apr_poll_setup(&pollarray_large, LARGE_NUM_SOCKETS, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     
     for (i = 0; i < LARGE_NUM_SOCKETS;i++){
-        CuAssertIntEquals(tc, 0, pollarray_large[i].reqevents);
-        CuAssertIntEquals(tc, 0, pollarray_large[i].rtnevents);
+        abts_int_equal(tc, 0, pollarray_large[i].reqevents);
+        abts_int_equal(tc, 0, pollarray_large[i].rtnevents);
 
         rv = apr_poll_socket_add(pollarray_large, s[i], APR_POLLIN);
-        CuAssertIntEquals(tc, APR_SUCCESS, rv);
-        CuAssertPtrEquals(tc, s[i], pollarray_large[i].desc.s);
+        abts_int_equal(tc, APR_SUCCESS, rv);
+        abts_ptr_equal(tc, s[i], pollarray_large[i].desc.s);
     }
 }
 
-static void nomessage(CuTest *tc)
+static void nomessage(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int srv = SMALL_NUM_SOCKETS;
 
     rv = apr_poll(pollarray, SMALL_NUM_SOCKETS, &srv, 2 * APR_USEC_PER_SEC);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_TIMEUP(rv));
+    abts_int_equal(tc, 1, APR_STATUS_IS_TIMEUP(rv));
     check_sockets(pollarray, s, 0, 0, tc);
     check_sockets(pollarray, s, 1, 0, tc);
     check_sockets(pollarray, s, 2, 0, tc);
 }
 
-static void send_2(CuTest *tc)
+static void send_2(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int srv = SMALL_NUM_SOCKETS;
@@ -177,13 +177,13 @@ static void send_2(CuTest *tc)
     send_msg(s, sa, 2, tc);
 
     rv = apr_poll(pollarray, SMALL_NUM_SOCKETS, &srv, 2 * APR_USEC_PER_SEC);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     check_sockets(pollarray, s, 0, 0, tc);
     check_sockets(pollarray, s, 1, 0, tc);
     check_sockets(pollarray, s, 2, 1, tc);
 }
 
-static void recv_2_send_1(CuTest *tc)
+static void recv_2_send_1(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int srv = SMALL_NUM_SOCKETS;
@@ -192,13 +192,13 @@ static void recv_2_send_1(CuTest *tc)
     send_msg(s, sa, 1, tc);
 
     rv = apr_poll(pollarray, SMALL_NUM_SOCKETS, &srv, 2 * APR_USEC_PER_SEC);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     check_sockets(pollarray, s, 0, 0, tc);
     check_sockets(pollarray, s, 1, 1, tc);
     check_sockets(pollarray, s, 2, 0, tc);
 }
 
-static void send_2_signaled_1(CuTest *tc)
+static void send_2_signaled_1(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int srv = SMALL_NUM_SOCKETS;
@@ -206,13 +206,13 @@ static void send_2_signaled_1(CuTest *tc)
     send_msg(s, sa, 2, tc);
 
     rv = apr_poll(pollarray, SMALL_NUM_SOCKETS, &srv, 2 * APR_USEC_PER_SEC);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     check_sockets(pollarray, s, 0, 0, tc);
     check_sockets(pollarray, s, 1, 1, tc);
     check_sockets(pollarray, s, 2, 1, tc);
 }
 
-static void recv_1_send_0(CuTest *tc)
+static void recv_1_send_0(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int srv = SMALL_NUM_SOCKETS;
@@ -221,13 +221,13 @@ static void recv_1_send_0(CuTest *tc)
     send_msg(s, sa, 0, tc);
 
     rv = apr_poll(pollarray, SMALL_NUM_SOCKETS, &srv, 2 * APR_USEC_PER_SEC);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     check_sockets(pollarray, s, 0, 1, tc);
     check_sockets(pollarray, s, 1, 0, tc);
     check_sockets(pollarray, s, 2, 1, tc);
 }
 
-static void clear_all_signalled(CuTest *tc)
+static void clear_all_signalled(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int srv = SMALL_NUM_SOCKETS;
@@ -236,13 +236,13 @@ static void clear_all_signalled(CuTest *tc)
     recv_msg(s, 2, p, tc);
 
     rv = apr_poll(pollarray, SMALL_NUM_SOCKETS, &srv, 2 * APR_USEC_PER_SEC);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_TIMEUP(rv));
+    abts_int_equal(tc, 1, APR_STATUS_IS_TIMEUP(rv));
     check_sockets(pollarray, s, 0, 0, tc);
     check_sockets(pollarray, s, 1, 0, tc);
     check_sockets(pollarray, s, 2, 0, tc);
 }
 
-static void send_large_pollarray(CuTest *tc)
+static void send_large_pollarray(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int lrv = LARGE_NUM_SOCKETS;
@@ -252,7 +252,7 @@ static void send_large_pollarray(CuTest *tc)
 
     rv = apr_poll(pollarray_large, LARGE_NUM_SOCKETS, &lrv, 
                   2 * APR_USEC_PER_SEC);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     for (i = 0; i < LARGE_NUM_SOCKETS; i++) {
         if (i == (LARGE_NUM_SOCKETS - 1)) {
@@ -264,7 +264,7 @@ static void send_large_pollarray(CuTest *tc)
     }
 }
 
-static void recv_large_pollarray(CuTest *tc)
+static void recv_large_pollarray(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int lrv = LARGE_NUM_SOCKETS;
@@ -274,7 +274,7 @@ static void recv_large_pollarray(CuTest *tc)
 
     rv = apr_poll(pollarray_large, LARGE_NUM_SOCKETS, &lrv, 
                   2 * APR_USEC_PER_SEC);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_TIMEUP(rv));
+    abts_int_equal(tc, 1, APR_STATUS_IS_TIMEUP(rv));
 
     for (i = 0; i < LARGE_NUM_SOCKETS; i++) {
         check_sockets(pollarray_large, s, i, 0, tc);
@@ -282,14 +282,14 @@ static void recv_large_pollarray(CuTest *tc)
 }
 #endif
 
-static void setup_pollset(CuTest *tc)
+static void setup_pollset(abts_case *tc, void *data)
 {
     apr_status_t rv;
     rv = apr_pollset_create(&pollset, LARGE_NUM_SOCKETS, p, 0);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 }
 
-static void add_sockets_pollset(CuTest *tc)
+static void add_sockets_pollset(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int i;
@@ -297,30 +297,30 @@ static void add_sockets_pollset(CuTest *tc)
     for (i = 0; i < LARGE_NUM_SOCKETS;i++){
         apr_pollfd_t socket_pollfd;
 
-        CuAssertPtrNotNull(tc, s[i]);
+        abts_ptr_notnull(tc, s[i]);
 
         socket_pollfd.desc_type = APR_POLL_SOCKET;
         socket_pollfd.reqevents = APR_POLLIN;
         socket_pollfd.desc.s = s[i];
         socket_pollfd.client_data = s[i];
         rv = apr_pollset_add(pollset, &socket_pollfd);
-        CuAssertIntEquals(tc, APR_SUCCESS, rv);
+        abts_int_equal(tc, APR_SUCCESS, rv);
     }
 }
 
-static void nomessage_pollset(CuTest *tc)
+static void nomessage_pollset(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int lrv;
     const apr_pollfd_t *descs = NULL;
 
     rv = apr_pollset_poll(pollset, 0, &lrv, &descs);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_TIMEUP(rv));
-    CuAssertIntEquals(tc, 0, lrv);
-    CuAssertPtrEquals(tc, NULL, descs);
+    abts_int_equal(tc, 1, APR_STATUS_IS_TIMEUP(rv));
+    abts_int_equal(tc, 0, lrv);
+    abts_ptr_equal(tc, NULL, descs);
 }
 
-static void send0_pollset(CuTest *tc)
+static void send0_pollset(abts_case *tc, void *data)
 {
     apr_status_t rv;
     const apr_pollfd_t *descs = NULL;
@@ -328,15 +328,15 @@ static void send0_pollset(CuTest *tc)
     
     send_msg(s, sa, 0, tc);
     rv = apr_pollset_poll(pollset, 0, &num, &descs);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, 1, num);
-    CuAssertPtrNotNull(tc, descs);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, 1, num);
+    abts_ptr_notnull(tc, descs);
 
-    CuAssertPtrEquals(tc, s[0], descs[0].desc.s);
-    CuAssertPtrEquals(tc, s[0],  descs[0].client_data);
+    abts_ptr_equal(tc, s[0], descs[0].desc.s);
+    abts_ptr_equal(tc, s[0],  descs[0].client_data);
 }
 
-static void recv0_pollset(CuTest *tc)
+static void recv0_pollset(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int lrv;
@@ -344,12 +344,12 @@ static void recv0_pollset(CuTest *tc)
 
     recv_msg(s, 0, p, tc);
     rv = apr_pollset_poll(pollset, 0, &lrv, &descs);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_TIMEUP(rv));
-    CuAssertIntEquals(tc, 0, lrv);
-    CuAssertPtrEquals(tc, NULL, descs);
+    abts_int_equal(tc, 1, APR_STATUS_IS_TIMEUP(rv));
+    abts_int_equal(tc, 0, lrv);
+    abts_ptr_equal(tc, NULL, descs);
 }
 
-static void send_middle_pollset(CuTest *tc)
+static void send_middle_pollset(abts_case *tc, void *data)
 {
     apr_status_t rv;
     const apr_pollfd_t *descs = NULL;
@@ -358,16 +358,16 @@ static void send_middle_pollset(CuTest *tc)
     send_msg(s, sa, 2, tc);
     send_msg(s, sa, 5, tc);
     rv = apr_pollset_poll(pollset, 0, &num, &descs);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, 2, num);
-    CuAssertPtrNotNull(tc, descs);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, 2, num);
+    abts_ptr_notnull(tc, descs);
 
-    CuAssert(tc, "Incorrect socket in result set",
+    abts_assert(tc, "Incorrect socket in result set",
             ((descs[0].desc.s == s[2]) && (descs[1].desc.s == s[5])) ||
             ((descs[0].desc.s == s[5]) && (descs[1].desc.s == s[2])));
 }
 
-static void clear_middle_pollset(CuTest *tc)
+static void clear_middle_pollset(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int lrv;
@@ -377,12 +377,12 @@ static void clear_middle_pollset(CuTest *tc)
     recv_msg(s, 5, p, tc);
 
     rv = apr_pollset_poll(pollset, 0, &lrv, &descs);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_TIMEUP(rv));
-    CuAssertIntEquals(tc, 0, lrv);
-    CuAssertPtrEquals(tc, NULL, descs);
+    abts_int_equal(tc, 1, APR_STATUS_IS_TIMEUP(rv));
+    abts_int_equal(tc, 0, lrv);
+    abts_ptr_equal(tc, NULL, descs);
 }
 
-static void send_last_pollset(CuTest *tc)
+static void send_last_pollset(abts_case *tc, void *data)
 {
     apr_status_t rv;
     const apr_pollfd_t *descs = NULL;
@@ -390,15 +390,15 @@ static void send_last_pollset(CuTest *tc)
     
     send_msg(s, sa, LARGE_NUM_SOCKETS - 1, tc);
     rv = apr_pollset_poll(pollset, 0, &num, &descs);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, 1, num);
-    CuAssertPtrNotNull(tc, descs);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, 1, num);
+    abts_ptr_notnull(tc, descs);
 
-    CuAssertPtrEquals(tc, s[LARGE_NUM_SOCKETS - 1], descs[0].desc.s);
-    CuAssertPtrEquals(tc, s[LARGE_NUM_SOCKETS - 1],  descs[0].client_data);
+    abts_ptr_equal(tc, s[LARGE_NUM_SOCKETS - 1], descs[0].desc.s);
+    abts_ptr_equal(tc, s[LARGE_NUM_SOCKETS - 1],  descs[0].client_data);
 }
 
-static void clear_last_pollset(CuTest *tc)
+static void clear_last_pollset(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int lrv;
@@ -407,23 +407,23 @@ static void clear_last_pollset(CuTest *tc)
     recv_msg(s, LARGE_NUM_SOCKETS - 1, p, tc);
 
     rv = apr_pollset_poll(pollset, 0, &lrv, &descs);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_TIMEUP(rv));
-    CuAssertIntEquals(tc, 0, lrv);
-    CuAssertPtrEquals(tc, NULL, descs);
+    abts_int_equal(tc, 1, APR_STATUS_IS_TIMEUP(rv));
+    abts_int_equal(tc, 0, lrv);
+    abts_ptr_equal(tc, NULL, descs);
 }
 
-static void close_all_sockets(CuTest *tc)
+static void close_all_sockets(abts_case *tc, void *data)
 {
     apr_status_t rv;
     int i;
 
     for (i = 0; i < LARGE_NUM_SOCKETS; i++){
         rv = apr_socket_close(s[i]);
-        CuAssertIntEquals(tc, APR_SUCCESS, rv);
+        abts_int_equal(tc, APR_SUCCESS, rv);
     }
 }
 
-static void pollset_remove(CuTest *tc)
+static void pollset_remove(abts_case *tc, void *data)
 {
     apr_status_t rv;
     apr_pollset_t *pollset;
@@ -432,7 +432,7 @@ static void pollset_remove(CuTest *tc)
     apr_int32_t num;
 
     rv = apr_pollset_create(&pollset, 5, p, 0);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     pfd.p = p;
     pfd.desc_type = APR_POLL_SOCKET;
@@ -441,92 +441,92 @@ static void pollset_remove(CuTest *tc)
     pfd.desc.s = s[0];
     pfd.client_data = (void *)1;
     rv = apr_pollset_add(pollset, &pfd);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     pfd.desc.s = s[1];
     pfd.client_data = (void *)2;
     rv = apr_pollset_add(pollset, &pfd);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     pfd.desc.s = s[2];
     pfd.client_data = (void *)3;
     rv = apr_pollset_add(pollset, &pfd);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     pfd.desc.s = s[3];
     pfd.client_data = (void *)4;
     rv = apr_pollset_add(pollset, &pfd);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     rv = apr_pollset_poll(pollset, 1000, &num, &hot_files);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, 4, num);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, 4, num);
 
     /* now remove the pollset element referring to desc s[1] */
     pfd.desc.s = s[1];
     pfd.client_data = (void *)999; /* not used on this call */
     rv = apr_pollset_remove(pollset, &pfd);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     /* this time only three should match */
     rv = apr_pollset_poll(pollset, 1000, &num, &hot_files);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, 3, num);
-    CuAssertPtrEquals(tc, (void *)1, hot_files[0].client_data);
-    CuAssertPtrEquals(tc, s[0], hot_files[0].desc.s);
-    CuAssertPtrEquals(tc, (void *)3, hot_files[1].client_data);
-    CuAssertPtrEquals(tc, s[2], hot_files[1].desc.s);
-    CuAssertPtrEquals(tc, (void *)4, hot_files[2].client_data);
-    CuAssertPtrEquals(tc, s[3], hot_files[2].desc.s);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, 3, num);
+    abts_ptr_equal(tc, (void *)1, hot_files[0].client_data);
+    abts_ptr_equal(tc, s[0], hot_files[0].desc.s);
+    abts_ptr_equal(tc, (void *)3, hot_files[1].client_data);
+    abts_ptr_equal(tc, s[2], hot_files[1].desc.s);
+    abts_ptr_equal(tc, (void *)4, hot_files[2].client_data);
+    abts_ptr_equal(tc, s[3], hot_files[2].desc.s);
     
     /* now remove the pollset elements referring to desc s[2] */
     pfd.desc.s = s[2];
     pfd.client_data = (void *)999; /* not used on this call */
     rv = apr_pollset_remove(pollset, &pfd);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     /* this time only two should match */
     rv = apr_pollset_poll(pollset, 1000, &num, &hot_files);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, 2, num);
-    CuAssertPtrEquals(tc, (void *)1, hot_files[0].client_data);
-    CuAssertPtrEquals(tc, s[0], hot_files[0].desc.s);
-    CuAssertPtrEquals(tc, (void *)4, hot_files[1].client_data);
-    CuAssertPtrEquals(tc, s[3], hot_files[1].desc.s);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, 2, num);
+    abts_ptr_equal(tc, (void *)1, hot_files[0].client_data);
+    abts_ptr_equal(tc, s[0], hot_files[0].desc.s);
+    abts_ptr_equal(tc, (void *)4, hot_files[1].client_data);
+    abts_ptr_equal(tc, s[3], hot_files[1].desc.s);
 }
 
-CuSuite *testpoll(void)
+abts_suite *testpoll(abts_suite *suite)
 {
-    CuSuite *suite = CuSuiteNew("Poll");
+    suite = ADD_SUITE(suite)
 
-    SUITE_ADD_TEST(suite, create_all_sockets);
+    abts_run_test(suite, create_all_sockets, NULL);
 
 #ifdef OLD_POLL_INTERFACE
-    SUITE_ADD_TEST(suite, setup_small_poll);
-    SUITE_ADD_TEST(suite, setup_large_poll);
-    SUITE_ADD_TEST(suite, nomessage);
-    SUITE_ADD_TEST(suite, send_2);
-    SUITE_ADD_TEST(suite, recv_2_send_1);
-    SUITE_ADD_TEST(suite, send_2_signaled_1);
-    SUITE_ADD_TEST(suite, recv_1_send_0);
-    SUITE_ADD_TEST(suite, clear_all_signalled);
-    SUITE_ADD_TEST(suite, send_large_pollarray);
-    SUITE_ADD_TEST(suite, recv_large_pollarray);
+    abts_run_test(suite, setup_small_poll, NULL);
+    abts_run_test(suite, setup_large_poll, NULL);
+    abts_run_test(suite, nomessage, NULL);
+    abts_run_test(suite, send_2, NULL);
+    abts_run_test(suite, recv_2_send_1, NULL);
+    abts_run_test(suite, send_2_signaled_1, NULL);
+    abts_run_test(suite, recv_1_send_0, NULL);
+    abts_run_test(suite, clear_all_signalled, NULL);
+    abts_run_test(suite, send_large_pollarray, NULL);
+    abts_run_test(suite, recv_large_pollarray, NULL);
 #endif
 
-    SUITE_ADD_TEST(suite, setup_pollset);
-    SUITE_ADD_TEST(suite, add_sockets_pollset);
-    SUITE_ADD_TEST(suite, nomessage_pollset);
-    SUITE_ADD_TEST(suite, send0_pollset);
-    SUITE_ADD_TEST(suite, recv0_pollset);
-    SUITE_ADD_TEST(suite, send_middle_pollset);
-    SUITE_ADD_TEST(suite, clear_middle_pollset);
-    SUITE_ADD_TEST(suite, send_last_pollset);
-    SUITE_ADD_TEST(suite, clear_last_pollset);
-
-    SUITE_ADD_TEST(suite, pollset_remove);
+    abts_run_test(suite, setup_pollset, NULL);
+    abts_run_test(suite, add_sockets_pollset, NULL);
+    abts_run_test(suite, nomessage_pollset, NULL);
+    abts_run_test(suite, send0_pollset, NULL);
+    abts_run_test(suite, recv0_pollset, NULL);
+    abts_run_test(suite, send_middle_pollset, NULL);
+    abts_run_test(suite, clear_middle_pollset, NULL);
+    abts_run_test(suite, send_last_pollset, NULL);
+    abts_run_test(suite, clear_last_pollset, NULL);
+
+    abts_run_test(suite, pollset_remove, NULL);
     
-    SUITE_ADD_TEST(suite, close_all_sockets);
+    abts_run_test(suite, close_all_sockets, NULL);
 
     return suite;
 }