Java: Support most RESP3 types

java/client/src/test/java/glide/ffi/FfiTest.java

@@ -1,10 +1,9 @@
 package glide.ffi;
 
-import static java.lang.Math.toIntExact;
 import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import glide.ffi.resolvers.RedisValueResolver;
@@ -32,7 +31,7 @@ public class FfiTest {
 
   public static native long createLeakedLongArray(long[] value);
 
-  public static native long createLeakedMap();
+  public static native long createLeakedMap(long[] keys, long[] values);
 
   public static native long createLeakedDouble(double value);
 
@@ -65,44 +64,17 @@ public void redisValueToJavaValue_Okay() {
   }
 
   @ParameterizedTest
-  @ValueSource(longs = {0L, 100L, 774L})
+  @ValueSource(longs = {0L, 100L, 774L, Integer.MAX_VALUE + 1, Integer.MIN_VALUE - 1})
   public void redisValueToJavaValue_Int(Long input) {
     long ptr = FfiTest.createLeakedInt(input);
     Object longValue = RedisValueResolver.valueFromPointer(ptr);
+    assertTrue(longValue instanceof Long);
     assertEquals(input, longValue);
   }
 
   @Test
-  public void redisValueToJavaValue_CastToIntegerMax() {
-    long ptr = FfiTest.createLeakedInt(Integer.MAX_VALUE);
-    Object longValue = RedisValueResolver.valueFromPointer(ptr);
-    toIntExact((Long) longValue);
-  }
-
-  @Test
-  public void redisValueToJavaValue_CastToIntegerTooLarge() {
-    long ptr = FfiTest.createLeakedInt(((long) Integer.MAX_VALUE) + 1);
-    Object longValue = RedisValueResolver.valueFromPointer(ptr);
-    assertThrows(ArithmeticException.class, () -> toIntExact((Long) longValue));
-  }
-
-  @Test
-  public void redisValueToJavaValue_CastToIntegerMin() {
-    long ptr = FfiTest.createLeakedInt(Integer.MIN_VALUE);
-    Object longValue = RedisValueResolver.valueFromPointer(ptr);
-    toIntExact((Long) longValue);
-  }
-
-  @Test
-  public void redisValueToJavaValue_CastToIntegerTooSmall() {
-    long ptr = FfiTest.createLeakedInt(((long) Integer.MIN_VALUE) - 1);
-    Object longValue = RedisValueResolver.valueFromPointer(ptr);
-    assertThrows(ArithmeticException.class, () -> toIntExact((Long) longValue));
-  }
-
-  @ParameterizedTest
-  @ValueSource(strings = {"hello", "cat", "dog"})
-  public void redisValueToJavaValue_BulkString(String input) {
+  public void redisValueToJavaValue_BulkString() {
+    String input = "😀\n💎\n🗿";
     byte[] bulkString = input.getBytes();
     long ptr = FfiTest.createLeakedBulkString(bulkString);
     Object bulkStringValue = RedisValueResolver.valueFromPointer(ptr);
@@ -116,19 +88,21 @@ public void redisValueToJavaValue_Array() {
     Object longArrayValue = RedisValueResolver.valueFromPointer(ptr);
     assertTrue(longArrayValue instanceof Object[]);
     Object[] result = (Object[]) longArrayValue;
-    assertAll(
-        () -> assertEquals(1L, result[0]),
-        () -> assertEquals(2L, result[1]),
-        () -> assertEquals(3L, result[2]));
+    assertArrayEquals(new Object[] {1L, 2L, 3L}, result);
   }
 
   @Test
   public void redisValueToJavaValue_Map() {
-    long ptr = FfiTest.createLeakedMap();
+    long[] keys = {12L, 14L, 23L};
+    long[] values = {1L, 2L, 3L};
+    long ptr = FfiTest.createLeakedMap(keys, values);
     Object mapValue = RedisValueResolver.valueFromPointer(ptr);
     assertTrue(mapValue instanceof HashMap);
     HashMap<Object, Object> result = (HashMap<Object, Object>) mapValue;
-    assertAll(() -> assertEquals(2L, result.get(1L)), () -> assertEquals("hi", result.get(3L)));
+    assertAll(
+        () -> assertEquals(1L, result.get(12L)),
+        () -> assertEquals(2L, result.get(14L)),
+        () -> assertEquals(3L, result.get(23L)));
   }
 
   @ParameterizedTest

java/src/ffi_test.rs

@@ -1,4 +1,8 @@
-use jni::{objects::JClass, sys::jlong, JNIEnv};
+use jni::{
+    objects::{JClass, JLongArray},
+    sys::jlong,
+    JNIEnv,
+};
 use redis::Value;
 
 #[no_mangle]
@@ -56,29 +60,23 @@ pub extern "system" fn Java_glide_ffi_FfiTest_createLeakedBulkString<'local>(
 pub extern "system" fn Java_glide_ffi_FfiTest_createLeakedLongArray<'local>(
     mut env: JNIEnv<'local>,
     _class: JClass<'local>,
-    value: jni::objects::JLongArray<'local>,
+    value: JLongArray<'local>,
 ) -> jlong {
-    use jni::objects::ReleaseMode;
-    let value = unsafe {
-        env.get_array_elements(&value, ReleaseMode::NoCopyBack)
-            .unwrap()
-    };
-    let array = value
-        .iter()
-        .map(|val| Value::Int(*val))
-        .collect::<Vec<Value>>();
+    let array = java_long_array_to_value(&mut env, &value);
     let redis_value = Value::Array(array);
     Box::leak(Box::new(redis_value)) as *mut Value as jlong
 }
 
 #[no_mangle]
 pub extern "system" fn Java_glide_ffi_FfiTest_createLeakedMap<'local>(
-    _env: JNIEnv<'local>,
+    mut env: JNIEnv<'local>,
     _class: JClass<'local>,
+    keys: JLongArray<'local>,
+    values: JLongArray<'local>,
 ) -> jlong {
-    let mut map: Vec<(Value, Value)> = Vec::new();
-    map.push((Value::Int(1i64), Value::Int(2i64)));
-    map.push((Value::Int(3i64), Value::SimpleString("hi".to_string())));
+    let keys_vec = java_long_array_to_value(&mut env, &keys);
+    let values_vec = java_long_array_to_value(&mut env, &values);
+    let map: Vec<(Value, Value)> = keys_vec.into_iter().zip(values_vec).collect();
     let redis_value = Value::Map(map);
     Box::leak(Box::new(redis_value)) as *mut Value as jlong
 }
@@ -122,17 +120,24 @@ pub extern "system" fn Java_glide_ffi_FfiTest_createLeakedVerbatimString<'local>
 pub extern "system" fn Java_glide_ffi_FfiTest_createLeakedLongSet<'local>(
     mut env: JNIEnv<'local>,
     _class: JClass<'local>,
-    value: jni::objects::JLongArray<'local>,
+    value: JLongArray<'local>,
 ) -> jlong {
+    let set = java_long_array_to_value(&mut env, &value);
+    let redis_value = Value::Set(set);
+    Box::leak(Box::new(redis_value)) as *mut Value as jlong
+}
+
+fn java_long_array_to_value<'local>(
+    env: &mut JNIEnv<'local>,
+    array: &JLongArray<'local>,
+) -> Vec<Value> {
     use jni::objects::ReleaseMode;
-    let value = unsafe {
-        env.get_array_elements(&value, ReleaseMode::NoCopyBack)
+    let elements = unsafe {
+        env.get_array_elements(array, ReleaseMode::NoCopyBack)
             .unwrap()
     };
-    let set = value
+    elements
         .iter()
-        .map(|val| Value::Int(*val))
-        .collect::<Vec<Value>>();
-    let redis_value = Value::Set(set);
-    Box::leak(Box::new(redis_value)) as *mut Value as jlong
+        .map(|value| Value::Int(*value))
+        .collect::<Vec<Value>>()
 }