diff --git a/.github/workflows/stable.yml b/.github/workflows/stable.yml index 78387f0..323f329 100644 --- a/.github/workflows/stable.yml +++ b/.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: diff --git a/Cargo.toml b/Cargo.toml index aa2feff..4171f74 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,5 +21,5 @@ lax_deserialize = ["serde"] default = ["std"] std = [] -[workspace] -members = ["ext_tests"] +[dev-dependencies] +serde_test = "1.0" diff --git a/ext_tests/Cargo.toml b/ext_tests/Cargo.toml deleted file mode 100644 index f02dcea..0000000 --- a/ext_tests/Cargo.toml +++ /dev/null @@ -1,17 +0,0 @@ -[package] -name = "js_int_ext_tests" -version = "0.1.0" -authors = ["Jonas Platte "] -edition = "2018" -publish = false - -[dependencies] -serde_json = "1.0" -serde = "1.0" - -[dependencies.js_int] -path = "../" -features = ["serde"] - -[features] -lax_deserialize = ["js_int/lax_deserialize", "serde_json/float_roundtrip"] diff --git a/ext_tests/README.md b/ext_tests/README.md deleted file mode 100644 index 780cdfb..0000000 --- a/ext_tests/README.md +++ /dev/null @@ -1,6 +0,0 @@ -Due to [cargo issue #1796](https://github.com/rust-lang/cargo/issues/1796), we can not depend on -`serde_json` as a `dev-dependency` in `js_int` without breaking `no_std` compatibility, because -`serde_json` isn't `no_std`-compatible (because of that same cargo bug – see -[serde_json PR #516](https://github.com/serde-rs/json/pull/516)). - -Thus, the `serde` tests live in this separate crate. diff --git a/ext_tests/src/lib.rs b/ext_tests/src/lib.rs deleted file mode 100644 index b239d32..0000000 --- a/ext_tests/src/lib.rs +++ /dev/null @@ -1,103 +0,0 @@ -#[cfg(test)] -mod tests { - use serde::{de::IntoDeserializer, Deserialize}; - use serde_json::{from_str as from_json_str, to_string as to_json_string}; - - use js_int::{int, uint, Int, UInt}; - - #[test] - fn serialize_int() { - assert_eq!(to_json_string(&int!(100)).unwrap(), "100"); - assert_eq!(to_json_string(&int!(0)).unwrap(), "0"); - assert_eq!(to_json_string(&int!(-100)).unwrap(), "-100"); - } - - #[test] - fn deserialize_int() { - assert_eq!(from_json_str::("100").unwrap(), int!(100)); - assert_eq!(from_json_str::("0").unwrap(), int!(0)); - assert_eq!(from_json_str::("-100").unwrap(), int!(-100)); - assert_eq!(from_json_str::("-9007199254740991").unwrap(), Int::MIN); - assert_eq!(from_json_str::("9007199254740991").unwrap(), Int::MAX); - assert!(from_json_str::("9007199254740992").is_err()); - assert!(from_json_str::("-9007199254740992").is_err()); - } - - #[test] - fn serialize_uint() { - assert_eq!(to_json_string(&uint!(100)).unwrap(), "100"); - assert_eq!(to_json_string(&uint!(0)).unwrap(), "0"); - } - - #[test] - fn deserialize_uint() { - assert_eq!(from_json_str::("100").unwrap(), uint!(100)); - assert_eq!(from_json_str::("0").unwrap(), uint!(0)); - assert_eq!(from_json_str::("9007199254740991").unwrap(), UInt::MAX); - assert!(from_json_str::("9007199254740992").is_err()); - } - - #[test] - #[cfg_attr(feature = "lax_deserialize", ignore)] - fn strict_deserialize_int() { - assert!(from_json_str::("-10.0").is_err()); - assert!(from_json_str::("-0.0").is_err()); - assert!(from_json_str::("0.5").is_err()); - assert!(from_json_str::("1.0").is_err()); - assert!(from_json_str::("9007199254740991.0").is_err()); - assert!(from_json_str::("9007199254740991.49").is_err()); - assert!(from_json_str::("9007199254740992.0").is_err()); - } - - #[test] - #[cfg_attr(feature = "lax_deserialize", ignore)] - fn strict_deserialize_uint() { - assert!(from_json_str::("0.5").is_err()); - assert!(from_json_str::("1.0").is_err()); - assert!(from_json_str::("9007199254740991.0").is_err()); - assert!(from_json_str::("9007199254740991.49").is_err()); - assert!(from_json_str::("9007199254740992.0").is_err()); - } - - #[test] - #[cfg_attr(not(feature = "lax_deserialize"), ignore)] - fn lax_deserialize_int() { - assert_eq!(from_json_str::("-10.0").unwrap(), int!(-10)); - assert_eq!(from_json_str::("-0.0").unwrap(), int!(0)); - assert_eq!(from_json_str::("0.5").unwrap(), int!(0)); - assert_eq!(from_json_str::("1.0").unwrap(), int!(1)); - assert_eq!(from_json_str::("9007199254740991.0").unwrap(), Int::MAX); - assert_eq!(from_json_str::("9007199254740991.49").unwrap(), Int::MAX); - assert!(from_json_str::("9007199254740992.0").is_err()); - - assert!(deserialize_int_from(f64::NAN).is_err()); - assert!(deserialize_int_from(f64::INFINITY).is_err()); - assert!(deserialize_int_from(f64::NEG_INFINITY).is_err()); - } - - #[test] - #[cfg_attr(not(feature = "lax_deserialize"), ignore)] - fn lax_deserialize_uint() { - assert_eq!(from_json_str::("0.5").unwrap(), uint!(0)); - assert_eq!(from_json_str::("1.0").unwrap(), uint!(1)); - assert_eq!(from_json_str::("9007199254740991.0").unwrap(), UInt::MAX); - assert_eq!(from_json_str::("9007199254740991.49").unwrap(), UInt::MAX); - assert!(from_json_str::("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_int_from<'de, Value: IntoDeserializer<'de>>( - value: Value, - ) -> Result { - Int::deserialize(value.into_deserializer()) - } - - fn deserialize_uint_from<'de, Value: IntoDeserializer<'de>>( - value: Value, - ) -> Result { - UInt::deserialize(value.into_deserializer()) - } -} diff --git a/tests/int.rs b/tests/int.rs new file mode 100644 index 0000000..188ad54 --- /dev/null +++ b/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::deserialize(value.into_deserializer()) +} diff --git a/tests/uint.rs b/tests/uint.rs new file mode 100644 index 0000000..64e7d36 --- /dev/null +++ b/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::deserialize(value.into_deserializer()) +}