tigerbeetle 0.0.34 → 0.0.37

data/ext/tb_client/tigerbeetle/src/clients/java/src/jni_tests.zig

@@ -0,0 +1,1718 @@
+///! This test hosts an in-process JVM
+///! using the JNI Invocation API.
+const std = @import("std");
+const assert = std.debug.assert;
+const jni = @import("jni.zig");
+const testing = std.testing;
+
+const JavaVM = jni.JavaVM;
+const JNIEnv = jni.JNIEnv;
+
+test {
+    _ = @import("jni_thread_cleaner.zig");
+}
+
+test "JNI: check jvm" {
+    const env: *JNIEnv = get_testing_env();
+
+    var jvm: *JavaVM = undefined;
+    const get_java_vm_result = env.get_java_vm(&jvm);
+    try testing.expectEqual(jni.JNIResultType.ok, get_java_vm_result);
+
+    var vm_buf: [2]*jni.JavaVM = undefined;
+    var vm_len: jni.JSize = 0;
+    const get_created_java_vm_result = JavaVM.get_created_java_vm(
+        &vm_buf,
+        @intCast(vm_buf.len),
+        &vm_len,
+    );
+
+    try testing.expectEqual(jni.JNIResultType.ok, get_created_java_vm_result);
+    try testing.expect(vm_len == 1);
+    try testing.expectEqual(jvm, vm_buf[0]);
+}
+
+test "JNI: GetVersion" {
+    const env: *JNIEnv = get_testing_env();
+
+    const version = env.get_version();
+    try testing.expect(version >= jni.jni_version_10);
+}
+
+test "JNI: FindClass" {
+    const env: *JNIEnv = get_testing_env();
+
+    const object_class = env.find_class("java/lang/Object");
+    try testing.expect(object_class != null);
+    defer env.delete_local_ref(object_class);
+
+    const not_found = env.find_class("no/such/Class");
+    defer env.exception_clear();
+
+    try testing.expect(not_found == null);
+    try testing.expect(env.exception_check() == .jni_true);
+}
+
+test "JNI: GetSuperclass" {
+    const env: *JNIEnv = get_testing_env();
+
+    const object_class = env.find_class("java/lang/Object");
+    try testing.expect(object_class != null);
+    defer env.delete_local_ref(object_class);
+
+    try testing.expect(env.get_super_class(object_class) == null);
+
+    const string_class = env.find_class("java/lang/String");
+    try testing.expect(string_class != null);
+    defer env.delete_local_ref(string_class);
+
+    const super_class = env.get_super_class(string_class);
+    try testing.expect(super_class != null);
+    defer env.delete_local_ref(super_class);
+
+    try testing.expect(env.is_same_object(object_class, super_class) == .jni_true);
+}
+
+test "JNI: IsAssignableFrom" {
+    const env: *JNIEnv = get_testing_env();
+
+    const object_class = env.find_class("java/lang/Object");
+    try testing.expect(object_class != null);
+    defer env.delete_local_ref(object_class);
+
+    try testing.expect(env.get_super_class(object_class) == null);
+
+    const string_class = env.find_class("java/lang/String");
+    try testing.expect(string_class != null);
+    defer env.delete_local_ref(string_class);
+
+    const long_class = env.find_class("java/lang/Long");
+    try testing.expect(long_class != null);
+    defer env.delete_local_ref(long_class);
+
+    try testing.expect(env.is_assignable_from(long_class, object_class) == .jni_true);
+    try testing.expect(env.is_assignable_from(long_class, string_class) == .jni_false);
+}
+
+test "JNI: GetModule" {
+    const env: *JNIEnv = get_testing_env();
+
+    const exception_class = env.find_class("java/lang/Exception");
+    try testing.expect(exception_class != null);
+    defer env.delete_local_ref(exception_class);
+
+    const module = env.get_module(exception_class);
+    try testing.expect(module != null);
+    defer env.delete_local_ref(module);
+}
+
+test "JNI: Throw" {
+    const env: *JNIEnv = get_testing_env();
+
+    const exception_class = env.find_class("java/lang/Exception");
+    try testing.expect(exception_class != null);
+    defer env.delete_local_ref(exception_class);
+
+    const exception = env.alloc_object(exception_class);
+    try testing.expect(exception != null);
+    defer env.delete_local_ref(exception);
+
+    const throw_result = env.throw(exception);
+    try testing.expectEqual(jni.JNIResultType.ok, throw_result);
+    defer env.exception_clear();
+
+    try testing.expect(env.exception_check() == .jni_true);
+}
+
+test "JNI: ThrowNew" {
+    const env: *JNIEnv = get_testing_env();
+
+    const exception_class = env.find_class("java/lang/Exception");
+    try testing.expect(exception_class != null);
+    defer env.delete_local_ref(exception_class);
+
+    try testing.expect(env.exception_check() == .jni_false);
+
+    const throw_new_result = env.throw_new(exception_class, "");
+    try testing.expectEqual(jni.JNIResultType.ok, throw_new_result);
+    defer env.exception_clear();
+
+    try testing.expect(env.exception_check() == .jni_true);
+}
+
+test "JNI: ExceptionOccurred" {
+    const env: *JNIEnv = get_testing_env();
+
+    try testing.expect(env.exception_occurred() == null);
+
+    const exception_class = env.find_class("java/lang/Exception");
+    try testing.expect(exception_class != null);
+    defer env.delete_local_ref(exception_class);
+
+    const throw_new_result = env.throw_new(exception_class, "");
+    try testing.expectEqual(jni.JNIResultType.ok, throw_new_result);
+
+    const exception_occurred = env.exception_occurred();
+    try testing.expect(exception_occurred != null);
+    defer env.delete_local_ref(exception_occurred);
+
+    env.exception_clear();
+
+    try testing.expect(env.exception_occurred() == null);
+}
+
+test "JNI: ExceptionDescribe" {
+    const env: *JNIEnv = get_testing_env();
+
+    try testing.expect(env.exception_check() == .jni_false);
+
+    const exception_class = env.find_class("java/lang/Exception");
+    try testing.expect(exception_class != null);
+    defer env.delete_local_ref(exception_class);
+
+    const throw_new_result = env.throw_new(
+        exception_class,
+        "EXCEPTION DESCRIBED CORRECTLY",
+    );
+    try testing.expectEqual(jni.JNIResultType.ok, throw_new_result);
+    try testing.expect(env.exception_check() == .jni_true);
+    defer env.exception_clear();
+
+    env.exception_describe();
+}
+
+test "JNI: ExceptionClear" {
+    const env: *JNIEnv = get_testing_env();
+
+    // Asserting that calling it is a no-op here:
+    try testing.expect(env.exception_check() == .jni_false);
+    env.exception_clear();
+    try testing.expect(env.exception_check() == .jni_false);
+
+    const exception_class = env.find_class("java/lang/Exception");
+    try testing.expect(exception_class != null);
+    defer env.delete_local_ref(exception_class);
+
+    const throw_new_result = env.throw_new(exception_class, "");
+    try testing.expectEqual(jni.JNIResultType.ok, throw_new_result);
+
+    // Asserting that calling it clears the current exception:
+    try testing.expect(env.exception_check() == .jni_true);
+    env.exception_clear();
+    try testing.expect(env.exception_check() == .jni_false);
+}
+
+test "JNI: ExceptionCheck" {
+    const env: *JNIEnv = get_testing_env();
+
+    try testing.expect(env.exception_check() == .jni_false);
+
+    const object_class = env.find_class("java/lang/Object");
+    try testing.expect(object_class != null);
+    defer env.delete_local_ref(object_class);
+
+    const to_string = env.get_method_id(object_class, "toString", "()Ljava/lang/String;");
+    try testing.expect(to_string != null);
+
+    // Expected null reference exception:
+    const result = env.call_object_method(null, to_string, null);
+    try testing.expect(result == null);
+
+    try testing.expect(env.exception_check() == .jni_true);
+    env.exception_clear();
+    try testing.expect(env.exception_check() == .jni_false);
+}
+
+test "JNI: References" {
+    const env: *JNIEnv = get_testing_env();
+
+    const boolean_class = env.find_class("java/lang/Boolean");
+    try testing.expect(boolean_class != null);
+    defer env.delete_local_ref(boolean_class);
+
+    const obj = env.alloc_object(boolean_class);
+    defer env.delete_local_ref(obj);
+
+    try testing.expect(obj != null);
+    try testing.expect(env.get_object_ref_type(obj) == .local);
+
+    // Local ref:
+    {
+        const local_ref = env.new_local_ref(obj);
+        try testing.expect(local_ref != null);
+
+        try testing.expect(env.is_same_object(obj, local_ref) == .jni_true);
+        try testing.expect(env.get_object_ref_type(local_ref) == .local);
+
+        env.delete_local_ref(local_ref);
+        try testing.expect(env.new_local_ref(local_ref) == null);
+    }
+
+    // Global ref:
+    {
+        const global_ref = env.new_global_ref(obj);
+        try testing.expect(global_ref != null);
+
+        try testing.expect(env.is_same_object(obj, global_ref) == .jni_true);
+        try testing.expect(env.get_object_ref_type(global_ref) == .global);
+
+        env.delete_global_ref(global_ref);
+        try testing.expect(env.get_object_ref_type(global_ref) == .invalid);
+    }
+
+    // Weak global ref:
+    {
+        const weak_global_ref = env.new_weak_global_ref(obj);
+        try testing.expect(weak_global_ref != null);
+
+        try testing.expect(env.is_same_object(obj, weak_global_ref) == .jni_true);
+        try testing.expect(env.get_object_ref_type(weak_global_ref) == .weak_global);
+
+        env.delete_weak_global_ref(weak_global_ref);
+        try testing.expect(env.get_object_ref_type(weak_global_ref) == .invalid);
+    }
+}
+
+test "JNI: LocalFrame" {
+    const env: *JNIEnv = get_testing_env();
+
+    // Creating a new local frame.
+    const push_local_frame_result = env.push_local_frame(1);
+    try testing.expectEqual(jni.JNIResultType.ok, push_local_frame_result);
+
+    const ensure_local_capacity_result = env.ensure_local_capacity(10);
+    try testing.expectEqual(jni.JNIResultType.ok, ensure_local_capacity_result);
+
+    const boolean_class = env.find_class("java/lang/Boolean");
+    try testing.expect(boolean_class != null);
+    defer env.delete_local_ref(boolean_class);
+
+    const local_ref = env.alloc_object(boolean_class);
+    try testing.expect(local_ref != null);
+
+    // All local references must be invalidated after this frame being dropped,
+    // except by the frame result.
+    const pop_local_frame_result = env.pop_local_frame(local_ref);
+    try testing.expect(pop_local_frame_result != null);
+    defer env.delete_local_ref(pop_local_frame_result);
+
+    const valid_reference = env.get_object_ref_type(pop_local_frame_result);
+    try testing.expect(valid_reference == .local);
+    try testing.expect(pop_local_frame_result != local_ref);
+}
+
+test "JNI: AllocObject" {
+    const env: *JNIEnv = get_testing_env();
+
+    // Concrete type:
+    {
+        const boolean_class = env.find_class("java/lang/Boolean");
+        try testing.expect(boolean_class != null);
+        defer env.delete_local_ref(boolean_class);
+
+        const obj = env.alloc_object(boolean_class);
+        defer env.delete_local_ref(obj);
+
+        try testing.expect(obj != null);
+    }
+
+    // Interface:
+    {
+        const serializable_interface = env.find_class("java/io/Serializable");
+        try testing.expect(serializable_interface != null);
+        defer env.delete_local_ref(serializable_interface);
+
+        const obj = env.alloc_object(serializable_interface);
+        defer env.exception_clear();
+
+        try testing.expect(obj == null);
+        try testing.expect(env.exception_check() == .jni_true);
+    }
+
+    // Abstract class:
+    {
+        const calendar_abstract_class = env.find_class("java/util/Calendar");
+        try testing.expect(calendar_abstract_class != null);
+        defer env.delete_local_ref(calendar_abstract_class);
+
+        const obj = env.alloc_object(calendar_abstract_class);
+        defer env.exception_clear();
+
+        try testing.expect(obj == null);
+        try testing.expect(env.exception_check() == .jni_true);
+    }
+}
+
+test "JNI: NewObject" {
+    const env: *JNIEnv = get_testing_env();
+
+    const string_buffer_class = env.find_class("java/lang/StringBuffer");
+    try testing.expect(string_buffer_class != null);
+    defer env.delete_local_ref(string_buffer_class);
+
+    const capacity_ctor = env.get_method_id(string_buffer_class, "<init>", "(I)V");
+    try testing.expect(capacity_ctor != null);
+
+    const capacity: jni.JInt = 42;
+    const obj = env.new_object(
+        string_buffer_class,
+        capacity_ctor,
+        &[_]jni.JValue{jni.JValue.to_jvalue(capacity)},
+    );
+    try testing.expect(obj != null);
+    defer env.delete_local_ref(obj);
+}
+
+test "JNI: IsInstanceOf" {
+    const env: *JNIEnv = get_testing_env();
+
+    const boolean_class = env.find_class("java/lang/Boolean");
+    try testing.expect(boolean_class != null);
+    defer env.delete_local_ref(boolean_class);
+
+    const obj = env.alloc_object(boolean_class);
+    defer env.delete_local_ref(obj);
+
+    try testing.expect(obj != null);
+
+    try testing.expect(env.is_instance_of(obj, boolean_class) == .jni_true);
+
+    const long_class = env.find_class("java/lang/Long");
+    try testing.expect(long_class != null);
+    defer env.delete_local_ref(long_class);
+
+    try testing.expect(env.is_instance_of(obj, long_class) == .jni_false);
+}
+
+test "JNI: GetFieldId" {
+    const env: *JNIEnv = get_testing_env();
+
+    const boolean_class = env.find_class("java/lang/Boolean");
+    try testing.expect(boolean_class != null);
+    defer env.delete_local_ref(boolean_class);
+
+    const value_field_id = env.get_field_id(boolean_class, "value", "Z");
+    try testing.expect(value_field_id != null);
+
+    const invalid_field = env.get_field_id(boolean_class, "not_a_valid_field", "I");
+    defer env.exception_clear();
+
+    try testing.expect(invalid_field == null);
+    try testing.expect(env.exception_check() == .jni_true);
+}
+
+test "JNI: Get<Type>Field, Set<Type>Field" {
+    const env: *JNIEnv = get_testing_env();
+
+    // Boolean:
+    {
+        const boolean_class = env.find_class("java/lang/Boolean");
+        try testing.expect(boolean_class != null);
+        defer env.delete_local_ref(boolean_class);
+
+        const value_field_id = env.get_field_id(boolean_class, "value", "Z");
+        try testing.expect(value_field_id != null);
+
+        const obj = env.alloc_object(boolean_class);
+        defer env.delete_local_ref(obj);
+
+        try testing.expect(obj != null);
+
+        const value_before = env.get_boolean_field(obj, value_field_id);
+        try testing.expect(value_before == .jni_false);
+
+        env.set_boolean_field(obj, value_field_id, .jni_true);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const value_after = env.get_boolean_field(obj, value_field_id);
+        try testing.expect(value_after == .jni_true);
+    }
+
+    // Byte:
+    {
+        const byte_class = env.find_class("java/lang/Byte");
+        try testing.expect(byte_class != null);
+        defer env.delete_local_ref(byte_class);
+
+        const value_field_id = env.get_field_id(byte_class, "value", "B");
+        try testing.expect(value_field_id != null);
+
+        const obj = env.alloc_object(byte_class);
+        defer env.delete_local_ref(obj);
+
+        try testing.expect(obj != null);
+
+        const value_before = env.get_byte_field(obj, value_field_id);
+        try testing.expect(value_before == 0);
+
+        env.set_byte_field(obj, value_field_id, 127);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const value_after = env.get_byte_field(obj, value_field_id);
+        try testing.expect(value_after == 127);
+    }
+
+    // Char:
+    {
+        const char_class = env.find_class("java/lang/Character");
+        try testing.expect(char_class != null);
+        defer env.delete_local_ref(char_class);
+
+        const value_field_id = env.get_field_id(char_class, "value", "C");
+        try testing.expect(value_field_id != null);
+
+        const obj = env.alloc_object(char_class);
+        defer env.delete_local_ref(obj);
+
+        try testing.expect(obj != null);
+
+        const value_before = env.get_char_field(obj, value_field_id);
+        try testing.expect(value_before == 0);
+
+        env.set_char_field(obj, value_field_id, 'A');
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const value_after = env.get_char_field(obj, value_field_id);
+        try testing.expect(value_after == 'A');
+    }
+
+    // Short:
+    {
+        const short_class = env.find_class("java/lang/Short");
+        try testing.expect(short_class != null);
+        defer env.delete_local_ref(short_class);
+
+        const value_field_id = env.get_field_id(short_class, "value", "S");
+        try testing.expect(value_field_id != null);
+
+        const obj = env.alloc_object(short_class);
+        defer env.delete_local_ref(obj);
+
+        try testing.expect(obj != null);
+
+        const value_before = env.get_short_field(obj, value_field_id);
+        try testing.expect(value_before == 0);
+
+        env.set_short_field(obj, value_field_id, 9999);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const value_after = env.get_short_field(obj, value_field_id);
+        try testing.expect(value_after == 9999);
+    }
+
+    // Int:
+    {
+        const int_class = env.find_class("java/lang/Integer");
+        try testing.expect(int_class != null);
+        defer env.delete_local_ref(int_class);
+
+        const value_field_id = env.get_field_id(int_class, "value", "I");
+        try testing.expect(value_field_id != null);
+
+        const obj = env.alloc_object(int_class);
+        defer env.delete_local_ref(obj);
+
+        try testing.expect(obj != null);
+
+        const value_before = env.get_int_field(obj, value_field_id);
+        try testing.expect(value_before == 0);
+
+        env.set_int_field(obj, value_field_id, 999_999);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const value_after = env.get_int_field(obj, value_field_id);
+        try testing.expect(value_after == 999_999);
+    }
+
+    // Long:
+    {
+        const long_class = env.find_class("java/lang/Long");
+        try testing.expect(long_class != null);
+        defer env.delete_local_ref(long_class);
+
+        const value_field_id = env.get_field_id(long_class, "value", "J");
+        try testing.expect(value_field_id != null);
+
+        const obj = env.alloc_object(long_class);
+        defer env.delete_local_ref(obj);
+
+        try testing.expect(obj != null);
+
+        const value_before = env.get_long_field(obj, value_field_id);
+        try testing.expect(value_before == 0);
+
+        env.set_long_field(obj, value_field_id, 9_999_999_999);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const value_after = env.get_long_field(obj, value_field_id);
+        try testing.expect(value_after == 9_999_999_999);
+    }
+
+    // Float:
+    {
+        const float_class = env.find_class("java/lang/Float");
+        try testing.expect(float_class != null);
+        defer env.delete_local_ref(float_class);
+
+        const value_field_id = env.get_field_id(float_class, "value", "F");
+        try testing.expect(value_field_id != null);
+
+        const obj = env.alloc_object(float_class);
+        defer env.delete_local_ref(obj);
+
+        try testing.expect(obj != null);
+
+        const value_before = env.get_float_field(obj, value_field_id);
+        try testing.expect(value_before == 0);
+
+        env.set_float_field(obj, value_field_id, 9.99);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const value_after = env.get_float_field(obj, value_field_id);
+        try testing.expect(value_after == 9.99);
+    }
+
+    // Double:
+    {
+        const double_class = env.find_class("java/lang/Double");
+        try testing.expect(double_class != null);
+        defer env.delete_local_ref(double_class);
+
+        const value_field_id = env.get_field_id(double_class, "value", "D");
+        try testing.expect(value_field_id != null);
+
+        const obj = env.alloc_object(double_class);
+        defer env.delete_local_ref(obj);
+
+        try testing.expect(obj != null);
+
+        const value_before = env.get_double_field(obj, value_field_id);
+        try testing.expect(value_before == 0);
+
+        env.set_double_field(obj, value_field_id, 9.99);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const value_after = env.get_double_field(obj, value_field_id);
+        try testing.expect(value_after == 9.99);
+    }
+
+    // Object:
+    {
+        const object_class = env.find_class("java/lang/Throwable");
+        try testing.expect(object_class != null);
+        defer env.delete_local_ref(object_class);
+
+        const value_field_id = env.get_field_id(object_class, "cause", "Ljava/lang/Throwable;");
+        try testing.expect(value_field_id != null);
+
+        const obj = env.alloc_object(object_class);
+        defer env.delete_local_ref(obj);
+
+        try testing.expect(obj != null);
+
+        const value_before = env.get_object_field(obj, value_field_id);
+        try testing.expect(value_before == null);
+
+        env.set_object_field(obj, value_field_id, obj);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const value_after = env.get_object_field(obj, value_field_id);
+        try testing.expect(value_after != null);
+    }
+}
+
+test "JNI: GetMethodId" {
+    const env: *JNIEnv = get_testing_env();
+
+    const object_class = env.find_class("java/lang/Throwable");
+    try testing.expect(object_class != null);
+    defer env.delete_local_ref(object_class);
+
+    const method_id = env.get_method_id(object_class, "toString", "()Ljava/lang/String;");
+    try testing.expect(method_id != null);
+
+    const invalid_method = env.get_method_id(object_class, "invalid_method", "()V");
+    defer env.exception_clear();
+
+    try testing.expect(invalid_method == null);
+    try testing.expect(env.exception_check() == .jni_true);
+}
+
+test "JNI: Call<Type>Method,CallNonVirtual<Type>Method" {
+    const env: *JNIEnv = get_testing_env();
+
+    const buffer_class = env.find_class("java/nio/ByteBuffer");
+    try testing.expect(buffer_class != null);
+    defer env.delete_local_ref(buffer_class);
+
+    const direct_buffer_class = env.find_class("java/nio/DirectByteBuffer");
+    try testing.expect(direct_buffer_class != null);
+    defer env.delete_local_ref(direct_buffer_class);
+
+    const element: u8 = 42;
+    var native_buffer: [256]u8 = @splat(element);
+    const buffer = env.new_direct_byte_buffer(&native_buffer, @intCast(native_buffer.len));
+    try testing.expect(buffer != null);
+    defer env.delete_local_ref(buffer);
+
+    // Byte:
+    {
+        const method_id = env.get_method_id(buffer_class, "get", "()B");
+        try testing.expect(method_id != null);
+
+        const non_virtual_method_id = env.get_method_id(direct_buffer_class, "get", "()B");
+        try testing.expect(non_virtual_method_id != null);
+
+        const expected: jni.JByte = @bitCast(element);
+
+        const read = env.call_byte_method(buffer, method_id, null);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read);
+
+        const read_non_virtual = env.call_nonvirtual_byte_method(
+            buffer,
+            direct_buffer_class,
+            non_virtual_method_id,
+            null,
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read_non_virtual);
+    }
+
+    // Short:
+    {
+        const method_id = env.get_method_id(buffer_class, "getShort", "()S");
+        try testing.expect(method_id != null);
+
+        const non_virtual_method_id = env.get_method_id(direct_buffer_class, "getShort", "()S");
+        try testing.expect(non_virtual_method_id != null);
+
+        const Packed = packed struct { a: u8, b: u8 };
+        const expected: jni.JShort = @bitCast(Packed{
+            .a = element,
+            .b = element,
+        });
+
+        const read = env.call_short_method(buffer, method_id, null);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read);
+
+        const read_non_virtual = env.call_nonvirtual_short_method(
+            buffer,
+            direct_buffer_class,
+            non_virtual_method_id,
+            null,
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read_non_virtual);
+    }
+
+    // Char:
+    {
+        const method_id = env.get_method_id(buffer_class, "getChar", "()C");
+        try testing.expect(method_id != null);
+
+        const non_virtual_method_id = env.get_method_id(direct_buffer_class, "getChar", "()C");
+        try testing.expect(non_virtual_method_id != null);
+
+        const Packed = packed struct { a: u8, b: u8 };
+        const expected: jni.JChar = @bitCast(Packed{
+            .a = element,
+            .b = element,
+        });
+
+        const read = env.call_char_method(buffer, method_id, null);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read);
+
+        const read_non_virtual = env.call_nonvirtual_char_method(
+            buffer,
+            direct_buffer_class,
+            non_virtual_method_id,
+            null,
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read_non_virtual);
+    }
+
+    // Int:
+    {
+        const method_id = env.get_method_id(buffer_class, "getInt", "()I");
+        try testing.expect(method_id != null);
+
+        const non_virtual_method_id = env.get_method_id(direct_buffer_class, "getInt", "()I");
+        try testing.expect(non_virtual_method_id != null);
+
+        const Packed = packed struct { a: u8, b: u8, c: u8, d: u8 };
+        const expected: jni.JInt = @bitCast(Packed{
+            .a = element,
+            .b = element,
+            .c = element,
+            .d = element,
+        });
+
+        const read = env.call_int_method(buffer, method_id, null);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read);
+
+        const read_non_virtual = env.call_nonvirtual_int_method(
+            buffer,
+            direct_buffer_class,
+            non_virtual_method_id,
+            null,
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read_non_virtual);
+    }
+
+    // Long:
+    {
+        const method_id = env.get_method_id(buffer_class, "getLong", "()J");
+        try testing.expect(method_id != null);
+
+        const non_virtual_method_id = env.get_method_id(direct_buffer_class, "getLong", "()J");
+        try testing.expect(non_virtual_method_id != null);
+
+        const Packed = packed struct { a: u8, b: u8, c: u8, d: u8, e: u8, f: u8, g: u8, h: u8 };
+        const expected: jni.JLong = @bitCast(Packed{
+            .a = element,
+            .b = element,
+            .c = element,
+            .d = element,
+            .e = element,
+            .f = element,
+            .g = element,
+            .h = element,
+        });
+
+        const read = env.call_long_method(buffer, method_id, null);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read);
+
+        const read_non_virtual = env.call_nonvirtual_long_method(
+            buffer,
+            direct_buffer_class,
+            non_virtual_method_id,
+            null,
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read_non_virtual);
+    }
+
+    // Float:
+    {
+        const method_id = env.get_method_id(buffer_class, "getFloat", "()F");
+        try testing.expect(method_id != null);
+
+        const non_virtual_method_id = env.get_method_id(direct_buffer_class, "getFloat", "()F");
+        try testing.expect(non_virtual_method_id != null);
+
+        const Packed = packed struct { a: u8, b: u8, c: u8, d: u8 };
+        const expected: jni.JFloat = @bitCast(Packed{
+            .a = element,
+            .b = element,
+            .c = element,
+            .d = element,
+        });
+
+        const read = env.call_float_method(buffer, method_id, null);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read);
+
+        const read_non_virtual = env.call_nonvirtual_float_method(
+            buffer,
+            direct_buffer_class,
+            non_virtual_method_id,
+            null,
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read_non_virtual);
+    }
+
+    // Double:
+    {
+        const method_id = env.get_method_id(buffer_class, "getDouble", "()D");
+        try testing.expect(method_id != null);
+
+        const non_virtual_method_id = env.get_method_id(direct_buffer_class, "getDouble", "()D");
+        try testing.expect(non_virtual_method_id != null);
+
+        const Packed = packed struct { a: u8, b: u8, c: u8, d: u8, e: u8, f: u8, g: u8, h: u8 };
+        const expected: jni.JDouble = @bitCast(Packed{
+            .a = element,
+            .b = element,
+            .c = element,
+            .d = element,
+            .e = element,
+            .f = element,
+            .g = element,
+            .h = element,
+        });
+
+        const read = env.call_double_method(buffer, method_id, null);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read);
+
+        const read_non_virtual = env.call_nonvirtual_double_method(
+            buffer,
+            direct_buffer_class,
+            non_virtual_method_id,
+            null,
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expectEqual(expected, read_non_virtual);
+    }
+
+    // Object:
+    {
+        const method_id = env.get_method_id(buffer_class, "put", "(B)Ljava/nio/ByteBuffer;");
+        try testing.expect(method_id != null);
+
+        const non_virtual_method_id = env.get_method_id(
+            direct_buffer_class,
+            "put",
+            "(B)Ljava/nio/ByteBuffer;",
+        );
+        try testing.expect(non_virtual_method_id != null);
+
+        const put = env.call_object_method(buffer, method_id, &[_]jni.JValue{
+            jni.JValue.to_jvalue(@as(jni.JByte, 0)),
+        });
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(env.is_same_object(buffer, put) == .jni_true);
+        defer env.delete_local_ref(put);
+
+        const put_non_virtual = env.call_nonvirtual_object_method(
+            buffer,
+            direct_buffer_class,
+            non_virtual_method_id,
+            &[_]jni.JValue{jni.JValue.to_jvalue(@as(jni.JByte, 0))},
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(env.is_same_object(buffer, put_non_virtual) == .jni_true);
+        defer env.delete_local_ref(put_non_virtual);
+    }
+}
+
+test "JNI: GetStaticFieldId" {
+    const env: *JNIEnv = get_testing_env();
+
+    const boolean_class = env.find_class("java/lang/Boolean");
+    try testing.expect(boolean_class != null);
+    defer env.delete_local_ref(boolean_class);
+
+    const field_id = env.get_static_field_id(boolean_class, "serialVersionUID", "J");
+    try testing.expect(field_id != null);
+
+    const invalid_field_id = env.get_static_field_id(boolean_class, "invalid_field", "J");
+    defer env.exception_clear();
+
+    try testing.expect(invalid_field_id == null);
+    try testing.expect(env.exception_check() == .jni_true);
+}
+
+test "JNI: GetStatic<Type>Field, SetStatic<Type>Field" {
+    const env: *JNIEnv = get_testing_env();
+
+    // Byte:
+    {
+        const class = env.find_class("java/lang/Byte");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const field_id = env.get_static_field_id(class, "MIN_VALUE", "B");
+        try testing.expect(field_id != null);
+
+        const before = env.get_static_byte_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(before == -128);
+
+        env.set_static_byte_field(class, field_id, -127);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const after = env.get_static_byte_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(after == -127);
+    }
+
+    // Char:
+    {
+        const class = env.find_class("java/lang/Character");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const field_id = env.get_static_field_id(class, "MIN_VALUE", "C");
+        try testing.expect(field_id != null);
+
+        const before = env.get_static_char_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(before == 0);
+
+        env.set_static_char_field(class, field_id, 1);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const after = env.get_static_char_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(after == 1);
+    }
+
+    // Short:
+    {
+        const class = env.find_class("java/lang/Short");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const field_id = env.get_static_field_id(class, "MIN_VALUE", "S");
+        try testing.expect(field_id != null);
+
+        const before = env.get_static_short_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(before == -32768);
+
+        env.set_static_short_field(class, field_id, -32767);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const after = env.get_static_short_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(after == -32767);
+    }
+
+    // Int:
+    {
+        const class = env.find_class("java/lang/Integer");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const field_id = env.get_static_field_id(class, "MIN_VALUE", "I");
+        try testing.expect(field_id != null);
+
+        const before = env.get_static_int_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(before == -2147483648);
+
+        env.set_static_int_field(class, field_id, -2147483647);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const after = env.get_static_int_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(after == -2147483647);
+    }
+
+    // Long:
+    {
+        const class = env.find_class("java/lang/Long");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const field_id = env.get_static_field_id(class, "MIN_VALUE", "J");
+        try testing.expect(field_id != null);
+
+        const before = env.get_static_long_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(before == -9223372036854775808);
+
+        env.set_static_long_field(class, field_id, -9223372036854775807);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const after = env.get_static_long_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(after == -9223372036854775807);
+    }
+
+    // Float:
+    {
+        const class = env.find_class("java/lang/Float");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const field_id = env.get_static_field_id(class, "MIN_VALUE", "F");
+        try testing.expect(field_id != null);
+
+        const before = env.get_static_float_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(before == 1.4E-45);
+
+        env.set_static_float_field(class, field_id, 1.4E-44);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const after = env.get_static_float_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(after == 1.4E-44);
+    }
+
+    // Double:
+    {
+        const class = env.find_class("java/lang/Double");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const field_id = env.get_static_field_id(class, "MIN_VALUE", "D");
+        try testing.expect(field_id != null);
+
+        const before = env.get_static_double_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(before == 4.9E-324);
+
+        env.set_static_double_field(class, field_id, 4.9E-323);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const after = env.get_static_double_field(class, field_id);
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(after == 4.9E-323);
+    }
+}
+
+test "JNI: GetStaticMethodId" {
+    const env: *JNIEnv = get_testing_env();
+
+    const boolean_class = env.find_class("java/lang/Boolean");
+    try testing.expect(boolean_class != null);
+    defer env.delete_local_ref(boolean_class);
+
+    const method_id = env.get_static_method_id(boolean_class, "valueOf", "(Z)Ljava/lang/Boolean;");
+    try testing.expect(method_id != null);
+
+    const invalid_method_id = env.get_static_method_id(boolean_class, "invalid_method", "()J");
+    defer env.exception_clear();
+
+    try testing.expect(invalid_method_id == null);
+    try testing.expect(env.exception_check() == .jni_true);
+}
+
+test "JNI: CallStatic<Type>Method" {
+    const env: *JNIEnv = get_testing_env();
+
+    const str = env.new_string_utf("1");
+    try testing.expect(str != null);
+    defer env.delete_local_ref(str);
+
+    // Boolean:
+    {
+        const class = env.find_class("java/lang/Boolean");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const method_id = env.get_static_method_id(class, "parseBoolean", "(Ljava/lang/String;)Z");
+        try testing.expect(method_id != null);
+
+        const ret = env.call_static_boolean_method(
+            class,
+            method_id,
+            &[_]jni.JValue{jni.JValue.to_jvalue(str)},
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(ret == .jni_false);
+    }
+
+    // Byte:
+    {
+        const class = env.find_class("java/lang/Byte");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const method_id = env.get_static_method_id(class, "parseByte", "(Ljava/lang/String;)B");
+        try testing.expect(method_id != null);
+
+        const ret = env.call_static_byte_method(
+            class,
+            method_id,
+            &[_]jni.JValue{jni.JValue.to_jvalue(str)},
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(ret == 1);
+    }
+
+    // Char:
+    {
+        const class = env.find_class("java/lang/Character");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const method_id = env.get_static_method_id(class, "toLowerCase", "(C)C");
+        try testing.expect(method_id != null);
+
+        const ret = env.call_static_char_method(
+            class,
+            method_id,
+            &[_]jni.JValue{jni.JValue.to_jvalue(@as(jni.JChar, 'A'))},
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(ret == 'a');
+    }
+
+    // Short:
+    {
+        const class = env.find_class("java/lang/Short");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const method_id = env.get_static_method_id(class, "parseShort", "(Ljava/lang/String;)S");
+        try testing.expect(method_id != null);
+
+        const ret = env.call_static_short_method(
+            class,
+            method_id,
+            &[_]jni.JValue{jni.JValue.to_jvalue(str)},
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(ret == 1);
+    }
+
+    // Int:
+    {
+        const class = env.find_class("java/lang/Integer");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const method_id = env.get_static_method_id(class, "parseInt", "(Ljava/lang/String;)I");
+        try testing.expect(method_id != null);
+
+        const ret = env.call_static_int_method(
+            class,
+            method_id,
+            &[_]jni.JValue{jni.JValue.to_jvalue(str)},
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(ret == 1);
+    }
+
+    // Long:
+    {
+        const class = env.find_class("java/lang/Long");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const method_id = env.get_static_method_id(class, "parseLong", "(Ljava/lang/String;)J");
+        try testing.expect(method_id != null);
+
+        const ret = env.call_static_long_method(
+            class,
+            method_id,
+            &[_]jni.JValue{jni.JValue.to_jvalue(str)},
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(ret == 1);
+    }
+
+    // Float:
+    {
+        const class = env.find_class("java/lang/Float");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const method_id = env.get_static_method_id(class, "parseFloat", "(Ljava/lang/String;)F");
+        try testing.expect(method_id != null);
+
+        const ret = env.call_static_float_method(
+            class,
+            method_id,
+            &[_]jni.JValue{jni.JValue.to_jvalue(str)},
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(ret == 1.0);
+    }
+
+    // Double:
+    {
+        const class = env.find_class("java/lang/Double");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const method_id = env.get_static_method_id(class, "parseDouble", "(Ljava/lang/String;)D");
+        try testing.expect(method_id != null);
+
+        const ret = env.call_static_double_method(
+            class,
+            method_id,
+            &[_]jni.JValue{jni.JValue.to_jvalue(str)},
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        try testing.expect(ret == 1.0);
+    }
+
+    // Object:
+    {
+        const class = env.find_class("java/lang/String");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const method_id = env.get_static_method_id(
+            class,
+            "valueOf",
+            "(Ljava/lang/Object;)Ljava/lang/String;",
+        );
+        try testing.expect(method_id != null);
+
+        const ret = env.call_static_object_method(
+            class,
+            method_id,
+            &[_]jni.JValue{jni.JValue.to_jvalue(str)},
+        );
+        try testing.expect(env.exception_check() == .jni_false);
+        defer env.delete_local_ref(ret);
+
+        try testing.expect(env.is_instance_of(ret, class) == .jni_true);
+    }
+
+    // Void:
+    {
+        const class = env.find_class("java/lang/System");
+        try testing.expect(class != null);
+        defer env.delete_local_ref(class);
+
+        const method_id = env.get_static_method_id(class, "gc", "()V");
+        try testing.expect(method_id != null);
+
+        env.call_static_void_method(class, method_id, null);
+        try testing.expect(env.exception_check() == .jni_false);
+    }
+}
+
+test "JNI: strings" {
+    const env: *JNIEnv = get_testing_env();
+
+    const content: []const u16 = std.unicode.utf8ToUtf16LeStringLiteral("Hello utf16")[0..];
+    const string = env.new_string(
+        content.ptr,
+        @intCast(content.len),
+    );
+    try testing.expect(string != null);
+    defer env.delete_local_ref(string);
+
+    const len = env.get_string_length(string);
+    try testing.expectEqual(content.len, @as(usize, @intCast(len)));
+
+    const address = env.get_string_chars(string, null) orelse {
+        try testing.expect(false);
+        unreachable;
+    };
+    defer env.release_string_chars(string, address);
+
+    try testing.expectEqualSlices(u16, content[0..], address[0..@as(usize, @intCast(len))]);
+}
+
+test "JNI: strings utf" {
+    const env: *JNIEnv = get_testing_env();
+
+    const content = "Hello utf8";
+    const string = env.new_string_utf(content);
+    try testing.expect(string != null);
+    defer env.delete_local_ref(string);
+
+    const len = env.get_string_utf_length(string);
+    try testing.expectEqual(content.len, @as(usize, @intCast(len)));
+
+    const address = env.get_string_utf_chars(string, null) orelse {
+        try testing.expect(false);
+        unreachable;
+    };
+    defer env.release_string_utf_chars(string, address);
+
+    try testing.expectEqualSlices(u8, content[0..], address[0..@as(usize, @intCast(len))]);
+}
+
+test "JNI: GetStringRegion" {
+    const env: *JNIEnv = get_testing_env();
+
+    const content: []const u16 =
+        std.unicode.utf8ToUtf16LeStringLiteral("ABCDEFGHIJKLMNOPQRSTUVXYZ")[0..];
+    const string = env.new_string(
+        content.ptr,
+        @intCast(content.len),
+    );
+    try testing.expect(string != null);
+    defer env.delete_local_ref(string);
+
+    var buff: [10]jni.JChar = undefined;
+    env.get_string_region(string, 5, 10, &buff);
+    try testing.expect(env.exception_check() == .jni_false);
+    try testing.expectEqualSlices(u16, content[5..][0..10], &buff);
+}
+
+test "JNI: GetStringUTFRegion" {
+    const env: *JNIEnv = get_testing_env();
+
+    const content = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
+    const string = env.new_string_utf(content);
+    try testing.expect(string != null);
+    defer env.delete_local_ref(string);
+
+    // From: https://docs.oracle.com/en/java/javase/17/docs/specs/jni/functions.html#getstringutfregion.
+    // The resulting number modified UTF-8 encoding characters may be greater than
+    // the given len argument. GetStringUTFLength() may be used to determine the
+    // maximum size of the required character buffer.
+
+    var buff: [content.len]u8 = undefined;
+    env.get_string_utf_region(string, 5, 10, &buff);
+    try testing.expect(env.exception_check() == .jni_false);
+    try testing.expectEqualSlices(u8, content[5..][0..10], buff[0..10]);
+}
+
+test "JNI: GetStringCritical" {
+    const env: *JNIEnv = get_testing_env();
+
+    const content: []const u16 =
+        std.unicode.utf8ToUtf16LeStringLiteral("ABCDEFGHIJKLMNOPQRSTUVXYZ")[0..];
+    const str = env.new_string(content.ptr, @intCast(content.len));
+    try testing.expect(str != null);
+    defer env.delete_local_ref(str);
+
+    const len = env.get_string_length(str);
+    try testing.expectEqual(content.len, @as(usize, @intCast(len)));
+
+    const region = env.get_string_critical(str, null) orelse {
+        try testing.expect(false);
+        unreachable;
+    };
+    defer env.release_string_critical(str, region);
+
+    try testing.expectEqualSlices(u16, content, region[0..@as(usize, @intCast(len))]);
+}
+
+test "JNI: DirectByteBuffer" {
+    const env: *JNIEnv = get_testing_env();
+
+    var native_buffer = blk: {
+        var array: [32]u8 = undefined;
+        var value: u8 = array.len;
+        for (&array) |*byte| {
+            value -= 1;
+            byte.* = value;
+        }
+        break :blk array;
+    };
+
+    const buffer = env.new_direct_byte_buffer(&native_buffer, native_buffer.len);
+    try testing.expect(buffer != null);
+    defer env.delete_local_ref(buffer);
+
+    const capacity = env.get_direct_buffer_capacity(buffer);
+    try testing.expect(capacity == native_buffer.len);
+
+    const address = env.get_direct_buffer_address(buffer) orelse {
+        try testing.expect(false);
+        unreachable;
+    };
+
+    try testing.expectEqualSlices(u8, &native_buffer, address[0..@as(usize, @intCast(capacity))]);
+}
+
+test "JNI: object array" {
+    const env: *JNIEnv = get_testing_env();
+
+    const object_class = env.find_class("java/lang/Object");
+    try testing.expect(object_class != null);
+    defer env.delete_local_ref(object_class);
+
+    const array = env.new_object_array(32, object_class, null);
+    try testing.expect(array != null);
+    defer env.delete_local_ref(array);
+
+    // ArrayIndexOutOfBoundsException:
+    env.set_object_array_element(array, -1, null);
+    try testing.expect(env.exception_check() == .jni_true);
+    env.exception_clear();
+
+    env.set_object_array_element(array, 32, null);
+    try testing.expect(env.exception_check() == .jni_true);
+    env.exception_clear();
+
+    // Valid indexes:
+    var index: jni.JInt = 0;
+    while (index < 32) : (index += 1) {
+        const obj_before = env.get_object_array_element(array, index);
+        try testing.expect(obj_before == null);
+
+        const obj = env.alloc_object(object_class);
+        try testing.expect(obj != null);
+        defer env.delete_local_ref(obj);
+
+        env.set_object_array_element(array, index, obj);
+        try testing.expect(env.exception_check() == .jni_false);
+
+        const obj_after = env.get_object_array_element(array, index);
+        try testing.expect(obj_after != null);
+        defer env.delete_local_ref(obj_after);
+
+        try testing.expect(env.is_same_object(obj, obj_after) == .jni_true);
+    }
+}
+
+test "JNI: primitive arrays" {
+    const ArrayTest = struct {
+        fn ArrayTestType(comptime PrimitiveType: type) type {
+            return struct {
+                fn cast(value: anytype) PrimitiveType {
+                    return switch (PrimitiveType) {
+                        jni.JBoolean => switch (value) {
+                            0 => jni.JBoolean.jni_false,
+                            else => jni.JBoolean.jni_true,
+                        },
+                        jni.JFloat, jni.JDouble => @floatFromInt(value),
+                        else => @intCast(value),
+                    };
+                }
+
+                fn get_array_elements(env: *jni.JNIEnv, array: jni.JArray) ?[*]PrimitiveType {
+                    return switch (PrimitiveType) {
+                        jni.JBoolean => env.get_boolean_array_elements(array, null),
+                        jni.JByte => env.get_byte_array_elements(array, null),
+                        jni.JShort => env.get_short_array_elements(array, null),
+                        jni.JChar => env.get_char_array_elements(array, null),
+                        jni.JInt => env.get_int_array_elements(array, null),
+                        jni.JLong => env.get_long_array_elements(array, null),
+                        jni.JFloat => env.get_float_array_elements(array, null),
+                        jni.JDouble => env.get_double_array_elements(array, null),
+                        else => unreachable,
+                    };
+                }
+
+                fn release_array_elements(
+                    env: *jni.JNIEnv,
+                    array: jni.JArray,
+                    elements: [*]PrimitiveType,
+                ) void {
+                    switch (PrimitiveType) {
+                        jni.JBoolean => env.release_boolean_array_elements(
+                            array,
+                            elements,
+                            .default,
+                        ),
+                        jni.JByte => env.release_byte_array_elements(
+                            array,
+                            elements,
+                            .default,
+                        ),
+                        jni.JShort => env.release_short_array_elements(
+                            array,
+                            elements,
+                            .default,
+                        ),
+                        jni.JChar => env.release_char_array_elements(
+                            array,
+                            elements,
+                            .default,
+                        ),
+                        jni.JInt => env.release_int_array_elements(
+                            array,
+                            elements,
+                            .default,
+                        ),
+                        jni.JLong => env.release_long_array_elements(
+                            array,
+                            elements,
+                            .default,
+                        ),
+                        jni.JFloat => env.release_float_array_elements(
+                            array,
+                            elements,
+                            .default,
+                        ),
+                        jni.JDouble => env.release_double_array_elements(
+                            array,
+                            elements,
+                            .default,
+                        ),
+                        else => unreachable,
+                    }
+                }
+
+                fn get_array_region(
+                    env: *jni.JNIEnv,
+                    array: jni.JArray,
+                    start: jni.JSize,
+                    len: jni.JSize,
+                    buf: [*]PrimitiveType,
+                ) void {
+                    switch (PrimitiveType) {
+                        jni.JBoolean => env.get_boolean_array_region(array, start, len, buf),
+                        jni.JByte => env.get_byte_array_region(array, start, len, buf),
+                        jni.JShort => env.get_short_array_region(array, start, len, buf),
+                        jni.JChar => env.get_char_array_region(array, start, len, buf),
+                        jni.JInt => env.get_int_array_region(array, start, len, buf),
+                        jni.JLong => env.get_long_array_region(array, start, len, buf),
+                        jni.JFloat => env.get_float_array_region(array, start, len, buf),
+                        jni.JDouble => env.get_double_array_region(array, start, len, buf),
+                        else => unreachable,
+                    }
+                }
+
+                fn set_array_region(
+                    env: *jni.JNIEnv,
+                    array: jni.JArray,
+                    start: jni.JSize,
+                    len: jni.JSize,
+                    buf: [*]PrimitiveType,
+                ) void {
+                    switch (PrimitiveType) {
+                        jni.JBoolean => env.set_boolean_array_region(array, start, len, buf),
+                        jni.JByte => env.set_byte_array_region(array, start, len, buf),
+                        jni.JShort => env.set_short_array_region(array, start, len, buf),
+                        jni.JChar => env.set_char_array_region(array, start, len, buf),
+                        jni.JInt => env.set_int_array_region(array, start, len, buf),
+                        jni.JLong => env.set_long_array_region(array, start, len, buf),
+                        jni.JFloat => env.set_float_array_region(array, start, len, buf),
+                        jni.JDouble => env.set_double_array_region(array, start, len, buf),
+                        else => unreachable,
+                    }
+                }
+
+                pub fn assert(env: *JNIEnv) !void {
+                    const length = 32;
+
+                    const array = switch (PrimitiveType) {
+                        jni.JBoolean => env.new_boolean_array(length),
+                        jni.JByte => env.new_byte_array(length),
+                        jni.JChar => env.new_char_array(length),
+                        jni.JShort => env.new_short_array(length),
+                        jni.JInt => env.new_int_array(length),
+                        jni.JLong => env.new_long_array(length),
+                        jni.JFloat => env.new_float_array(length),
+                        jni.JDouble => env.new_double_array(length),
+                        else => unreachable,
+                    };
+
+                    try testing.expect(array != null);
+                    defer env.delete_local_ref(array);
+
+                    const len = env.get_array_length(array);
+                    try testing.expect(len == length);
+
+                    // Change the array:
+                    {
+                        const elements = get_array_elements(env, array) orelse {
+                            try testing.expect(false);
+                            unreachable;
+                        };
+                        defer release_array_elements(env, array, elements);
+
+                        for (elements[0..@as(usize, @intCast(len))], 0..) |*element, i| {
+                            try testing.expectEqual(cast(0), element.*);
+                            element.* = cast(i);
+                        }
+                    }
+
+                    // Check changes:
+                    {
+                        const elements = get_array_elements(env, array) orelse {
+                            try testing.expect(false);
+                            unreachable;
+                        };
+                        defer release_array_elements(env, array, elements);
+
+                        for (elements[0..@as(usize, @intCast(len))], 0..) |element, i| {
+                            try testing.expectEqual(cast(i), element);
+                        }
+                    }
+
+                    // ArrayRegion:
+                    {
+                        var buffer: [10]PrimitiveType = undefined;
+
+                        // ArrayIndexOutOfBoundsException:
+                        get_array_region(env, array, -1, 10, &buffer);
+                        try testing.expect(env.exception_check() == .jni_true);
+                        env.exception_clear();
+
+                        get_array_region(env, array, 0, 200, &buffer);
+                        try testing.expect(env.exception_check() == .jni_true);
+                        env.exception_clear();
+
+                        // Correct bounds:
+                        get_array_region(env, array, 5, 10, &buffer);
+                        try testing.expect(env.exception_check() == .jni_false);
+
+                        for (&buffer, 0..) |*element, i| {
+                            try testing.expectEqual(cast(i + 5), element.*);
+                            element.* = cast(i);
+                        }
+
+                        // ArrayIndexOutOfBoundsException:
+                        set_array_region(env, array, -1, 10, &buffer);
+                        try testing.expect(env.exception_check() == .jni_true);
+                        env.exception_clear();
+
+                        set_array_region(env, array, 0, 200, &buffer);
+                        try testing.expect(env.exception_check() == .jni_true);
+                        env.exception_clear();
+
+                        // Correct bounds:
+                        set_array_region(env, array, 5, 10, &buffer);
+                    }
+
+                    // Check changes
+                    {
+                        var buffer: [10]PrimitiveType = undefined;
+                        get_array_region(env, array, 5, 10, &buffer);
+                        try testing.expect(env.exception_check() == .jni_false);
+
+                        for (buffer, 0..) |element, i| {
+                            try testing.expectEqual(cast(i), element);
+                        }
+                    }
+
+                    // Critical
+                    {
+                        const critical = env.get_primitive_array_critical(array, null) orelse {
+                            try testing.expect(false);
+                            unreachable;
+                        };
+                        defer env.release_primitive_array_critical(array, critical, .default);
+
+                        const elements: [*]PrimitiveType = @ptrCast(@alignCast(critical));
+                        for (elements[0..@intCast(len)], 0..) |*element, i| {
+                            element.* = cast(i + 10);
+                        }
+                    }
+
+                    // Check changes
+                    {
+                        const critical = env.get_primitive_array_critical(array, null) orelse {
+                            try testing.expect(false);
+                            unreachable;
+                        };
+                        defer env.release_primitive_array_critical(array, critical, .default);
+
+                        const elements: [*]PrimitiveType = @ptrCast(@alignCast(critical));
+                        for (elements[0..@intCast(len)], 0..) |element, i| {
+                            try testing.expectEqual(cast(i + 10), element);
+                        }
+                    }
+                }
+            };
+        }
+    }.ArrayTestType;
+
+    const env: *JNIEnv = get_testing_env();
+
+    try ArrayTest(jni.JBoolean).assert(env);
+    try ArrayTest(jni.JByte).assert(env);
+    try ArrayTest(jni.JChar).assert(env);
+    try ArrayTest(jni.JShort).assert(env);
+    try ArrayTest(jni.JInt).assert(env);
+    try ArrayTest(jni.JLong).assert(env);
+    try ArrayTest(jni.JFloat).assert(env);
+    try ArrayTest(jni.JDouble).assert(env);
+}
+
+const get_testing_env = struct {
+    var init = std.once(jvm_create);
+    var env: *JNIEnv = undefined;
+
+    fn jvm_create() void {
+        var jvm: *jni.JavaVM = undefined;
+        var args = jni.JavaVMInitArgs{
+            .version = jni.jni_version_10,
+            .options_len = 0,
+            .options = null,
+            .ignore_unrecognized = .jni_true,
+        };
+        const jni_result = JavaVM.create_java_vm(&jvm, &env, &args);
+        assert(jni_result == .ok);
+    }
+
+    pub fn get_env() *JNIEnv {
+        init.call();
+        return env;
+    }
+}.get_env;