Add some math methods

Author: dlunch

java_runtime/src/classes/java/lang/math.rs

@@ -18,16 +18,20 @@ impl Math {
             methods: vec![
                 JavaMethodProto::new("abs", "(I)I", Self::abs, MethodAccessFlags::STATIC),
                 JavaMethodProto::new("abs", "(J)J", Self::abs_long, MethodAccessFlags::STATIC),
+                JavaMethodProto::new("abs", "(F)F", Self::abs_float, MethodAccessFlags::STATIC),
+                JavaMethodProto::new("abs", "(D)D", Self::abs_double, MethodAccessFlags::STATIC),
                 JavaMethodProto::new("max", "(II)I", Self::max, MethodAccessFlags::STATIC),
+                JavaMethodProto::new("max", "(JJ)J", Self::max_long, MethodAccessFlags::STATIC),
                 JavaMethodProto::new("min", "(II)I", Self::min, MethodAccessFlags::STATIC),
+                JavaMethodProto::new("min", "(JJ)J", Self::min_long, MethodAccessFlags::STATIC),
             ],
             fields: vec![],
             access_flags: Default::default(),
         }
     }
 
     async fn abs(_: &Jvm, _: &mut RuntimeContext, x: i32) -> Result<i32> {
-        tracing::debug!("java.lang.Math::abs({:?})", x);
+        tracing::debug!("java.lang.Math::abs({x:?})");
 
         Ok(x.abs())
     }
@@ -38,14 +42,38 @@ impl Math {
         Ok(x.abs())
     }
 
+    async fn abs_float(_: &Jvm, _: &mut RuntimeContext, x: f32) -> Result<f32> {
+        tracing::debug!("java.lang.Math::abs({x:?})");
+
+        Ok(x.abs())
+    }
+
+    async fn abs_double(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
+        tracing::debug!("java.lang.Math::abs({x:?})");
+
+        Ok(x.abs())
+    }
+
     async fn max(_: &Jvm, _: &mut RuntimeContext, x: i32, y: i32) -> Result<i32> {
-        tracing::debug!("java.lang.Math::max({:?}, {:?})", x, y);
+        tracing::debug!("java.lang.Math::max({x:?}, {y:?})");
+
+        Ok(x.max(y))
+    }
+
+    async fn max_long(_: &Jvm, _: &mut RuntimeContext, x: i64, y: i64) -> Result<i64> {
+        tracing::debug!("java.lang.Math::max({x:?}, {y:?})");
 
         Ok(x.max(y))
     }
 
     async fn min(_: &Jvm, _: &mut RuntimeContext, x: i32, y: i32) -> Result<i32> {
-        tracing::debug!("java.lang.Math::min({:?}, {:?})", x, y);
+        tracing::debug!("java.lang.Math::min({x:?}, {y:?})");
+
+        Ok(x.min(y))
+    }
+
+    async fn min_long(_: &Jvm, _: &mut RuntimeContext, x: i64, y: i64) -> Result<i64> {
+        tracing::debug!("java.lang.Math::min({x:?}, {y:?})");
 
         Ok(x.min(y))
     }

java_runtime/tests/classes/java/lang/test_math.rs

@@ -9,5 +9,27 @@ async fn test_abs() -> Result<()> {
     assert_eq!(42i32, jvm.invoke_static("java/lang/Math", "abs", "(I)I", (42,)).await?);
     assert_eq!(42i32, jvm.invoke_static("java/lang/Math", "abs", "(I)I", (-42,)).await?);
 
+    assert_eq!(42i64, jvm.invoke_static("java/lang/Math", "abs", "(J)J", (42i64,)).await?);
+    assert_eq!(42i64, jvm.invoke_static("java/lang/Math", "abs", "(J)J", (-42i64,)).await?);
+
+    assert_eq!(3.15f32, jvm.invoke_static("java/lang/Math", "abs", "(F)F", (3.15f32,)).await?);
+    assert_eq!(3.15f32, jvm.invoke_static("java/lang/Math", "abs", "(F)F", (-3.15f32,)).await?);
+
+    assert_eq!(2.818f64, jvm.invoke_static("java/lang/Math", "abs", "(D)D", (2.818f64,)).await?);
+    assert_eq!(2.818f64, jvm.invoke_static("java/lang/Math", "abs", "(D)D", (-2.818f64,)).await?);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_min_max() -> Result<()> {
+    let jvm = test_jvm().await?;
+
+    assert_eq!(10i32, jvm.invoke_static("java/lang/Math", "max", "(II)I", (10, 5)).await?);
+    assert_eq!(5i32, jvm.invoke_static("java/lang/Math", "min", "(II)I", (10, 5)).await?);
+
+    assert_eq!(20i64, jvm.invoke_static("java/lang/Math", "max", "(JJ)J", (20i64, 15i64)).await?);
+    assert_eq!(15i64, jvm.invoke_static("java/lang/Math", "min", "(JJ)J", (20i64, 15i64)).await?);
+
     Ok(())
 }