sleela_java_string_vm_smoke.c
impl/core/sleela_java_string_vm_smoke.c · 121 line(s) · c
#include "sleela_core.h"
#include "sleela_java_string_codec.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
static int fail(SLVM *vm, const char *what) {
fprintf(stderr, "java-string-vm smoke failed: %s (vm=%s)\n",
what, slvm_error(vm) ? slvm_error(vm) : "no diagnostic");
slvm_free(vm);
return 1;
}
int main(void) {
static const uint16_t units[] = { 0x0041u, 0x0000u, 0xd83du, 0xde00u, 0xd800u };
SLVM *vm = slvm_new();
if (!vm) return 1;
SLValue value = slvm_java_string_new(vm, units, sizeof(units) / sizeof(units[0]));
if (value.type != SL_UTF16 || slvm_java_string_root(vm, value) != 0)
return fail(vm, "construct/root UTF-16 value");
int32_t length = -1, cp_count = -1, cp = -1, offset = -1;
uint16_t unit = 0;
if (slvm_java_string_length(vm, value, &length) != SL_JAVA_STRING_OK || length != 5)
return fail(vm, "UTF-16 length includes embedded NUL and surrogate units");
if (slvm_java_string_char_at(vm, value, 1, &unit) != SL_JAVA_STRING_OK || unit != 0)
return fail(vm, "charAt preserves embedded NUL");
if (slvm_java_string_char_at(vm, value, 4, &unit) != SL_JAVA_STRING_OK || unit != 0xd800u)
return fail(vm, "charAt preserves isolated high surrogate");
if (slvm_java_string_code_point_at(vm, value, 2, &cp) != SL_JAVA_STRING_OK || cp != 0x1f600)
return fail(vm, "codePointAt combines valid surrogate pair");
if (slvm_java_string_code_point_count(vm, value, 0, 5, &cp_count) != SL_JAVA_STRING_OK || cp_count != 4)
return fail(vm, "codePointCount treats isolated surrogate as one code point");
if (slvm_java_string_offset_by_code_points(vm, value, 2, 1, &offset) != SL_JAVA_STRING_OK || offset != 4)
return fail(vm, "offsetByCodePoints advances across pair");
SLValue pair = slvm_java_string_substring(vm, value, 2, 4);
if (pair.type != SL_UTF16 || slvm_java_string_root(vm, pair) != 0)
return fail(vm, "substring returns rooted UTF-16 value");
int equal = 0;
if (slvm_java_string_equals(vm, pair, pair, &equal) != SL_JAVA_STRING_OK || !equal)
return fail(vm, "equals");
int32_t hash = 0, order = 1;
if (slvm_java_string_hash_code(vm, pair, &hash) != SL_JAVA_STRING_OK)
return fail(vm, "hashCode");
if (slvm_java_string_compare_to(vm, pair, pair, &order) != SL_JAVA_STRING_OK || order != 0)
return fail(vm, "compareTo");
SLValue joined = slvm_java_string_concat(vm, pair, pair);
if (joined.type != SL_UTF16 || slvm_java_string_root(vm, joined) != 0)
return fail(vm, "concat returns rooted UTF-16 value");
if (slvm_java_string_length(vm, joined, &length) != SL_JAVA_STRING_OK || length != 4)
return fail(vm, "concat preserves UTF-16 units");
SLJavaString copy;
sljava_string_init_empty(©);
if (slvm_java_string_copy(vm, value, ©) != SL_JAVA_STRING_OK ||
copy.length != 5 || copy.units[1] != 0 || copy.units[4] != 0xd800u) {
sljava_string_destroy(©);
return fail(vm, "copy preserves all code units");
}
uint8_t *record = NULL;
size_t record_size = 0;
SLJavaString decoded;
sljava_string_init_empty(&decoded);
if (sljava_string_encode_record(©, &record, &record_size) != SL_JAVA_STRING_OK ||
sljava_string_decode_record(&decoded, record, record_size) != SL_JAVA_STRING_OK ||
decoded.length != copy.length || decoded.units[1] != 0 || decoded.units[4] != 0xd800u) {
free(record);
sljava_string_destroy(&decoded);
sljava_string_destroy(©);
return fail(vm, "versioned little-endian UTF-16 record round trip");
}
free(record);
sljava_string_destroy(&decoded);
sljava_string_destroy(©);
/* Exercise artifact v3 end-to-end: a UTF-16 constant survives save/load,
including embedded NUL and an isolated surrogate code unit. */
int constant_index = slvm_add_const_utf16(vm, units, sizeof(units) / sizeof(units[0]));
int entry = slvm_begin_func(vm, "javaStringArtifactEntry", 0, 0);
const char *artifact_path = "build/java_string_vm_roundtrip.sleela";
if (constant_index < 0 || entry < 0 ||
slvm_emit(vm, OP_CONST, constant_index) < 0 ||
slvm_emit0(vm, OP_RET) < 0) return fail(vm, "build UTF-16 artifact entry");
slvm_end_func(vm);
slvm_set_entry(vm, entry);
if (slvm_save_file(vm, artifact_path) != 0)
return fail(vm, "save UTF-16 artifact v3");
SLVM *loaded = slvm_load_file(artifact_path);
remove(artifact_path);
if (!loaded) return fail(vm, "load UTF-16 artifact v3");
if (slvm_run(loaded) != SLR_OK) {
slvm_free(loaded);
return fail(vm, "execute UTF-16 artifact v3");
}
SLValue loaded_value = slvm_result(loaded);
int32_t loaded_length = -1;
uint16_t loaded_unit = 0;
if (loaded_value.type != SL_UTF16 ||
slvm_java_string_length(loaded, loaded_value, &loaded_length) != SL_JAVA_STRING_OK ||
loaded_length != 5 ||
slvm_java_string_char_at(loaded, loaded_value, 4, &loaded_unit) != SL_JAVA_STRING_OK ||
loaded_unit != 0xd800u) {
slvm_free(loaded);
return fail(vm, "artifact v3 preserves UTF-16 constant payload");
}
slvm_free(loaded);
if (slvm_java_string_unroot(vm, joined) != 0 ||
slvm_java_string_unroot(vm, pair) != 0 ||
slvm_java_string_unroot(vm, value) != 0)
return fail(vm, "release explicit host roots");
slvm_free(vm);
puts("JAVA-STRING-VM-UTF16=PASS");
puts("JAVA-STRING-VM-NUL-SURROGATE-GC-ROOT-API=PASS");
return 0;
}