Home /Modules/test-suites/reg_java_string.c

reg_java_string.c

test-suites/regression/c/reg_java_string.c · 412 line(s) · c

/*
 * reg_java_string.c -- regression suite for impl/core/sleela_java_string.c
 *
 * Contract (impl/core/sleela_java_string.h): a lossless java.lang.String
 * kernel over UTF-16 code units.  Embedded U+0000 and isolated surrogates are
 * preserved; results own independent buffers; every operation reports the
 * documented SLJavaStringStatus and leaves the destination untouched when it
 * fails.  Expected values for hashCode()/compareTo() are the ones the JDK
 * produces (hashes cross-computed independently in Python).
 */
#include "../../../impl/core/sleela_java_string.h"
#include "../../../impl/core/sleela_utf16.h"
#include "regression.h"

#include <limits.h>
#include <stdlib.h>
#include <string.h>

#define U16(...) ((const uint16_t[]){__VA_ARGS__})
#define N16(...) (sizeof((const uint16_t[]){__VA_ARGS__}) / sizeof(uint16_t))
#define MAKE(out, ...) REG_EQ_I(SL_JAVA_STRING_OK, sljava_string_from_utf16((out), U16(__VA_ARGS__), N16(__VA_ARGS__)))

static void from_ascii(SLJavaString *s, const char *a) {
    size_t n = strlen(a); uint16_t *u = (uint16_t *)malloc(n * sizeof(uint16_t) + 1);
    for (size_t i = 0; i < n; ++i) u[i] = (uint16_t)(unsigned char)a[i];
    (void)sljava_string_from_utf16(s, u, n);
    free(u);
}

static int same(const SLJavaString *s, const uint16_t *u, size_t n) {
    return s->length == n && (n == 0 || memcmp(s->units, u, n * sizeof(uint16_t)) == 0);
}

static int32_t hash_of(const SLJavaString *s) {
    int32_t h = 0; (void)sljava_string_hash_code(s, &h); return h;
}

/* ---- independent references ------------------------------------------- */
static int32_t ref_compare(const uint16_t *a, size_t an, const uint16_t *b, size_t bn) {
    size_t m = an < bn ? an : bn;
    for (size_t i = 0; i < m; ++i) if (a[i] != b[i]) return (int32_t)a[i] - (int32_t)b[i];
    return (int32_t)an - (int32_t)bn;
}
static int sgn(int32_t v) { return (v > 0) - (v < 0); }
static uint32_t ref_hash(const uint16_t *a, size_t n) {
    uint32_t h = 0; for (size_t i = 0; i < n; ++i) h = 31u * h + a[i]; return h;
}
static uint32_t pow31(size_t n) { uint32_t p = 1; while (n--) p *= 31u; return p; }
static int is_hi(uint16_t u) { return u >= 0xD800 && u <= 0xDBFF; }
static int is_lo(uint16_t u) { return u >= 0xDC00 && u <= 0xDFFF; }
static int32_t ref_cp_count(const uint16_t *u, size_t n) {
    int32_t c = 0;
    for (size_t i = 0; i < n; ++i, ++c) if (is_hi(u[i]) && i + 1 < n && is_lo(u[i + 1])) ++i;
    return c;
}

/* ---- cases -------------------------------------------------------------- */

static void t_lifecycle(void) {
    SLJavaString s; uint16_t src[3] = {1, 2, 3};
    sljava_string_init_empty(&s);
    REG_CHECK(s.units == NULL); REG_EQ_U(0, s.length);
    sljava_string_init_empty(NULL);   /* must not crash */
    sljava_string_destroy(NULL);      /* must not crash */
    sljava_string_destroy(&s);        /* empty destroy is a no-op */

    REG_EQ_I(SL_JAVA_STRING_OK, sljava_string_from_utf16(&s, src, 3));
    src[0] = 99;                      /* the copy must be independent */
    REG_CHECK(same(&s, U16(1, 2, 3), 3));
    REG_CHECK(s.units != src);
    /* replacing a live value releases the old buffer (leak-checked per case) */
    REG_EQ_I(SL_JAVA_STRING_OK, sljava_string_from_utf16(&s, src, 1));
    REG_CHECK(same(&s, U16(99), 1));
    REG_EQ_I(SL_JAVA_STRING_OK, sljava_string_from_utf16(&s, NULL, 0));
    REG_CHECK(s.units == NULL); REG_EQ_U(0, s.length);
    sljava_string_destroy(&s); sljava_string_destroy(&s); /* idempotent */

    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_from_utf16(NULL, src, 1));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_from_utf16(&s, NULL, 1));
}

static void t_invalid_values_rejected(void) {
    SLJavaString bad, out; int32_t i = 0; uint16_t u = 0; int eq = 0;
    sljava_string_init_empty(&out);
    bad.units = NULL; bad.length = 1;                 /* non-empty without storage */
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_length(&bad, &i));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_char_at(&bad, 0, &u));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_clone(&out, &bad));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_equals(&bad, &bad, &eq));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_length(NULL, &i));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_length(&out, NULL));
#if SIZE_MAX > INT32_MAX
    {   /* length beyond the Java limit is rejected before any dereference */
        SLJavaString huge; uint16_t stub = 0;
        huge.units = &stub; huge.length = (size_t)INT32_MAX + 1u;
        REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_length(&huge, &i));
        REG_EQ_I(SL_JAVA_STRING_TOO_LARGE,
                 sljava_string_from_utf16(&out, &stub, (size_t)INT32_MAX + 1u));
        REG_CHECK(out.units == NULL && out.length == 0);
    }
#endif
}

static void t_length_and_char_at(void) {
    SLJavaString s; int32_t n = -1; uint16_t c = 0;
    sljava_string_init_empty(&s);
    REG_EQ_I(0, sljava_string_length(&s, &n)); REG_EQ_I(0, n);
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_char_at(&s, 0, &c));
    MAKE(&s, 0x61, 0x0000, 0xD83D, 0xFFFF);
    REG_EQ_I(0, sljava_string_length(&s, &n)); REG_EQ_I(4, n);
    REG_EQ_I(0, sljava_string_char_at(&s, 1, &c)); REG_EQ_U(0, c);       /* NUL kept   */
    REG_EQ_I(0, sljava_string_char_at(&s, 2, &c)); REG_EQ_U(0xD83D, c);  /* lone high  */
    REG_EQ_I(0, sljava_string_char_at(&s, 3, &c)); REG_EQ_U(0xFFFF, c);  /* unsigned   */
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_char_at(&s, 4, &c));
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_char_at(&s, -1, &c));
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_char_at(&s, INT32_MIN, &c));
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_char_at(&s, INT32_MAX, &c));
    sljava_string_destroy(&s);
}

static void t_code_points(void) {
    SLJavaString s; int32_t v = 0, idx = 0;
    sljava_string_init_empty(&s);
    /* "a" U+1F600 "b", then a lone low, a lone high, and a high+non-low */
    MAKE(&s, 0x61, 0xD83D, 0xDE00, 0x62, 0xDC00, 0xD83D, 0xD83D, 0x63);
    REG_EQ_I(0, sljava_string_code_point_at(&s, 0, &v)); REG_EQ_I(0x61, v);
    REG_EQ_I(0, sljava_string_code_point_at(&s, 1, &v)); REG_EQ_I(0x1F600, v);
    REG_EQ_I(0, sljava_string_code_point_at(&s, 2, &v)); REG_EQ_I(0xDE00, v); /* mid-pair */
    REG_EQ_I(0, sljava_string_code_point_at(&s, 4, &v)); REG_EQ_I(0xDC00, v); /* lone low  */
    REG_EQ_I(0, sljava_string_code_point_at(&s, 5, &v)); REG_EQ_I(0xD83D, v); /* hi, hi    */
    REG_EQ_I(0, sljava_string_code_point_at(&s, 6, &v)); REG_EQ_I(0xD83D, v); /* hi, non-lo*/
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_code_point_at(&s, 8, &v));
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_code_point_at(&s, -1, &v));
    sljava_string_destroy(&s);

    MAKE(&s, 0x61, 0xD83D, 0xDE00, 0x62);
    REG_EQ_I(0, sljava_string_code_point_count(&s, 0, 4, &v)); REG_EQ_I(3, v);
    REG_EQ_I(0, sljava_string_code_point_count(&s, 1, 3, &v)); REG_EQ_I(1, v);
    REG_EQ_I(0, sljava_string_code_point_count(&s, 1, 2, &v)); REG_EQ_I(1, v); /* cut pair */
    REG_EQ_I(0, sljava_string_code_point_count(&s, 2, 3, &v)); REG_EQ_I(1, v);
    REG_EQ_I(0, sljava_string_code_point_count(&s, 4, 4, &v)); REG_EQ_I(0, v);
    REG_EQ_I(SL_JAVA_STRING_RANGE_OUT_OF_BOUNDS, sljava_string_code_point_count(&s, 3, 2, &v));
    REG_EQ_I(SL_JAVA_STRING_RANGE_OUT_OF_BOUNDS, sljava_string_code_point_count(&s, -1, 2, &v));
    REG_EQ_I(SL_JAVA_STRING_RANGE_OUT_OF_BOUNDS, sljava_string_code_point_count(&s, 0, 5, &v));

    REG_EQ_I(0, sljava_string_offset_by_code_points(&s, 0, 2, &idx)); REG_EQ_I(3, idx);
    REG_EQ_I(0, sljava_string_offset_by_code_points(&s, 0, 3, &idx)); REG_EQ_I(4, idx);
    REG_EQ_I(0, sljava_string_offset_by_code_points(&s, 4, -1, &idx)); REG_EQ_I(3, idx);
    REG_EQ_I(0, sljava_string_offset_by_code_points(&s, 4, -2, &idx)); REG_EQ_I(1, idx);
    REG_EQ_I(0, sljava_string_offset_by_code_points(&s, 3, -1, &idx)); REG_EQ_I(1, idx);
    REG_EQ_I(0, sljava_string_offset_by_code_points(&s, 2, -1, &idx)); REG_EQ_I(1, idx);
    REG_EQ_I(0, sljava_string_offset_by_code_points(&s, 2, 0, &idx)); REG_EQ_I(2, idx);
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_offset_by_code_points(&s, 0, 4, &idx));
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_offset_by_code_points(&s, 0, -1, &idx));
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_offset_by_code_points(&s, 5, 0, &idx));
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_offset_by_code_points(&s, 0, INT32_MAX, &idx));
    REG_EQ_I(SL_JAVA_STRING_INDEX_OUT_OF_BOUNDS, sljava_string_offset_by_code_points(&s, 4, INT32_MIN, &idx));
    sljava_string_destroy(&s);
}

static void t_substring(void) {
    SLJavaString s, r;
    sljava_string_init_empty(&s); sljava_string_init_empty(&r);
    MAKE(&s, 0x68, 0x65, 0x6C, 0x6C, 0x6F);
    REG_EQ_I(0, sljava_string_substring(&r, &s, 1, 4)); REG_CHECK(same(&r, U16(0x65, 0x6C, 0x6C), 3));
    REG_CHECK(r.units != s.units + 1);                     /* independent buffer */
    REG_EQ_I(0, sljava_string_substring(&r, &s, 0, 5)); REG_CHECK(same(&r, s.units, 5));
    REG_EQ_I(0, sljava_string_substring(&r, &s, 2, 2)); REG_EQ_U(0, r.length); REG_CHECK(r.units == NULL);
    REG_EQ_I(0, sljava_string_substring(&r, &s, 5, 5)); REG_EQ_U(0, r.length);
    /* failures leave the destination untouched */
    REG_EQ_I(0, sljava_string_substring(&r, &s, 0, 2));
    REG_EQ_I(SL_JAVA_STRING_RANGE_OUT_OF_BOUNDS, sljava_string_substring(&r, &s, 3, 2));
    REG_EQ_I(SL_JAVA_STRING_RANGE_OUT_OF_BOUNDS, sljava_string_substring(&r, &s, -1, 2));
    REG_EQ_I(SL_JAVA_STRING_RANGE_OUT_OF_BOUNDS, sljava_string_substring(&r, &s, 0, 6));
    REG_EQ_I(SL_JAVA_STRING_RANGE_OUT_OF_BOUNDS, sljava_string_substring(&r, &s, INT32_MAX, INT32_MAX));
    REG_CHECK(same(&r, U16(0x68, 0x65), 2));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_substring(NULL, &s, 0, 1));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_substring(&r, NULL, 0, 1));
    /* aliasing: destination is the source */
    REG_EQ_I(0, sljava_string_substring(&s, &s, 1, 3)); REG_CHECK(same(&s, U16(0x65, 0x6C), 2));
    sljava_string_destroy(&s); sljava_string_destroy(&r);
}

static void t_concat(void) {
    SLJavaString a, b, r;
    sljava_string_init_empty(&a); sljava_string_init_empty(&b); sljava_string_init_empty(&r);
    MAKE(&a, 0x61, 0xD83D); MAKE(&b, 0xDE00, 0x62);
    /* a lone high joined to a lone low forms a pair (value semantics, no validation) */
    REG_EQ_I(0, sljava_string_concat(&r, &a, &b));
    REG_CHECK(same(&r, U16(0x61, 0xD83D, 0xDE00, 0x62), 4));
    { int32_t v = 0; REG_EQ_I(0, sljava_string_code_point_at(&r, 1, &v)); REG_EQ_I(0x1F600, v); }
    REG_CHECK(r.units != a.units && r.units != b.units);
    /* empties */
    sljava_string_destroy(&b);
    REG_EQ_I(0, sljava_string_concat(&r, &a, &b)); REG_CHECK(same(&r, a.units, 2));
    REG_EQ_I(0, sljava_string_concat(&r, &b, &b)); REG_EQ_U(0, r.length); REG_CHECK(r.units == NULL);
    /* aliasing: out==left, out==right, left==right, out==both */
    MAKE(&b, 0x7A);
    REG_EQ_I(0, sljava_string_concat(&a, &a, &b)); REG_CHECK(same(&a, U16(0x61, 0xD83D, 0x7A), 3));
    REG_EQ_I(0, sljava_string_concat(&b, &a, &b)); REG_CHECK(same(&b, U16(0x61, 0xD83D, 0x7A, 0x7A), 4));
    REG_EQ_I(0, sljava_string_concat(&a, &a, &a)); REG_EQ_U(6, a.length);
    REG_EQ_MEM(a.units, U16(0x61, 0xD83D, 0x7A, 0x61, 0xD83D, 0x7A), 6 * sizeof(uint16_t));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_concat(NULL, &a, &b));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_concat(&r, NULL, &b));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_concat(&r, &a, NULL));
    sljava_string_destroy(&a); sljava_string_destroy(&b); sljava_string_destroy(&r);
}

static void t_clone(void) {
    SLJavaString a, c; sljava_string_init_empty(&a); sljava_string_init_empty(&c);
    MAKE(&a, 1, 0, 0xDC00);
    REG_EQ_I(0, sljava_string_clone(&c, &a)); REG_CHECK(same(&c, a.units, 3)); REG_CHECK(c.units != a.units);
    a.units[0] = 9; REG_EQ_U(1, c.units[0]);
    sljava_string_destroy(&a);
    REG_EQ_I(0, sljava_string_clone(&c, &a)); REG_EQ_U(0, c.length);
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_clone(NULL, &a));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_clone(&c, NULL));
    sljava_string_destroy(&c);
}

/* Values cross-computed with the JDK definition s[0]*31^(n-1)+...+s[n-1]. */
static void t_hash_code_golden(void) {
    static const struct { const char *ascii; int32_t h; } g[] = {
        {"", 0}, {"a", 97}, {"hello", 99162322}, {"Aa", 2112}, {"BB", 2112},
        {"Hello, World!", 1498789909},
        {"The quick brown fox jumps over the lazy dog", -609428141},
        {"polygenelubricants", INT32_MIN},            /* the famous Integer.MIN_VALUE */
        {"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", 641926002},
    };
    SLJavaString s; sljava_string_init_empty(&s);
    for (size_t i = 0; i < sizeof g / sizeof g[0]; ++i) {
        from_ascii(&s, g[i].ascii); REG_EQ_I(g[i].h, hash_of(&s));
    }
    MAKE(&s, 0xD83D, 0xDE00); REG_EQ_I(1772899, hash_of(&s));     /* U+1F600 */
    MAKE(&s, 0x00E9);         REG_EQ_I(233, hash_of(&s));
    MAKE(&s, 0x61, 0x00, 0x62); REG_EQ_I(93315, hash_of(&s));     /* NUL participates */
    MAKE(&s, 0xFFFF);         REG_EQ_I(65535, hash_of(&s));
    { int32_t h = 5; REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_hash_code(NULL, &h)); }
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_hash_code(&s, NULL));
    sljava_string_destroy(&s);
}

static void t_compare_and_equals_golden(void) {
    SLJavaString a, b; int32_t o = 0; int eq = -1;
    sljava_string_init_empty(&a); sljava_string_init_empty(&b);
    from_ascii(&a, "apple"); from_ascii(&b, "banana");
    REG_EQ_I(0, sljava_string_compare_to(&a, &b, &o)); REG_EQ_I(-1, o);
    REG_EQ_I(0, sljava_string_compare_to(&b, &a, &o)); REG_EQ_I(1, o);
    from_ascii(&a, "abc"); from_ascii(&b, "abcd");
    REG_EQ_I(0, sljava_string_compare_to(&a, &b, &o)); REG_EQ_I(-1, o);      /* prefix: length diff */
    from_ascii(&b, "abc");
    REG_EQ_I(0, sljava_string_compare_to(&a, &b, &o)); REG_EQ_I(0, o);
    REG_EQ_I(0, sljava_string_equals(&a, &b, &eq)); REG_EQ_I(1, eq);
    from_ascii(&b, "abd");
    REG_EQ_I(0, sljava_string_equals(&a, &b, &eq)); REG_EQ_I(0, eq);
    from_ascii(&a, "Z"); from_ascii(&b, "a");
    REG_EQ_I(0, sljava_string_compare_to(&a, &b, &o)); REG_EQ_I(-7, o);      /* 'Z'-'a' */
    /* UTF-16 unit order, NOT code point order: U+1F600 (D83D..) < U+FFFF */
    MAKE(&a, 0xD83D, 0xDE00); MAKE(&b, 0xFFFF);
    REG_EQ_I(0, sljava_string_compare_to(&a, &b, &o)); REG_EQ_I(0xD83D - 0xFFFF, o);
    /* empty strings */
    sljava_string_destroy(&a); sljava_string_destroy(&b);
    REG_EQ_I(0, sljava_string_equals(&a, &b, &eq)); REG_EQ_I(1, eq);
    REG_EQ_I(0, sljava_string_compare_to(&a, &b, &o)); REG_EQ_I(0, o);
    MAKE(&b, 0); /* "\0" is not the empty string */
    REG_EQ_I(0, sljava_string_equals(&a, &b, &eq)); REG_EQ_I(0, eq);
    REG_EQ_I(0, sljava_string_compare_to(&a, &b, &o)); REG_EQ_I(-1, o);
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_equals(&a, &b, NULL));
    REG_EQ_I(SL_JAVA_STRING_INVALID_ARGUMENT, sljava_string_compare_to(&a, NULL, &o));
    sljava_string_destroy(&b);
}

/* Failure atomicity under out-of-memory: status is OUT_OF_MEMORY, the
 * destination keeps its previous value, nothing leaks. */
static void t_out_of_memory_is_atomic(void) {
    SLJavaString out, a, b; uint16_t keep[2] = {7, 8};
    sljava_string_init_empty(&out); sljava_string_init_empty(&a); sljava_string_init_empty(&b);
    MAKE(&a, 1, 2, 3); MAKE(&b, 4, 5);
    REG_EQ_I(0, sljava_string_from_utf16(&out, keep, 2));

    reg_alloc_fail_nth(1);
    REG_EQ_I(SL_JAVA_STRING_OUT_OF_MEMORY, sljava_string_from_utf16(&out, a.units, 3));
    REG_CHECK(reg_alloc_injected()); REG_CHECK(same(&out, keep, 2));
    reg_alloc_fail_nth(1);
    REG_EQ_I(SL_JAVA_STRING_OUT_OF_MEMORY, sljava_string_clone(&out, &a)); REG_CHECK(same(&out, keep, 2));
    reg_alloc_fail_nth(1);
    REG_EQ_I(SL_JAVA_STRING_OUT_OF_MEMORY, sljava_string_substring(&out, &a, 0, 2)); REG_CHECK(same(&out, keep, 2));
    reg_alloc_fail_nth(1);
    REG_EQ_I(SL_JAVA_STRING_OUT_OF_MEMORY, sljava_string_concat(&out, &a, &b)); REG_CHECK(same(&out, keep, 2));
    /* aliased concat failing must not destroy its inputs */
    reg_alloc_fail_nth(1);
    REG_EQ_I(SL_JAVA_STRING_OUT_OF_MEMORY, sljava_string_concat(&a, &a, &b));
    REG_CHECK(same(&a, U16(1, 2, 3), 3));
    reg_alloc_fail_nth(0);
    sljava_string_destroy(&out); sljava_string_destroy(&a); sljava_string_destroy(&b);
}

/* Property: algebraic laws over deterministic random strings. */
static void t_algebraic_properties(void) {
    static const uint16_t alpha[] = {0x00, 0x01, 0x61, 0x7F, 0x80, 0xD7FF, 0xD800, 0xD83D,
                                     0xDBFF, 0xDC00, 0xDE00, 0xDFFF, 0xE000, 0xFFFF};
    uint16_t abuf[24], bbuf[24];
    reg_seed(0xABCDEF0123ull);
    for (int it = 0; it < 3000; ++it) {
        size_t an = reg_below(24), bn = reg_below(24);
        SLJavaString a, b, c, d; int32_t o1 = 0, o2 = 0; int eq = 0;
        for (size_t i = 0; i < an; ++i) abuf[i] = alpha[reg_below(sizeof alpha / sizeof alpha[0])];
        for (size_t i = 0; i < bn; ++i) bbuf[i] = alpha[reg_below(sizeof alpha / sizeof alpha[0])];
        sljava_string_init_empty(&a); sljava_string_init_empty(&b);
        sljava_string_init_empty(&c); sljava_string_init_empty(&d);
        REG_REQUIRE(sljava_string_from_utf16(&a, abuf, an) == 0);
        REG_REQUIRE(sljava_string_from_utf16(&b, bbuf, bn) == 0);

        /* length additivity and content of concat */
        REG_REQUIRE(sljava_string_concat(&c, &a, &b) == 0);
        REG_EQ_U(an + bn, c.length);
        /* substring undoes concat */
        REG_REQUIRE(sljava_string_substring(&d, &c, 0, (int32_t)an) == 0);
        REG_CHECK(same(&d, abuf, an));
        REG_REQUIRE(sljava_string_substring(&d, &c, (int32_t)an, (int32_t)(an + bn)) == 0);
        REG_CHECK(same(&d, bbuf, bn));
        /* hash homomorphism: h(ab) = h(a)*31^|b| + h(b)  (mod 2^32) */
        REG_EQ_U(ref_hash(abuf, an) * pow31(bn) + ref_hash(bbuf, bn), (uint32_t)hash_of(&c));
        REG_EQ_U(ref_hash(abuf, an), (uint32_t)hash_of(&a));
        /* compare: matches reference, antisymmetric, zero iff equal; equal => equal hash */
        REG_REQUIRE(sljava_string_compare_to(&a, &b, &o1) == 0);
        REG_REQUIRE(sljava_string_compare_to(&b, &a, &o2) == 0);
        REG_EQ_I(ref_compare(abuf, an, bbuf, bn), o1);
        REG_EQ_I(-sgn(o1), sgn(o2));
        REG_REQUIRE(sljava_string_equals(&a, &b, &eq) == 0);
        REG_EQ_I(o1 == 0, eq);
        if (eq) REG_EQ_I(hash_of(&a), hash_of(&b));
        /* concat with empty is identity; clone equals original */
        sljava_string_destroy(&d);
        REG_REQUIRE(sljava_string_concat(&d, &a, &d) == 0);
        REG_CHECK(same(&d, abuf, an));
        /* code point accounting */
        { int32_t cnt = 0, back = 0;
          REG_REQUIRE(sljava_string_code_point_count(&a, 0, (int32_t)an, &cnt) == 0);
          REG_EQ_I(ref_cp_count(abuf, an), cnt);
          REG_REQUIRE(sljava_string_offset_by_code_points(&a, 0, cnt, &back) == 0);
          REG_EQ_I((long long)an, back);
          REG_REQUIRE(sljava_string_offset_by_code_points(&a, (int32_t)an, -cnt, &back) == 0);
          REG_EQ_I(0, back);
        }
        sljava_string_destroy(&a); sljava_string_destroy(&b);
        sljava_string_destroy(&c); sljava_string_destroy(&d);
    }
}

/* Property: compareTo is a total preorder consistent with equals (sorting). */
static void t_compare_is_a_total_order(void) {
    static const uint16_t alpha[] = {0x00, 0x61, 0x80, 0xD7FF, 0xD800, 0xDC00, 0xE000, 0xFFFF};
    enum { N = 120 };
    SLJavaString s[N]; uint16_t buf[8];
    reg_seed(0x13572468ull);
    for (int i = 0; i < N; ++i) {
        size_t n = reg_below(6);
        for (size_t k = 0; k < n; ++k) buf[k] = alpha[reg_below(8)];
        sljava_string_init_empty(&s[i]);
        REG_REQUIRE(sljava_string_from_utf16(&s[i], buf, n) == 0);
    }
    for (int i = 0; i < N; ++i)
        for (int j = 0; j < N; ++j) {
            int32_t ij = 0, ji = 0, jk = 0, ik = 0;
            (void)sljava_string_compare_to(&s[i], &s[j], &ij);
            (void)sljava_string_compare_to(&s[j], &s[i], &ji);
            if (sgn(ij) != -sgn(ji)) { REG_CHECK(sgn(ij) == -sgn(ji)); return; }
            for (int k = (i * 7 + j) % 11; k < N; k += 11) {
                (void)sljava_string_compare_to(&s[j], &s[k], &jk);
                (void)sljava_string_compare_to(&s[i], &s[k], &ik);
                if (ij <= 0 && jk <= 0 && ik > 0) {
                    REG_CHECK(!"transitivity: a<=b && b<=c implies a<=c"); return;
                }
            }
        }
    for (int i = 0; i < N; ++i) sljava_string_destroy(&s[i]);
}

/* Integration: UTF-8 -> UTF-16 (sleela_utf16) -> SLJavaString agree on counts. */
static void t_utf8_pipeline(void) {
    const char *text = "a\xF0\x9F\x98\x80" "b\xC3\xA9\xE2\x82\xAC"; /* a U+1F600 b é € */
    uint16_t *units = NULL; size_t n = 0; SLJavaString s; int32_t len = 0, cps = 0, cp = 0;
    sljava_string_init_empty(&s);
    REG_EQ_I(0, sleela_utf8_to_utf16(text, strlen(text), &units, &n));
    REG_REQUIRE(units != NULL);
    REG_EQ_I(0, sljava_string_from_utf16(&s, units, n));
    free(units);
    REG_EQ_I(0, sljava_string_length(&s, &len)); REG_EQ_I(6, len);
    REG_EQ_I(0, sljava_string_code_point_count(&s, 0, len, &cps)); REG_EQ_I(5, cps);
    REG_EQ_I(0, sljava_string_code_point_at(&s, 1, &cp)); REG_EQ_I(0x1F600, cp);
    REG_EQ_I(0, sljava_string_code_point_at(&s, 5, &cp)); REG_EQ_I(0x20AC, cp);
    sljava_string_destroy(&s);
}

int main(void) {
    REG_RUN(t_lifecycle);
    REG_RUN(t_invalid_values_rejected);
    REG_RUN(t_length_and_char_at);
    REG_RUN(t_code_points);
    REG_RUN(t_substring);
    REG_RUN(t_concat);
    REG_RUN(t_clone);
    REG_RUN(t_hash_code_golden);
    REG_RUN(t_compare_and_equals_golden);
    REG_RUN(t_out_of_memory_is_atomic);
    REG_RUN(t_algebraic_properties);
    REG_RUN(t_compare_is_a_total_order);
    REG_RUN(t_utf8_pipeline);
    return reg_finish("java_string");
}