Bugfix: lax_deserialize currently accepts deserializing from NaN

.github/workflows/stable.yml

@@ -26,12 +26,16 @@ jobs:
       uses: actions-rs/cargo@v1
       with:
         command: test
-        args: --features std,serde,lax_deserialize
-    - name: Run external tests
+    - name: Run tests (serde)
       uses: actions-rs/cargo@v1
       with:
         command: test
-        args: -p js_int_ext_tests --all-features
+        args: --features serde
+    - name: Run tests (all features)
+      uses: actions-rs/cargo@v1
+      with:
+        command: test
+        args: --all-features
     - name: Run tests (release build)
       uses: actions-rs/cargo@v1
       with:

Cargo.toml

@@ -21,5 +21,5 @@ lax_deserialize = ["serde"]
 default = ["std"]
 std = []
 
-[workspace]
-members = ["ext_tests"]
+[dev-dependencies]
+serde_test = "1.0"

src/int.rs

@@ -582,7 +582,7 @@ impl<'de> Deserialize<'de> for Int {
         {
             let val = f64::deserialize(deserializer)?;
 
-            if val > MAX_SAFE_INT as f64 || val < MIN_SAFE_INT as f64 {
+            if val > MAX_SAFE_INT as f64 || val < MIN_SAFE_INT as f64 || val.is_nan() {
                 Err(D::Error::invalid_value(
                     Unexpected::Float(val),
                     &"a number between -2^53 + 1 and 2^53 - 1",

src/uint.rs

@@ -589,7 +589,7 @@ impl<'de> Deserialize<'de> for UInt {
         {
             let val = f64::deserialize(deserializer)?;
 
-            if val < 0.0 || val > MAX_SAFE_UINT as f64 {
+            if val < 0.0 || val > MAX_SAFE_UINT as f64 || val.is_nan() {
                 Err(D::Error::invalid_value(
                     Unexpected::Float(val),
                     &"a number between 0 and 2^53 - 1",

tests/int.rs

@@ -0,0 +1,64 @@
+#![cfg(feature = "serde")]
+
+use js_int::{int, Int};
+use serde::{de::IntoDeserializer, Deserialize};
+use serde_test::{assert_ser_tokens, Token};
+
+#[test]
+fn serialize_int() {
+    assert_serialize(100);
+    assert_serialize(0);
+    assert_serialize(-100);
+}
+
+fn assert_serialize(number: i32) {
+    assert_ser_tokens(
+        &Int::from(number),
+        &[Token::NewtypeStruct { name: "Int" }, Token::I64(number as _)],
+    )
+}
+
+#[test]
+fn deserialize_int() {
+    assert_eq!(deserialize_from(100).unwrap(), int!(100));
+    assert_eq!(deserialize_from(0).unwrap(), int!(0));
+    assert_eq!(deserialize_from(-100).unwrap(), int!(-100));
+    assert_eq!(deserialize_from(-9007199254740991i64).unwrap(), Int::MIN);
+    assert_eq!(deserialize_from(9007199254740991i64).unwrap(), Int::MAX);
+    assert!(deserialize_from(9007199254740992i64).is_err());
+    assert!(deserialize_from(-9007199254740992i64).is_err());
+}
+
+#[test]
+#[cfg_attr(feature = "lax_deserialize", ignore)]
+fn strict_deserialize_int() {
+    assert!(deserialize_from(-10.0).is_err());
+    assert!(deserialize_from(-0.0).is_err());
+    assert!(deserialize_from(0.5).is_err());
+    assert!(deserialize_from(1.0).is_err());
+    assert!(deserialize_from(9007199254740991.0).is_err());
+    assert!(deserialize_from(9007199254740991.49).is_err());
+    assert!(deserialize_from(9007199254740992.0).is_err());
+}
+
+#[test]
+#[cfg_attr(not(feature = "lax_deserialize"), ignore)]
+fn lax_deserialize_int() {
+    assert_eq!(deserialize_from(-10.0).unwrap(), int!(-10));
+    assert_eq!(deserialize_from(-0.0).unwrap(), int!(0));
+    assert_eq!(deserialize_from(0.5).unwrap(), int!(0));
+    assert_eq!(deserialize_from(1.0).unwrap(), int!(1));
+    assert_eq!(deserialize_from(9007199254740991.0).unwrap(), Int::MAX);
+    assert_eq!(deserialize_from(9007199254740991.49).unwrap(), Int::MAX);
+    assert!(deserialize_from(9007199254740992.0).is_err());
+
+    assert!(deserialize_from(f64::NAN).is_err());
+    assert!(deserialize_from(f64::INFINITY).is_err());
+    assert!(deserialize_from(f64::NEG_INFINITY).is_err());
+}
+
+fn deserialize_from<'de, Value: IntoDeserializer<'de>>(
+    value: Value,
+) -> Result<Int, serde::de::value::Error> {
+    Int::deserialize(value.into_deserializer())
+}

tests/uint.rs

@@ -0,0 +1,56 @@
+#![cfg(feature = "serde")]
+
+use js_int::{uint, UInt};
+use serde::{de::IntoDeserializer, Deserialize};
+use serde_test::{assert_ser_tokens, Token};
+
+#[test]
+fn serialize_uint() {
+    assert_serialize(100);
+    assert_serialize(0);
+}
+
+fn assert_serialize(number: u32) {
+    assert_ser_tokens(
+        &UInt::from(number),
+        &[Token::NewtypeStruct { name: "UInt" }, Token::U64(number as _)],
+    )
+}
+
+#[test]
+fn deserialize_uint() {
+    assert_eq!(deserialize_uint_from(100).unwrap(), uint!(100));
+    assert_eq!(deserialize_uint_from(0).unwrap(), uint!(0));
+    assert_eq!(deserialize_uint_from(9007199254740991i64).unwrap(), UInt::MAX);
+    assert!(deserialize_uint_from(9007199254740992i64).is_err());
+}
+
+#[test]
+#[cfg_attr(feature = "lax_deserialize", ignore)]
+fn strict_deserialize_uint() {
+    assert!(deserialize_uint_from(0.5).is_err());
+    assert!(deserialize_uint_from(1.0).is_err());
+    assert!(deserialize_uint_from(9007199254740991.0).is_err());
+    assert!(deserialize_uint_from(9007199254740991.49).is_err());
+    assert!(deserialize_uint_from(9007199254740992.0).is_err());
+}
+
+#[test]
+#[cfg_attr(not(feature = "lax_deserialize"), ignore)]
+fn lax_deserialize_uint() {
+    assert_eq!(deserialize_uint_from(0.5).unwrap(), uint!(0));
+    assert_eq!(deserialize_uint_from(1.0).unwrap(), uint!(1));
+    assert_eq!(deserialize_uint_from(9007199254740991.0).unwrap(), UInt::MAX);
+    assert_eq!(deserialize_uint_from(9007199254740991.49).unwrap(), UInt::MAX);
+    assert!(deserialize_uint_from(9007199254740992.0).is_err());
+
+    assert!(deserialize_uint_from(f64::NAN).is_err());
+    assert!(deserialize_uint_from(f64::INFINITY).is_err());
+    assert!(deserialize_uint_from(f64::NEG_INFINITY).is_err());
+}
+
+fn deserialize_uint_from<'de, Value: IntoDeserializer<'de>>(
+    value: Value,
+) -> Result<UInt, serde::de::value::Error> {
+    UInt::deserialize(value.into_deserializer())
+}