svn commit: r1935497 - in apr/apr-util/branches/1.7.x: . test

Author: brane
Date: Fri Jun 19 06:54:04 2026
New Revision: 1935497

Log:
Merge r1935351 from trunk:                                          

Overhaul the xlate tests, making each conversion a separate test case.
Print the source and target encoding of failing conversions.

Modified:
   apr/apr-util/branches/1.7.x/   (props changed)
   apr/apr-util/branches/1.7.x/test/testxlate.c

Modified: apr/apr-util/branches/1.7.x/test/testxlate.c
==============================================================================
--- apr/apr-util/branches/1.7.x/test/testxlate.c	Fri Jun 19 06:53:43 2026	(r1935496)
+++ apr/apr-util/branches/1.7.x/test/testxlate.c	Fri Jun 19 06:54:04 2026	(r1935497)
@@ -24,13 +24,45 @@
 
 #if APR_HAS_XLATE
 
+static const char cs_utf7[] = "UTF-7";
+static const char cs_utf8[] = "UTF-8";
+static const char cs_latin1[] = "ISO-8859-1";
+static const char cs_latin2[] = "ISO-8859-2";
+
 static const char test_utf8[] = "Edelwei\xc3\x9f";
 static const char test_utf7[] = "Edelwei+AN8-";
 static const char test_latin1[] = "Edelwei\xdf";
 static const char test_latin2[] = "Edelwei\xdf";
 
+struct test_params
+{
+    const char *cs1;            /* source encoding */
+    const char *cs2;            /* target encoding */
+    const char *source;
+    const char *expected;
+    int check_xlate_supported;
+};
+
+#define DECLARE_TEST_PARAMS(src, dst, chk)              \
+static struct test_params test_params_##src##_##dst = { \
+    cs_##src, cs_##dst, test_##src, test_##dst, (chk)   \
+}
+DECLARE_TEST_PARAMS(utf8, utf8, 0);
+DECLARE_TEST_PARAMS(utf8, latin1, 0);
+DECLARE_TEST_PARAMS(latin1, utf8, 0);
+DECLARE_TEST_PARAMS(latin1, latin2, 1);
+DECLARE_TEST_PARAMS(latin2, latin1, 1);
+DECLARE_TEST_PARAMS(utf8, utf7, 0);
+/* NOTE: The system libiconv on macOS has a bug in the UTF-7 to UTF-8
+ *       conversion that leaves the trailing '-' in the translated
+ *       string, causing this test to fail. */
+DECLARE_TEST_PARAMS(utf7, utf8, 0);
+#undef DECLARE_TEST_PARAMS
+
+
 static void test_conversion(abts_case *tc, apr_xlate_t *convset,
-                            const char *inbuf, const char *expected)
+                            const char *inbuf, const char *expected,
+                            const char *cs1, const char *cs2, apr_pool_t *pool)
 {
     static char buf[1024];
     apr_size_t inbytes_left = strlen(inbuf);
@@ -43,32 +75,23 @@ static void test_conversion(abts_case *t
     if (rv != APR_SUCCESS)
         return;
 
-    rv = apr_xlate_conv_buffer(convset, NULL, NULL, buf + sizeof(buf) -
-                               outbytes_left - 1, &outbytes_left);
+    rv = apr_xlate_conv_buffer(convset, NULL, NULL,
+                               buf + sizeof(buf) - outbytes_left - 1,
+                               &outbytes_left);
     ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 
     buf[sizeof(buf) - outbytes_left - 1] = '\0';
 
-    ABTS_STR_EQUAL(tc, expected, buf);
-}
-
-static void one_test(abts_case *tc, const char *cs1, const char *cs2,
-                     const char *str1, const char *str2,
-                     apr_pool_t *pool)
-{
-    apr_status_t rv;
-    apr_xlate_t *convset;
-
-    rv = apr_xlate_open(&convset, cs2, cs1, pool);
-    ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
-
-    if (rv != APR_SUCCESS)
-        return;
-
-    test_conversion(tc, convset, str1, str2);
-
-    rv = apr_xlate_close(convset);
-    ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
+    {
+        /* Make the source and target encodings part of the comparison
+           so that ABTS prints them if the results don't match, otherwise
+           we wouldn't know which conversion failed. */
+        const char *const expect = apr_psprintf(pool, "%s to %s: %s",
+                                                cs1, cs2, expected);
+        const char *const result = apr_psprintf(pool, "%s to %s: %s",
+                                                cs1, cs2, buf);
+        ABTS_STR_EQUAL(tc, expect, result);
+    }
 }
 
 #if APU_HAVE_APR_ICONV
@@ -81,8 +104,9 @@ static int is_transform_supported(abts_c
 /* some iconv implementations don't support all tested transforms;
  * example: 8859-1 <-> 8859-2 using native Solaris iconv
  */
-static int is_transform_supported(abts_case *tc, const char *cs1,
-                                  const char *cs2, apr_pool_t *pool) {
+static int is_transform_supported(abts_case *tc,
+                                  const char *cs1, const char *cs2,
+                                  apr_pool_t *pool) {
     apr_status_t rv;
     apr_xlate_t *convset;
 
@@ -100,24 +124,30 @@ static int is_transform_supported(abts_c
 
 static void test_transformation(abts_case *tc, void *data)
 {
-    /* 1. Identity transformation: UTF-8 -> UTF-8 */
-    one_test(tc, "UTF-8", "UTF-8", test_utf8, test_utf8, p);
+    const struct test_params *const params = data;
 
-    /* 2. UTF-8 <-> ISO-8859-1 */
-    one_test(tc, "UTF-8", "ISO-8859-1", test_utf8, test_latin1, p);
-    one_test(tc, "ISO-8859-1", "UTF-8", test_latin1, test_utf8, p);
+    apr_status_t rv;
+    apr_xlate_t *convset;
 
-    /* 3. ISO-8859-1 <-> ISO-8859-2, identity */
-    if (is_transform_supported(tc, "ISO-8859-1", "ISO-8859-2", p)) {
-        one_test(tc, "ISO-8859-1", "ISO-8859-2", test_latin1, test_latin2, p);
-    }
-    if (is_transform_supported(tc, "ISO-8859-2", "ISO-8859-1", p)) {
-        one_test(tc, "ISO-8859-2", "ISO-8859-1", test_latin2, test_latin1, p);
+    if (params->check_xlate_supported
+        && !is_transform_supported(tc, params->cs1, params->cs2, p)) {
+        ABTS_SKIP(tc, data,
+                  apr_psprintf(p, "xlate not supported: %s to %s",
+                  params->cs1, params->cs2));
+        return;
     }
 
-    /* 4. Transformation using charset aliases */
-    one_test(tc, "UTF-8", "UTF-7", test_utf8, test_utf7, p);
-    one_test(tc, "UTF-7", "UTF-8", test_utf7, test_utf8, p);
+    rv = apr_xlate_open(&convset, params->cs2, params->cs1, p);
+    ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
+
+    if (rv != APR_SUCCESS)
+        return;
+
+    test_conversion(tc, convset, params->source, params->expected,
+                    params->cs1, params->cs2, p);
+
+    rv = apr_xlate_close(convset);
+    ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 }
 
 #endif /* APR_HAS_XLATE */
@@ -127,7 +157,20 @@ abts_suite *testxlate(abts_suite *suite)
     suite = ADD_SUITE(suite);
 
 #if APR_HAS_XLATE
-    abts_run_test(suite, test_transformation, NULL);
+    /* 1. Identity transformation: UTF-8 -> UTF-8 */
+    abts_run_test(suite, test_transformation, &test_params_utf8_utf8);
+
+    /* 2. UTF-8 <-> ISO-8859-1 */
+    abts_run_test(suite, test_transformation, &test_params_latin1_utf8);
+    abts_run_test(suite, test_transformation, &test_params_utf8_latin1);
+
+    /* 3. Identity transformation: ISO-8859-1 <-> ISO-8859-2 */
+    abts_run_test(suite, test_transformation, &test_params_latin1_latin2);
+    abts_run_test(suite, test_transformation, &test_params_latin2_latin1);
+
+    /* 4. Transformation using charset aliases */
+    abts_run_test(suite, test_transformation, &test_params_utf8_utf7);
+    abts_run_test(suite, test_transformation, &test_params_utf7_utf8);
 #endif
 
     return suite;