Use postcard instead of bincode in tests

CHANGELOG.md

@@ -18,6 +18,7 @@ You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.
 - Replace fn `TryRngCore::read_adapter(..) -> RngReadAdapter` with simpler struct `RngReader` (#1669)
 - Remove fns `SeedableRng::from_os_rng`, `try_from_os_rng` (#1674)
 - Remove `Clone` support for `StdRng`, `ReseedingRng` (#1677)
+- Use `postcard` instead of `bincode` to test the serde feature (#1693)
 
 ### Additions
 - Add fns `IndexedRandom::choose_iter`, `choose_weighted_iter` (#1632)

Cargo.toml

@@ -82,6 +82,6 @@ getrandom = { version = "0.3.0", optional = true }
 [dev-dependencies]
 rand_pcg = { path = "rand_pcg", version = "0.10.0-rc.1" }
 # Only to test serde
-bincode = "1.2.1"
+postcard = {version = "1.1.3", default-features = false, features = ["alloc"]}
 rayon = "1.7"
 serde_json = "1.0.140"

rand_pcg/CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changes
 - Use Edition 2024 and MSRV 1.85 (#1653)
 - Remove feature `os_rng` (#1674)
+- Use `postcard` instead of `bincode` to test the serde feature (#1693)
 
 ## [0.9.0] - 2025-01-27
 ### Dependencies and features

rand_pcg/Cargo.toml

@@ -29,5 +29,4 @@ serde = { version = "1", features = ["derive"], optional = true }
 [dev-dependencies]
 # This is for testing serde, unfortunately we can't specify feature-gated dev
 # deps yet, see: https://github.com/rust-lang/cargo/issues/1596
-# Versions prior to 1.1.4 had incorrect minimal dependencies.
-bincode = { version = "1.1.4" }
+postcard = {version = "1.1.3", default-features = false, features = ["alloc"]}

rand_pcg/tests/lcg128cmdxsm64.rs

@@ -57,19 +57,14 @@ fn test_lcg128cmdxsm64_reference() {
 #[cfg(feature = "serde")]
 #[test]
 fn test_lcg128cmdxsm64_serde() {
-    use bincode;
-    use std::io::{BufReader, BufWriter};
+    use postcard;
 
     let mut rng = Lcg128CmDxsm64::seed_from_u64(0);
 
-    let buf: Vec<u8> = Vec::new();
-    let mut buf = BufWriter::new(buf);
-    bincode::serialize_into(&mut buf, &rng).expect("Could not serialize");
+    let buf = postcard::to_allocvec(&rng).expect("Could not serialize");
 
-    let buf = buf.into_inner().unwrap();
-    let mut read = BufReader::new(&buf[..]);
     let mut deserialized: Lcg128CmDxsm64 =
-        bincode::deserialize_from(&mut read).expect("Could not deserialize");
+        postcard::from_bytes(&buf).expect("Could not deserialize");
 
     for _ in 0..16 {
         assert_eq!(rng.next_u64(), deserialized.next_u64());

rand_pcg/tests/lcg128xsl64.rs

@@ -57,19 +57,13 @@ fn test_lcg128xsl64_reference() {
 #[cfg(feature = "serde")]
 #[test]
 fn test_lcg128xsl64_serde() {
-    use bincode;
-    use std::io::{BufReader, BufWriter};
+    use postcard;
 
     let mut rng = Lcg128Xsl64::seed_from_u64(0);
 
-    let buf: Vec<u8> = Vec::new();
-    let mut buf = BufWriter::new(buf);
-    bincode::serialize_into(&mut buf, &rng).expect("Could not serialize");
+    let buf = postcard::to_allocvec(&rng).expect("Could not serialize");
 
-    let buf = buf.into_inner().unwrap();
-    let mut read = BufReader::new(&buf[..]);
-    let mut deserialized: Lcg128Xsl64 =
-        bincode::deserialize_from(&mut read).expect("Could not deserialize");
+    let mut deserialized: Lcg128Xsl64 = postcard::from_bytes(&buf).expect("Could not deserialize");
 
     for _ in 0..16 {
         assert_eq!(rng.next_u64(), deserialized.next_u64());

rand_pcg/tests/lcg64xsh32.rs

@@ -50,19 +50,12 @@ fn test_lcg64xsh32_reference() {
 #[cfg(feature = "serde")]
 #[test]
 fn test_lcg64xsh32_serde() {
-    use bincode;
-    use std::io::{BufReader, BufWriter};
-
+    use postcard;
     let mut rng = Lcg64Xsh32::seed_from_u64(0);
 
-    let buf: Vec<u8> = Vec::new();
-    let mut buf = BufWriter::new(buf);
-    bincode::serialize_into(&mut buf, &rng).expect("Could not serialize");
+    let buf = postcard::to_allocvec(&rng).expect("Could not serialize");
 
-    let buf = buf.into_inner().unwrap();
-    let mut read = BufReader::new(&buf[..]);
-    let mut deserialized: Lcg64Xsh32 =
-        bincode::deserialize_from(&mut read).expect("Could not deserialize");
+    let mut deserialized: Lcg64Xsh32 = postcard::from_bytes(&buf).expect("Could not deserialize");
 
     for _ in 0..16 {
         assert_eq!(rng.next_u64(), deserialized.next_u64());

rand_pcg/tests/mcg128xsl64.rs

@@ -55,19 +55,13 @@ fn test_mcg128xsl64_reference() {
 #[cfg(feature = "serde")]
 #[test]
 fn test_mcg128xsl64_serde() {
-    use bincode;
-    use std::io::{BufReader, BufWriter};
+    use postcard;
 
     let mut rng = Mcg128Xsl64::seed_from_u64(0);
 
-    let buf: Vec<u8> = Vec::new();
-    let mut buf = BufWriter::new(buf);
-    bincode::serialize_into(&mut buf, &rng).expect("Could not serialize");
+    let buf = postcard::to_allocvec(&rng).expect("Could not serialize");
 
-    let buf = buf.into_inner().unwrap();
-    let mut read = BufReader::new(&buf[..]);
-    let mut deserialized: Mcg128Xsl64 =
-        bincode::deserialize_from(&mut read).expect("Could not deserialize");
+    let mut deserialized: Mcg128Xsl64 = postcard::from_bytes(&buf).expect("Could not deserialize");
 
     for _ in 0..16 {
         assert_eq!(rng.next_u64(), deserialized.next_u64());

src/distr/bernoulli.rs

@@ -173,7 +173,7 @@ mod test {
     fn test_serializing_deserializing_bernoulli() {
         let coin_flip = Bernoulli::new(0.5).unwrap();
         let de_coin_flip: Bernoulli =
-            bincode::deserialize(&bincode::serialize(&coin_flip).unwrap()).unwrap();
+            postcard::from_bytes(&postcard::to_allocvec(&coin_flip).unwrap()).unwrap();
 
         assert_eq!(coin_flip.p_int, de_coin_flip.p_int);
     }

src/distr/uniform.rs

@@ -496,12 +496,12 @@ mod tests {
     fn test_uniform_serialization() {
         let unit_box: Uniform<i32> = Uniform::new(-1, 1).unwrap();
         let de_unit_box: Uniform<i32> =
-            bincode::deserialize(&bincode::serialize(&unit_box).unwrap()).unwrap();
+            postcard::from_bytes(&postcard::to_allocvec(&unit_box).unwrap()).unwrap();
         assert_eq!(unit_box.0, de_unit_box.0);
 
         let unit_box: Uniform<f32> = Uniform::new(-1., 1.).unwrap();
         let de_unit_box: Uniform<f32> =
-            bincode::deserialize(&bincode::serialize(&unit_box).unwrap()).unwrap();
+            postcard::from_bytes(&postcard::to_allocvec(&unit_box).unwrap()).unwrap();
         assert_eq!(unit_box.0, de_unit_box.0);
     }
 

src/distr/uniform_other.rs

@@ -252,7 +252,7 @@ mod tests {
     fn test_serialization_uniform_duration() {
         let distr = UniformDuration::new(Duration::from_secs(10), Duration::from_secs(60)).unwrap();
         let de_distr: UniformDuration =
-            bincode::deserialize(&bincode::serialize(&distr).unwrap()).unwrap();
+            postcard::from_bytes(&postcard::to_allocvec(&distr).unwrap()).unwrap();
         assert_eq!(distr, de_distr);
     }
 

src/distr/weighted/weighted_index.rs

@@ -376,9 +376,9 @@ mod test {
     fn test_weightedindex_serde() {
         let weighted_index = WeightedIndex::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).unwrap();
 
-        let ser_weighted_index = bincode::serialize(&weighted_index).unwrap();
+        let ser_weighted_index = postcard::to_allocvec(&weighted_index).unwrap();
         let de_weighted_index: WeightedIndex<i32> =
-            bincode::deserialize(&ser_weighted_index).unwrap();
+            postcard::from_bytes(&ser_weighted_index).unwrap();
 
         assert_eq!(
             de_weighted_index.cumulative_weights,

src/seq/index.rs

@@ -570,7 +570,7 @@ mod test {
     fn test_serialization_index_vec() {
         let some_index_vec = IndexVec::from(vec![254_u32, 234, 2, 1]);
         let de_some_index_vec: IndexVec =
-            bincode::deserialize(&bincode::serialize(&some_index_vec).unwrap()).unwrap();
+            postcard::from_bytes(&postcard::to_allocvec(&some_index_vec).unwrap()).unwrap();
         assert_eq!(some_index_vec, de_some_index_vec);
     }