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: http://svn.apache.org/repos/asf/apr/apr/trunk@65091 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 38 insertions, 38 deletions

diff --git a/test/testfmt.c b/test/testfmt.c
index 20af8b9d0..2e1e38ca2 100644
--- a/test/testfmt.c
+++ b/test/testfmt.c
@@ -13,89 +13,89 @@
  * limitations under the License.
  */
 
-#include "test_apr.h"
+#include "testutil.h"
 #include "apr.h"
 #include "apr_portable.h"
 #include "apr_strings.h"
 
-static void ssize_t_fmt(CuTest *tc)
+static void ssize_t_fmt(abts_case *tc, void *data)
 {
     char buf[100];
     apr_ssize_t var = 0;
 
     sprintf(buf, "%" APR_SSIZE_T_FMT, var);
-    CuAssertStrEquals(tc, "0", buf);
+    abts_str_equal(tc, "0", buf);
     apr_snprintf(buf, sizeof(buf), "%" APR_SSIZE_T_FMT, var);
-    CuAssertStrEquals(tc, "0", buf);
+    abts_str_equal(tc, "0", buf);
 }
 
-static void size_t_fmt(CuTest *tc)
+static void size_t_fmt(abts_case *tc, void *data)
 {
     char buf[100];
     apr_size_t var = 0;
 
     sprintf(buf, "%" APR_SIZE_T_FMT, var);
-    CuAssertStrEquals(tc, "0", buf);
+    abts_str_equal(tc, "0", buf);
     apr_snprintf(buf, sizeof(buf), "%" APR_SIZE_T_FMT, var);
-    CuAssertStrEquals(tc, "0", buf);
+    abts_str_equal(tc, "0", buf);
 }
 
-static void off_t_fmt(CuTest *tc)
+static void off_t_fmt(abts_case *tc, void *data)
 {
     char buf[100];
     apr_off_t var = 0;
 
     sprintf(buf, "%" APR_OFF_T_FMT, var);
-    CuAssertStrEquals(tc, "0", buf);
+    abts_str_equal(tc, "0", buf);
     apr_snprintf(buf, sizeof(buf), "%" APR_OFF_T_FMT, var);
-    CuAssertStrEquals(tc, "0", buf);
+    abts_str_equal(tc, "0", buf);
 }
 
-static void pid_t_fmt(CuTest *tc)
+static void pid_t_fmt(abts_case *tc, void *data)
 {
     char buf[100];
     pid_t var = 0;
 
     sprintf(buf, "%" APR_PID_T_FMT, var);
-    CuAssertStrEquals(tc, "0", buf);
+    abts_str_equal(tc, "0", buf);
     apr_snprintf(buf, sizeof(buf), "%" APR_PID_T_FMT, var);
-    CuAssertStrEquals(tc, "0", buf);
+    abts_str_equal(tc, "0", buf);
 }
 
-static void int64_t_fmt(CuTest *tc)
+static void int64_t_fmt(abts_case *tc, void *data)
 {
     char buf[100];
     apr_int64_t var = 0;
 
     sprintf(buf, "%" APR_INT64_T_FMT, var);
-    CuAssertStrEquals(tc, "0", buf);
+    abts_str_equal(tc, "0", buf);
     apr_snprintf(buf, sizeof(buf), "%" APR_INT64_T_FMT, var);
-    CuAssertStrEquals(tc, "0", buf);
+    abts_str_equal(tc, "0", buf);
 }
 
-static void uint64_t_fmt(CuTest *tc)
+static void uint64_t_fmt(abts_case *tc, void *data)
 {
     char buf[100];
     apr_uint64_t var = APR_UINT64_C(14000000);
 
     sprintf(buf, "%" APR_UINT64_T_FMT, var);
-    CuAssertStrEquals(tc, "14000000", buf);
+    abts_str_equal(tc, "14000000", buf);
     apr_snprintf(buf, sizeof(buf), "%" APR_UINT64_T_FMT, var);
-    CuAssertStrEquals(tc, "14000000", buf);
+    abts_str_equal(tc, "14000000", buf);
 }
 
-static void uint64_t_hex_fmt(CuTest *tc)
+static void uint64_t_hex_fmt(abts_case *tc, void *data)
 {
     char buf[100];
     apr_uint64_t var = APR_UINT64_C(14000000);
 
     sprintf(buf, "%" APR_UINT64_T_HEX_FMT, var);
-    CuAssertStrEquals(tc, "d59f80", buf);
+    abts_str_equal(tc, "d59f80", buf);
     apr_snprintf(buf, sizeof(buf), "%" APR_UINT64_T_HEX_FMT, var);
-    CuAssertStrEquals(tc, "d59f80", buf);
+    abts_str_equal(tc, "d59f80", buf);
 }
 
-static void more_int64_fmts(CuTest *tc)
+static void more_int64_fmts(abts_case *tc, void *data)
 {
     char buf[100];
     apr_int64_t i = APR_INT64_C(-42);
@@ -104,30 +104,30 @@ static void more_int64_fmts(CuTest *tc)
     apr_uint64_t big = APR_UINT64_C(3141592653589793238);
 
     apr_snprintf(buf, sizeof buf, "%" APR_INT64_T_FMT, i);
-    CuAssertStrEquals(tc, buf, "-42");
+    abts_str_equal(tc, buf, "-42");
 
     apr_snprintf(buf, sizeof buf, "%" APR_UINT64_T_FMT, ui);
-    CuAssertStrEquals(tc, buf, "42");
+    abts_str_equal(tc, buf, "42");
 
     apr_snprintf(buf, sizeof buf, "%" APR_UINT64_T_FMT, big);
-    CuAssertStrEquals(tc, buf, "3141592653589793238");
+    abts_str_equal(tc, buf, "3141592653589793238");
 
     apr_snprintf(buf, sizeof buf, "%" APR_INT64_T_FMT, ibig);
-    CuAssertStrEquals(tc, buf, "-314159265358979323");
+    abts_str_equal(tc, buf, "-314159265358979323");
 }
 
-CuSuite *testfmt(void)
+abts_suite *testfmt(abts_suite *suite)
 {
-    CuSuite *suite = CuSuiteNew("Formats");
-
-    SUITE_ADD_TEST(suite, ssize_t_fmt);
-    SUITE_ADD_TEST(suite, size_t_fmt);
-    SUITE_ADD_TEST(suite, off_t_fmt);
-    SUITE_ADD_TEST(suite, pid_t_fmt);
-    SUITE_ADD_TEST(suite, int64_t_fmt);
-    SUITE_ADD_TEST(suite, uint64_t_fmt);
-    SUITE_ADD_TEST(suite, uint64_t_hex_fmt);
-    SUITE_ADD_TEST(suite, more_int64_fmts);
+    suite = ADD_SUITE(suite)
+
+    abts_run_test(suite, ssize_t_fmt, NULL);
+    abts_run_test(suite, size_t_fmt, NULL);
+    abts_run_test(suite, off_t_fmt, NULL);
+    abts_run_test(suite, pid_t_fmt, NULL);
+    abts_run_test(suite, int64_t_fmt, NULL);
+    abts_run_test(suite, uint64_t_fmt, NULL);
+    abts_run_test(suite, uint64_t_hex_fmt, NULL);
+    abts_run_test(suite, more_int64_fmts, NULL);
 
     return suite;
 }