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, 68 insertions, 68 deletions

diff --git a/test/testdir.c b/test/testdir.c
index 09c418022..b9a5bb2e4 100644
--- a/test/testdir.c
+++ b/test/testdir.c
@@ -21,130 +21,130 @@
 #include "apr_errno.h"
 #include "apr_general.h"
 #include "apr_lib.h"
-#include "test_apr.h"
+#include "testutil.h"
 
-static void test_mkdir(CuTest *tc)
+static void test_mkdir(abts_case *tc, void *data)
 {
     apr_status_t rv;
     apr_finfo_t finfo;
 
     rv = apr_dir_make("data/testdir", APR_UREAD | APR_UWRITE | APR_UEXECUTE, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     rv = apr_stat(&finfo, "data/testdir", APR_FINFO_TYPE, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, APR_DIR, finfo.filetype);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_DIR, finfo.filetype);
 }
 
-static void test_mkdir_recurs(CuTest *tc)
+static void test_mkdir_recurs(abts_case *tc, void *data)
 {
     apr_status_t rv;
     apr_finfo_t finfo;
 
     rv = apr_dir_make_recursive("data/one/two/three", 
                                 APR_UREAD | APR_UWRITE | APR_UEXECUTE, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     rv = apr_stat(&finfo, "data/one", APR_FINFO_TYPE, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, APR_DIR, finfo.filetype);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_DIR, finfo.filetype);
 
     rv = apr_stat(&finfo, "data/one/two", APR_FINFO_TYPE, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, APR_DIR, finfo.filetype);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_DIR, finfo.filetype);
 
     rv = apr_stat(&finfo, "data/one/two/three", APR_FINFO_TYPE, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertIntEquals(tc, APR_DIR, finfo.filetype);
+    abts_int_equal(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_DIR, finfo.filetype);
 }
 
-static void test_remove(CuTest *tc)
+static void test_remove(abts_case *tc, void *data)
 {
     apr_status_t rv;
     apr_finfo_t finfo;
 
     rv = apr_dir_remove("data/testdir", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     rv = apr_stat(&finfo, "data/testdir", APR_FINFO_TYPE, p);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_ENOENT(rv));
+    abts_int_equal(tc, 1, APR_STATUS_IS_ENOENT(rv));
 }
 
-static void test_removeall_fail(CuTest *tc)
+static void test_removeall_fail(abts_case *tc, void *data)
 {
     apr_status_t rv;
 
     rv = apr_dir_remove("data/one", p);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_ENOTEMPTY(rv));
+    abts_int_equal(tc, 1, APR_STATUS_IS_ENOTEMPTY(rv));
 }
 
-static void test_removeall(CuTest *tc)
+static void test_removeall(abts_case *tc, void *data)
 {
     apr_status_t rv;
 
     rv = apr_dir_remove("data/one/two/three", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     rv = apr_dir_remove("data/one/two", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     rv = apr_dir_remove("data/one", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 }
 
-static void test_remove_notthere(CuTest *tc)
+static void test_remove_notthere(abts_case *tc, void *data)
 {
     apr_status_t rv;
 
     rv = apr_dir_remove("data/notthere", p);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_ENOENT(rv));
+    abts_int_equal(tc, 1, APR_STATUS_IS_ENOENT(rv));
 }
 
-static void test_mkdir_twice(CuTest *tc)
+static void test_mkdir_twice(abts_case *tc, void *data)
 {
     apr_status_t rv;
 
     rv = apr_dir_make("data/testdir", APR_UREAD | APR_UWRITE | APR_UEXECUTE, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     rv = apr_dir_make("data/testdir", APR_UREAD | APR_UWRITE | APR_UEXECUTE, p);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_EEXIST(rv));
+    abts_int_equal(tc, 1, APR_STATUS_IS_EEXIST(rv));
 
     rv = apr_dir_remove("data/testdir", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 }
 
-static void test_opendir(CuTest *tc)
+static void test_opendir(abts_case *tc, void *data)
 {
     apr_status_t rv;
     apr_dir_t *dir;
 
     rv = apr_dir_open(&dir, "data", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     apr_dir_close(dir);
 }
 
-static void test_opendir_notthere(CuTest *tc)
+static void test_opendir_notthere(abts_case *tc, void *data)
 {
     apr_status_t rv;
     apr_dir_t *dir;
 
     rv = apr_dir_open(&dir, "notthere", p);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_ENOENT(rv));
+    abts_int_equal(tc, 1, APR_STATUS_IS_ENOENT(rv));
 }
 
-static void test_closedir(CuTest *tc)
+static void test_closedir(abts_case *tc, void *data)
 {
     apr_status_t rv;
     apr_dir_t *dir;
 
     rv = apr_dir_open(&dir, "data", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     rv = apr_dir_close(dir);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 }
 
-static void test_rewind(CuTest *tc)
+static void test_rewind(abts_case *tc, void *data)
 {
     apr_dir_t *dir;
     apr_finfo_t first, second;
@@ -161,12 +161,12 @@ static void test_rewind(CuTest *tc)
 
     apr_assert_success(tc, "apr_dir_close failed", apr_dir_close(dir));
 
-    CuAssertStrEquals(tc, first.name, second.name);
+    abts_str_equal(tc, first.name, second.name);
 }
 
 /* Test for a (fixed) bug in apr_dir_read().  This bug only happened
    in threadless cases. */
-static void test_uncleared_errno(CuTest *tc)
+static void test_uncleared_errno(abts_case *tc, void *data)
 {
     apr_file_t *thefile = NULL;
     apr_finfo_t finfo;
@@ -175,67 +175,67 @@ static void test_uncleared_errno(CuTest *tc)
     apr_status_t rv; 
 
     rv = apr_dir_make("dir1", APR_OS_DEFAULT, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     rv = apr_dir_make("dir2", APR_OS_DEFAULT, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     rv = apr_file_open(&thefile, "dir1/file1",
                        APR_READ | APR_WRITE | APR_CREATE, APR_OS_DEFAULT, p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     rv = apr_file_close(thefile);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     /* Try to remove dir1.  This should fail because it's not empty.
        However, on a platform with threads disabled (such as FreeBSD),
        `errno' will be set as a result. */
     rv = apr_dir_remove("dir1", p);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_ENOTEMPTY(rv));
+    abts_int_equal(tc, 1, APR_STATUS_IS_ENOTEMPTY(rv));
     
     /* Read `.' and `..' out of dir2. */
     rv = apr_dir_open(&this_dir, "dir2", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     rv = apr_dir_read(&finfo, finfo_flags, this_dir);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     rv = apr_dir_read(&finfo, finfo_flags, this_dir);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
     /* Now, when we attempt to do a third read of empty dir2, and the
        underlying system readdir() returns NULL, the old value of
        errno shouldn't cause a false alarm.  We should get an ENOENT
        back from apr_dir_read, and *not* the old errno. */
     rv = apr_dir_read(&finfo, finfo_flags, this_dir);
-    CuAssertIntEquals(tc, 1, APR_STATUS_IS_ENOENT(rv));
+    abts_int_equal(tc, 1, APR_STATUS_IS_ENOENT(rv));
 
     rv = apr_dir_close(this_dir);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 		 
     /* Cleanup */
     rv = apr_file_remove("dir1/file1", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     rv = apr_dir_remove("dir1", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
     rv = apr_dir_remove("dir2", p);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    abts_int_equal(tc, APR_SUCCESS, rv);
 
 }
 
-CuSuite *testdir(void)
+abts_suite *testdir(abts_suite *suite)
 {
-    CuSuite *suite = CuSuiteNew("Directory");
-
-    SUITE_ADD_TEST(suite, test_mkdir);
-    SUITE_ADD_TEST(suite, test_mkdir_recurs);
-    SUITE_ADD_TEST(suite, test_remove);
-    SUITE_ADD_TEST(suite, test_removeall_fail);
-    SUITE_ADD_TEST(suite, test_removeall);
-    SUITE_ADD_TEST(suite, test_remove_notthere);
-    SUITE_ADD_TEST(suite, test_mkdir_twice);
-
-    SUITE_ADD_TEST(suite, test_rewind);
-
-    SUITE_ADD_TEST(suite, test_opendir);
-    SUITE_ADD_TEST(suite, test_opendir_notthere);
-    SUITE_ADD_TEST(suite, test_closedir);
-    SUITE_ADD_TEST(suite, test_uncleared_errno);
+    suite = ADD_SUITE(suite)
+
+    abts_run_test(suite, test_mkdir, NULL);
+    abts_run_test(suite, test_mkdir_recurs, NULL);
+    abts_run_test(suite, test_remove, NULL);
+    abts_run_test(suite, test_removeall_fail, NULL);
+    abts_run_test(suite, test_removeall, NULL);
+    abts_run_test(suite, test_remove_notthere, NULL);
+    abts_run_test(suite, test_mkdir_twice, NULL);
+
+    abts_run_test(suite, test_rewind, NULL);
+
+    abts_run_test(suite, test_opendir, NULL);
+    abts_run_test(suite, test_opendir_notthere, NULL);
+    abts_run_test(suite, test_closedir, NULL);
+    abts_run_test(suite, test_uncleared_errno, NULL);
 
     return suite;
 }