use jvm::{ClassInstanceRef, JavaError, Result, runtime::JavaLangString};
use rustjava_runtime::classes::java::lang::{Float, String};
use test_utils::test_jvm;
#[tokio::test]
async fn test_float_constructors_and_number_conversions() -> Result<()> {
let jvm = test_jvm().await?;
let value = jvm.new_class("java/lang/Float", "(D)V", (130.75f64,)).await?;
assert_eq!(
jvm.invoke_virtual::<_, f32>(&value, &value.class_definition().name(), "floatValue", "()F", ())
.await?,
130.75
);
assert_eq!(
jvm.invoke_virtual::<_, f64>(&value, &value.class_definition().name(), "doubleValue", "()D", ())
.await?,
130.75
);
assert_eq!(
jvm.invoke_virtual::<_, i32>(&value, &value.class_definition().name(), "intValue", "()I", ())
.await?,
130
);
assert_eq!(
jvm.invoke_virtual::<_, i64>(&value, &value.class_definition().name(), "longValue", "()J", ())
.await?,
130
);
assert_eq!(
jvm.invoke_virtual::<_, i8>(&value, &value.class_definition().name(), "byteValue", "()B", ())
.await?,
-126
);
assert_eq!(
jvm.invoke_virtual::<_, i16>(&value, &value.class_definition().name(), "shortValue", "()S", ())
.await?,
130
);
let text = JavaLangString::from_rust_string(&jvm, "-3.5").await?;
let from_string = jvm.new_class("java/lang/Float", "(Ljava/lang/String;)V", (text,)).await?;
assert_eq!(
jvm.invoke_virtual::<_, f32>(&from_string, &from_string.class_definition().name(), "floatValue", "()F", ())
.await?,
-3.5
);
Ok(())
}
#[tokio::test]
async fn test_float_parse_value_of_and_format() -> Result<()> {
let jvm = test_jvm().await?;
for (text, expected) in [(" \t-1.25e2F\n", -125.0), (".5d", 0.5), ("+42.", 42.0)] {
let text = JavaLangString::from_rust_string(&jvm, text).await?;
let parsed: f32 = jvm
.invoke_static("java/lang/Float", "parseFloat", "(Ljava/lang/String;)F", (text,))
.await?;
assert_eq!(parsed, expected);
}
for suffix in ['f', 'F', 'd', 'D'] {
let text = JavaLangString::from_rust_string(&jvm, &format!("1.5{suffix}")).await?;
let parsed: f32 = jvm
.invoke_static("java/lang/Float", "parseFloat", "(Ljava/lang/String;)F", (text,))
.await?;
assert_eq!(parsed, 1.5);
}
let infinity = JavaLangString::from_rust_string(&jvm, "+Infinity").await?;
let infinity: f32 = jvm
.invoke_static("java/lang/Float", "parseFloat", "(Ljava/lang/String;)F", (infinity,))
.await?;
assert_eq!(infinity, f32::INFINITY);
let nan = JavaLangString::from_rust_string(&jvm, "-NaN").await?;
let nan: ClassInstanceRef<Float> = jvm
.invoke_static("java/lang/Float", "valueOf", "(Ljava/lang/String;)Ljava/lang/Float;", (nan,))
.await?;
assert!(jvm.invoke_virtual::<_, bool>(&nan, "java/lang/Float", "isNaN", "()Z", ()).await?);
for (value, expected) in [(12.0f32, "12.0"), (-0.0, "-0.0"), (10_000_000.0, "1.0E7"), (0.000_125, "1.25E-4")] {
let text: ClassInstanceRef<String> = jvm
.invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
.await?;
assert_eq!(JavaLangString::to_rust_string(&jvm, &text).await?, expected);
}
for malformed in ["", "nan", "Infinityf", "1e", ".", "1_0", "0x1.0p0", "1.0 ff"] {
let malformed = JavaLangString::from_rust_string(&jvm, malformed).await?;
let result: Result<f32> = jvm
.invoke_static("java/lang/Float", "parseFloat", "(Ljava/lang/String;)F", (malformed,))
.await;
let Err(JavaError::JavaException(exception)) = result else {
panic!("Float.parseFloat must reject malformed input");
};
assert!(jvm.is_instance(&*exception, "java/lang/NumberFormatException"));
}
let null_result: Result<f32> = jvm.invoke_static("java/lang/Float", "parseFloat", "(Ljava/lang/String;)F", (None,)).await;
let Err(JavaError::JavaException(exception)) = null_result else {
panic!("Float.parseFloat(null) must throw NullPointerException");
};
assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));
for (value, expected) in [(f32::from_bits(1), "1.4E-45"), (f32::from_bits(0x8000_0001), "-1.4E-45")] {
let text: ClassInstanceRef<String> = jvm
.invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
.await?;
assert_eq!(JavaLangString::to_rust_string(&jvm, &text).await?, expected);
}
let min = JavaLangString::from_rust_string(&jvm, "1.4e-45").await?;
assert_eq!(
jvm.invoke_static::<_, f32>("java/lang/Float", "parseFloat", "(Ljava/lang/String;)F", (min,))
.await?
.to_bits(),
1
);
let overflow = JavaLangString::from_rust_string(&jvm, "1e1000").await?;
assert_eq!(
jvm.invoke_static::<_, f32>("java/lang/Float", "parseFloat", "(Ljava/lang/String;)F", (overflow,))
.await?,
f32::INFINITY
);
let underflow = JavaLangString::from_rust_string(&jvm, "-1e-1000").await?;
assert_eq!(
jvm.invoke_static::<_, f32>("java/lang/Float", "parseFloat", "(Ljava/lang/String;)F", (underflow,))
.await?
.to_bits(),
(-0.0f32).to_bits()
);
Ok(())
}
#[tokio::test]
async fn test_float_bits_equality_hash_and_comparison() -> Result<()> {
let jvm = test_jvm().await?;
let payload_nan_a: f32 = jvm.invoke_static("java/lang/Float", "intBitsToFloat", "(I)F", (0x7fc0_0001i32,)).await?;
let payload_nan_b: f32 = jvm.invoke_static("java/lang/Float", "intBitsToFloat", "(I)F", (0x7fff_ffffi32,)).await?;
assert_eq!(
jvm.invoke_static::<_, i32>("java/lang/Float", "floatToIntBits", "(F)I", (payload_nan_a,))
.await?,
0x7fc0_0000
);
let raw = (-12.5f32).to_bits() as i32;
let round_trip: f32 = jvm.invoke_static("java/lang/Float", "intBitsToFloat", "(I)F", (raw,)).await?;
assert_eq!(
jvm.invoke_static::<_, i32>("java/lang/Float", "floatToIntBits", "(F)I", (round_trip,))
.await?,
raw
);
let nan_a = jvm.new_class("java/lang/Float", "(F)V", (payload_nan_a,)).await?;
let nan_b = jvm.new_class("java/lang/Float", "(F)V", (payload_nan_b,)).await?;
assert!(
jvm.invoke_virtual::<_, bool>(
&nan_a,
&nan_a.class_definition().name(),
"equals",
"(Ljava/lang/Object;)Z",
(nan_b.clone(),)
)
.await?
);
assert_eq!(
jvm.invoke_virtual::<_, i32>(&nan_a, &nan_a.class_definition().name(), "hashCode", "()I", ())
.await?,
0x7fc0_0000
);
assert_eq!(
jvm.invoke_virtual::<_, i32>(&nan_a, &nan_a.class_definition().name(), "compareTo", "(Ljava/lang/Float;)I", (nan_b,))
.await?,
0
);
let negative_zero = jvm.new_class("java/lang/Float", "(F)V", (-0.0f32,)).await?;
let positive_zero = jvm.new_class("java/lang/Float", "(F)V", (0.0f32,)).await?;
assert!(
!jvm.invoke_virtual::<_, bool>(
&negative_zero,
&negative_zero.class_definition().name(),
"equals",
"(Ljava/lang/Object;)Z",
(positive_zero.clone(),)
)
.await?
);
assert_eq!(
jvm.invoke_virtual::<_, i32>(
&negative_zero,
&negative_zero.class_definition().name(),
"compareTo",
"(Ljava/lang/Float;)I",
(positive_zero.clone(),),
)
.await?,
-1
);
assert_eq!(
jvm.invoke_virtual::<_, i32>(
&negative_zero,
&negative_zero.class_definition().name(),
"compareTo",
"(Ljava/lang/Object;)I",
(positive_zero,)
)
.await?,
-1
);
assert_eq!(
jvm.invoke_virtual::<_, i32>(&negative_zero, &negative_zero.class_definition().name(), "hashCode", "()I", ())
.await?,
i32::MIN
);
assert_eq!(
jvm.invoke_virtual::<_, i32>(
&jvm.new_class("java/lang/Float", "(F)V", (0.0f32,)).await?,
&jvm.new_class("java/lang/Float", "(F)V", (0.0f32,)).await?.class_definition().name(),
"hashCode",
"()I",
(),
)
.await?,
0
);
let infinity = jvm.new_class("java/lang/Float", "(F)V", (f32::INFINITY,)).await?;
assert_eq!(
jvm.invoke_virtual::<_, i32>(&nan_a, &nan_a.class_definition().name(), "compareTo", "(Ljava/lang/Float;)I", (infinity,))
.await?,
1
);
let typed_null: Result<i32> = jvm
.invoke_virtual(
&negative_zero,
&negative_zero.class_definition().name(),
"compareTo",
"(Ljava/lang/Float;)I",
(None,),
)
.await;
let Err(JavaError::JavaException(exception)) = typed_null else {
panic!("Float typed compare null must throw NPE");
};
assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));
let raw_null: Result<i32> = jvm
.invoke_virtual(
&negative_zero,
&negative_zero.class_definition().name(),
"compareTo",
"(Ljava/lang/Object;)I",
(None,),
)
.await;
let Err(JavaError::JavaException(exception)) = raw_null else {
panic!("Float raw compare null must throw NPE");
};
assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));
let object = jvm.new_class("java/lang/Object", "()V", ()).await?;
let wrong_type: Result<i32> = jvm
.invoke_virtual(
&negative_zero,
&negative_zero.class_definition().name(),
"compareTo",
"(Ljava/lang/Object;)I",
(object,),
)
.await;
let Err(JavaError::JavaException(exception)) = wrong_type else {
panic!("Float raw compare wrong type must throw CCE");
};
assert!(jvm.is_instance(&*exception, "java/lang/ClassCastException"));
for (value, int_value, long_value) in [
(f32::NAN, 0, 0i64),
(f32::INFINITY, i32::MAX, i64::MAX),
(f32::NEG_INFINITY, i32::MIN, i64::MIN),
] {
let wrapper = jvm.new_class("java/lang/Float", "(F)V", (value,)).await?;
assert_eq!(
jvm.invoke_virtual::<_, i32>(&wrapper, &wrapper.class_definition().name(), "intValue", "()I", ())
.await?,
int_value
);
assert_eq!(
jvm.invoke_virtual::<_, i64>(&wrapper, &wrapper.class_definition().name(), "longValue", "()J", ())
.await?,
long_value
);
}
Ok(())
}
#[tokio::test]
async fn test_float_constants_type_and_predicates() -> Result<()> {
let jvm = test_jvm().await?;
assert_eq!(
jvm.get_static_field::<f32>("java/lang/Float", "POSITIVE_INFINITY", "F").await?,
f32::INFINITY
);
assert_eq!(
jvm.get_static_field::<f32>("java/lang/Float", "NEGATIVE_INFINITY", "F").await?,
f32::NEG_INFINITY
);
assert!(jvm.get_static_field::<f32>("java/lang/Float", "NaN", "F").await?.is_nan());
assert_eq!(jvm.get_static_field::<f32>("java/lang/Float", "MAX_VALUE", "F").await?, f32::MAX);
assert_eq!(jvm.get_static_field::<f32>("java/lang/Float", "MIN_VALUE", "F").await?.to_bits(), 1);
assert!(jvm.invoke_static::<_, bool>("java/lang/Float", "isNaN", "(F)Z", (f32::NAN,)).await?);
assert!(
jvm.invoke_static::<_, bool>("java/lang/Float", "isInfinite", "(F)Z", (f32::NEG_INFINITY,))
.await?
);
let typ = jvm.get_static_field("java/lang/Float", "TYPE", "Ljava/lang/Class;").await?;
let name: ClassInstanceRef<String> = jvm
.invoke_virtual(&typ, &typ.class_definition().name(), "getName", "()Ljava/lang/String;", ())
.await?;
assert_eq!(JavaLangString::to_rust_string(&jvm, &name).await?, "float");
assert!(
jvm.invoke_virtual::<_, bool>(&typ, &typ.class_definition().name(), "isPrimitive", "()Z", ())
.await?
);
Ok(())
}