Merge pull request metno#53 from metno/dependabot/cargo/rand-0.9

dependabot[bot] · web-flow · commit 8320dfdbeebd · 2025-01-28T12:45:59.000Z
diff --git a/hdf5/Cargo.toml b/hdf5/Cargo.toml
@@ -58,7 +58,7 @@ num-complex = { workspace = true }
 parking_lot = "0.12.3"
 paste = "1.0"
 pretty_assertions = "1.4"
-rand = { version = "0.8", features = ["small_rng"] }
+rand = { version = "0.9", features = ["small_rng"] }
 regex = { workspace = true }
 scopeguard = "1.2"
 tempfile = "3.9"
diff --git a/hdf5/tests/common/gen.rs b/hdf5/tests/common/gen.rs
@@ -9,13 +9,13 @@ use hdf5_metno as hdf5;
 use half::f16;
 use ndarray::{ArrayD, SliceInfo, SliceInfoElem};
 use num_complex::Complex;
-use rand::distributions::Standard;
-use rand::distributions::{Alphanumeric, Uniform};
-use rand::prelude::Distribution;
-use rand::prelude::{Rng, SliceRandom};
+use rand::distr::StandardUniform;
+use rand::distr::{Alphanumeric, Uniform};
+use rand::prelude::Rng;
+use rand::prelude::{Distribution, IndexedRandom};
 
 pub fn gen_shape<R: Rng + ?Sized>(rng: &mut R, ndim: usize) -> Vec<usize> {
-    iter::repeat(()).map(|_| rng.gen_range(0..11)).take(ndim).collect()
+    iter::repeat(()).map(|_| rng.random_range(0..11)).take(ndim).collect()
 }
 
 pub fn gen_ascii<R: Rng + ?Sized>(rng: &mut R, len: usize) -> String {
@@ -37,35 +37,36 @@ fn gen_slice_one_dim<R: Rng + ?Sized>(rng: &mut R, shape: usize) -> ndarray::Sli
         return ndarray::SliceInfoElem::Slice { start: 0, end: None, step: 1 };
     }
 
-    if rng.gen_bool(0.1) {
-        ndarray::SliceInfoElem::Index(rng.gen_range(0..shape) as isize)
+    if rng.random_bool(0.1) {
+        ndarray::SliceInfoElem::Index(rng.random_range(0..shape) as isize)
     } else {
-        let start = rng.gen_range(0..shape) as isize;
+        let start = rng.random_range(0..shape) as isize;
 
-        let end = if rng.gen_bool(0.5) {
+        let end = if rng.random_bool(0.5) {
             None
-        } else if rng.gen_bool(0.9) {
-            Some(rng.gen_range(start..shape as isize))
+        } else if rng.random_bool(0.9) {
+            Some(rng.random_range(start as i64..shape as i64))
         } else {
             // Occasionally generate a slice with end < start.
-            Some(rng.gen_range(0..shape as isize))
+            Some(rng.random_range(0..shape as i64))
         };
 
-        let step = if rng.gen_bool(0.9) { 1isize } else { rng.gen_range(1..shape * 2) as isize };
+        let step =
+            if rng.random_bool(0.9) { 1isize } else { rng.random_range(1..shape * 2) as isize };
 
-        ndarray::SliceInfoElem::Slice { start, end, step }
+        ndarray::SliceInfoElem::Slice { start, end: end.map(|x| x as isize), step }
     }
 }
 
 pub trait Gen: Sized + fmt::Debug {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self;
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self;
 }
 
 macro_rules! impl_gen_primitive {
     ($ty:ty) => {
         impl Gen for $ty {
-            fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-                rng.gen()
+            fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+                rng.random()
             }
         }
     };
@@ -75,21 +76,21 @@ macro_rules! impl_gen_primitive {
     };
 }
 
-impl_gen_primitive!(usize, isize, u8, u16, u32, u64, i8, i16, i32, i64, bool, f32, f64);
+impl_gen_primitive!(u8, u16, u32, u64, i8, i16, i32, i64, bool, f32, f64);
 
 macro_rules! impl_gen_tuple {
     ($t:ident) => (
         impl<$t> Gen for ($t,) where $t: Gen {
-            fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-                (<$t as Gen>::gen(rng),)
+            fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+                (<$t as Gen>::random(rng),)
             }
         }
     );
 
     ($t:ident, $($tt:ident),*) => (
         impl<$t, $($tt),*> Gen for ($t, $($tt),*) where $t: Gen, $($tt: Gen),* {
-            fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-                (<$t as Gen>::gen(rng), $(<$tt as Gen>::gen(rng)),*)
+            fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+                (<$t as Gen>::random(rng), $(<$tt as Gen>::random(rng)),*)
             }
         }
         impl_gen_tuple!($($tt),*);
@@ -99,22 +100,22 @@ macro_rules! impl_gen_tuple {
 impl_gen_tuple! { A, B, C, D, E, F, G, H, I, J, K, L }
 
 impl Gen for f16 {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        Self::from_f32(rng.gen())
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        Self::from_f32(rng.random())
     }
 }
 
 impl<T: Debug> Gen for Complex<T>
 where
-    Standard: Distribution<T>,
+    StandardUniform: Distribution<T>,
 {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        Self::new(rng.gen(), rng.gen())
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        Self::new(rng.random(), rng.random())
     }
 }
 
 pub fn gen_vec<R: Rng + ?Sized, T: Gen>(rng: &mut R, size: usize) -> Vec<T> {
-    iter::repeat(()).map(|_| T::gen(rng)).take(size).collect()
+    iter::repeat(()).map(|_| T::random(rng)).take(size).collect()
 }
 
 pub fn gen_arr<T, R>(rng: &mut R, ndim: usize) -> ArrayD<T>
@@ -129,9 +130,9 @@ where
 }
 
 impl<const N: usize> Gen for FixedAscii<N> {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        let len = rng.sample(Uniform::new_inclusive(0, N));
-        let dist = Uniform::new_inclusive(0, 127);
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        let len = rng.sample(Uniform::new_inclusive(0, N).unwrap());
+        let dist = Uniform::new_inclusive(0, 127).unwrap();
         let mut v = Vec::with_capacity(len);
         for _ in 0..len {
             v.push(rng.sample(dist));
@@ -141,11 +142,11 @@ impl<const N: usize> Gen for FixedAscii<N> {
 }
 
 impl<const N: usize> Gen for FixedUnicode<N> {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        let len = rng.sample(Uniform::new_inclusive(0, N));
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        let len = rng.sample(Uniform::new_inclusive(0, N).unwrap());
         let mut s = String::new();
         for _ in 0..len {
-            let c = rng.gen::<char>();
+            let c = rng.random::<char>();
             if c != '\0' {
                 if s.as_bytes().len() + c.len_utf8() >= len {
                     break;
@@ -158,9 +159,9 @@ impl<const N: usize> Gen for FixedUnicode<N> {
 }
 
 impl Gen for VarLenAscii {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        let len = rng.sample(Uniform::new_inclusive(0, 8));
-        let dist = Uniform::new_inclusive(0, 127);
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        let len = rng.sample(Uniform::new_inclusive(0, 8).unwrap());
+        let dist = Uniform::new_inclusive(0, 127).unwrap();
         let mut v = Vec::with_capacity(len);
         for _ in 0..len {
             v.push(rng.sample(dist));
@@ -170,11 +171,11 @@ impl Gen for VarLenAscii {
 }
 
 impl Gen for VarLenUnicode {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        let len = rng.sample(Uniform::new_inclusive(0, 8));
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        let len = rng.sample(Uniform::new_inclusive(0, 8).unwrap());
         let mut s = String::new();
         while s.len() < len {
-            let c = rng.gen::<char>();
+            let c = rng.random::<char>();
             if c != '\0' {
                 s.push(c);
             }
@@ -184,11 +185,11 @@ impl Gen for VarLenUnicode {
 }
 
 impl<T: Gen + Copy> Gen for VarLenArray<T> {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        let len = rng.sample(Uniform::new_inclusive(0, 8));
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        let len = rng.sample(Uniform::new_inclusive(0, 8).unwrap());
         let mut v = Vec::with_capacity(len);
         for _ in 0..len {
-            v.push(Gen::gen(rng));
+            v.push(Gen::random(rng));
         }
         VarLenArray::from_slice(&v)
     }
@@ -202,7 +203,7 @@ pub enum Enum {
 }
 
 impl Gen for Enum {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
         *[Enum::X, Enum::Y].choose(rng).unwrap()
     }
 }
@@ -212,8 +213,8 @@ impl Gen for Enum {
 pub struct TupleStruct(bool, Enum);
 
 impl Gen for TupleStruct {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        TupleStruct(Gen::gen(rng), Gen::gen(rng))
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        TupleStruct(Gen::random(rng), Gen::random(rng))
     }
 }
 
@@ -227,12 +228,12 @@ pub struct FixedStruct {
 }
 
 impl Gen for FixedStruct {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
         FixedStruct {
-            fa: Gen::gen(rng),
-            fu: Gen::gen(rng),
-            tuple: (Gen::gen(rng), Gen::gen(rng), Gen::gen(rng)),
-            array: [Gen::gen(rng), Gen::gen(rng)],
+            fa: Gen::random(rng),
+            fu: Gen::random(rng),
+            tuple: (Gen::random(rng), Gen::random(rng), Gen::random(rng)),
+            array: [Gen::random(rng), Gen::random(rng)],
         }
     }
 }
@@ -246,8 +247,8 @@ pub struct VarLenStruct {
 }
 
 impl Gen for VarLenStruct {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        VarLenStruct { va: Gen::gen(rng), vu: Gen::gen(rng), vla: Gen::gen(rng) }
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        VarLenStruct { va: Gen::random(rng), vu: Gen::random(rng), vla: Gen::random(rng) }
     }
 }
 
@@ -260,8 +261,8 @@ pub struct RenameStruct {
 }
 
 impl Gen for RenameStruct {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        RenameStruct { first: Gen::gen(rng), second: Gen::gen(rng) }
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        RenameStruct { first: Gen::random(rng), second: Gen::random(rng) }
     }
 }
 
@@ -270,8 +271,8 @@ impl Gen for RenameStruct {
 pub struct RenameTupleStruct(#[hdf5(rename = "my_boolean")] bool, #[hdf5(rename = "my_enum")] Enum);
 
 impl Gen for RenameTupleStruct {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
-        RenameTupleStruct(Gen::gen(rng), Gen::gen(rng))
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        RenameTupleStruct(Gen::random(rng), Gen::random(rng))
     }
 }
 
@@ -285,7 +286,7 @@ pub enum RenameEnum {
 }
 
 impl Gen for RenameEnum {
-    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
+    fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
         *[RenameEnum::X, RenameEnum::Y].choose(rng).unwrap()
     }
 }
diff --git a/hdf5/tests/common/util.rs b/hdf5/tests/common/util.rs
@@ -3,7 +3,7 @@ use super::gen::gen_ascii;
 use hdf5_metno as hdf5;
 
 pub fn random_filename() -> String {
-    gen_ascii(&mut rand::thread_rng(), 8)
+    gen_ascii(&mut rand::rng(), 8)
 }
 
 pub fn new_in_memory_file() -> hdf5::Result<hdf5::File> {
diff --git a/hdf5/tests/test_dataset.rs b/hdf5/tests/test_dataset.rs
@@ -194,7 +194,7 @@ fn test_byte_read_seek_impl(ds: &hdf5::Dataset, arr: &ArrayD<u8>, ndim: usize) -
     reader.seek(std::io::SeekFrom::Start(0)).expect("io::Seek failed");
     let mut pos = 0;
     while pos < arr.len() {
-        let chunk_len: usize = rng.gen_range(1..arr.len() + 1);
+        let chunk_len: usize = rng.random_range(1..arr.len() + 1);
         let mut chunk = vec![0u8; chunk_len];
         let n_read = reader.read(&mut chunk).expect("io::Read failed");
         if pos + chunk_len < arr.len() {
@@ -212,15 +212,15 @@ fn test_byte_read_seek_impl(ds: &hdf5::Dataset, arr: &ArrayD<u8>, ndim: usize) -
     assert_eq!(out_bytes.as_slice(), arr.as_slice().unwrap());
 
     // Seek to a random position from start
-    let pos = rng.gen_range(0..arr.len() + 1) as u64;
+    let pos = rng.random_range(0..arr.len() + 1) as u64;
     let seek_pos = reader.seek(SeekFrom::Start(pos)).expect("io::Seek failed") as usize;
     let mut out_bytes = vec![0u8; arr.len() - seek_pos];
     reader.read(&mut out_bytes.as_mut_slice()).expect("io::Read failed");
     assert_eq!(out_bytes.as_slice(), arr.slice(s![seek_pos..]).as_slice().unwrap());
 
     // Seek from current position
     let orig_pos = reader.seek(SeekFrom::Start(pos)).expect("io::Seek failed") as i64;
-    let rel_pos = rng.gen_range(-(arr.len() as i64)..arr.len() as i64 + 1);
+    let rel_pos = rng.random_range(-(orig_pos as i64)..(arr.len() as i64 - orig_pos) + 1);
     let pos_res = reader.seek(SeekFrom::Current(rel_pos));
     if (rel_pos + orig_pos) < 0 {
         assert!(pos_res.is_err()) // We cannot seek before start
@@ -233,7 +233,7 @@ fn test_byte_read_seek_impl(ds: &hdf5::Dataset, arr: &ArrayD<u8>, ndim: usize) -
     }
 
     // Seek to a random position from end
-    let pos = -(rng.gen_range(0..arr.len() + 1) as i64);
+    let pos = -(rng.random_range(0..arr.len() + 1) as i64);
     let seek_pos = reader.seek(SeekFrom::End(pos)).expect("io::Seek failed") as usize;
     assert_eq!(pos, seek_pos as i64 - arr.len() as i64);
     let mut out_bytes = vec![0u8; arr.len() - seek_pos];
@@ -285,7 +285,7 @@ where
                     } else if mode == 2 {
                         test_read_slice(&mut rng, &ds, &arr, ndim)?;
                     } else if mode == 3 {
-                        let default_value = T::gen(&mut rng);
+                        let default_value = T::random(&mut rng);
                         test_write_slice(&mut rng, &ds, &arr, &default_value, ndim)?;
                     }
                 }
@@ -306,8 +306,6 @@ fn test_read_write_primitive() -> hdf5::Result<()> {
     test_read_write::<u16>()?;
     test_read_write::<u32>()?;
     test_read_write::<u64>()?;
-    test_read_write::<isize>()?;
-    test_read_write::<usize>()?;
     test_read_write::<bool>()?;
     test_read_write::<f32>()?;
     test_read_write::<f64>()?;

Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,13 @@ use hdf5_metno as hdf5;`
`9`	`9`	`use half::f16;`
`10`	`10`	`use ndarray::{ArrayD, SliceInfo, SliceInfoElem};`
`11`	`11`	`use num_complex::Complex;`
`12`		`-use rand::distributions::Standard;`
`13`		`-use rand::distributions::{Alphanumeric, Uniform};`
`14`		`-use rand::prelude::Distribution;`
`15`		`-use rand::prelude::{Rng, SliceRandom};`
	`12`	`+use rand::distr::StandardUniform;`
	`13`	`+use rand::distr::{Alphanumeric, Uniform};`
	`14`	`+use rand::prelude::Rng;`
	`15`	`+use rand::prelude::{Distribution, IndexedRandom};`
`16`	`16`
`17`	`17`	`pub fn gen_shape<R: Rng + ?Sized>(rng: &mut R, ndim: usize) -> Vec<usize> {`
`18`		`- iter::repeat(()).map(\|_\| rng.gen_range(0..11)).take(ndim).collect()`
	`18`	`+ iter::repeat(()).map(\|_\| rng.random_range(0..11)).take(ndim).collect()`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`pub fn gen_ascii<R: Rng + ?Sized>(rng: &mut R, len: usize) -> String {`
`@@ -37,35 +37,36 @@ fn gen_slice_one_dim<R: Rng + ?Sized>(rng: &mut R, shape: usize) -> ndarray::Sli`
`37`	`37`	`return ndarray::SliceInfoElem::Slice { start: 0, end: None, step: 1 };`
`38`	`38`	`}`
`39`	`39`
`40`		`- if rng.gen_bool(0.1) {`
`41`		`- ndarray::SliceInfoElem::Index(rng.gen_range(0..shape) as isize)`
	`40`	`+ if rng.random_bool(0.1) {`
	`41`	`+ ndarray::SliceInfoElem::Index(rng.random_range(0..shape) as isize)`
`42`	`42`	`} else {`
`43`		`- let start = rng.gen_range(0..shape) as isize;`
	`43`	`+ let start = rng.random_range(0..shape) as isize;`
`44`	`44`
`45`		`- let end = if rng.gen_bool(0.5) {`
	`45`	`+ let end = if rng.random_bool(0.5) {`
`46`	`46`	`None`
`47`		`- } else if rng.gen_bool(0.9) {`
`48`		`- Some(rng.gen_range(start..shape as isize))`
	`47`	`+ } else if rng.random_bool(0.9) {`
	`48`	`+ Some(rng.random_range(start as i64..shape as i64))`
`49`	`49`	`} else {`
`50`	`50`	`// Occasionally generate a slice with end < start.`
`51`		`- Some(rng.gen_range(0..shape as isize))`
	`51`	`+ Some(rng.random_range(0..shape as i64))`
`52`	`52`	`};`
`53`	`53`
`54`		`- let step = if rng.gen_bool(0.9) { 1isize } else { rng.gen_range(1..shape * 2) as isize };`
	`54`	`+ let step =`
	`55`	`+ if rng.random_bool(0.9) { 1isize } else { rng.random_range(1..shape * 2) as isize };`
`55`	`56`
`56`		`- ndarray::SliceInfoElem::Slice { start, end, step }`
	`57`	`+ ndarray::SliceInfoElem::Slice { start, end: end.map(\|x\| x as isize), step }`
`57`	`58`	`}`
`58`	`59`	`}`
`59`	`60`
`60`	`61`	`pub trait Gen: Sized + fmt::Debug {`
`61`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self;`
	`62`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self;`
`62`	`63`	`}`
`63`	`64`
`64`	`65`	`macro_rules! impl_gen_primitive {`
`65`	`66`	`($ty:ty) => {`
`66`	`67`	`impl Gen for $ty {`
`67`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`68`		`- rng.gen()`
	`68`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`69`	`+ rng.random()`
`69`	`70`	`}`
`70`	`71`	`}`
`71`	`72`	`};`
`@@ -75,21 +76,21 @@ macro_rules! impl_gen_primitive {`
`75`	`76`	`};`
`76`	`77`	`}`
`77`	`78`
`78`		`-impl_gen_primitive!(usize, isize, u8, u16, u32, u64, i8, i16, i32, i64, bool, f32, f64);`
	`79`	`+impl_gen_primitive!(u8, u16, u32, u64, i8, i16, i32, i64, bool, f32, f64);`
`79`	`80`
`80`	`81`	`macro_rules! impl_gen_tuple {`
`81`	`82`	`($t:ident) => (`
`82`	`83`	`impl<$t> Gen for ($t,) where $t: Gen {`
`83`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`84`		`- (<$t as Gen>::gen(rng),)`
	`84`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`85`	`+ (<$t as Gen>::random(rng),)`
`85`	`86`	`}`
`86`	`87`	`}`
`87`	`88`	`);`
`88`	`89`
`89`	`90`	`($t:ident, $($tt:ident),*) => (`
`90`	`91`	`impl<$t, $($tt),> Gen for ($t, $($tt),) where $t: Gen, $($tt: Gen),* {`
`91`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`92`		`- (<$t as Gen>::gen(rng), $(<$tt as Gen>::gen(rng)),*)`
	`92`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`93`	`+ (<$t as Gen>::random(rng), $(<$tt as Gen>::random(rng)),*)`
`93`	`94`	`}`
`94`	`95`	`}`
`95`	`96`	`impl_gen_tuple!($($tt),*);`
`@@ -99,22 +100,22 @@ macro_rules! impl_gen_tuple {`
`99`	`100`	`impl_gen_tuple! { A, B, C, D, E, F, G, H, I, J, K, L }`
`100`	`101`
`101`	`102`	`impl Gen for f16 {`
`102`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`103`		`- Self::from_f32(rng.gen())`
	`103`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`104`	`+ Self::from_f32(rng.random())`
`104`	`105`	`}`
`105`	`106`	`}`
`106`	`107`
`107`	`108`	`impl<T: Debug> Gen for Complex<T>`
`108`	`109`	`where`
`109`		`- Standard: Distribution<T>,`
	`110`	`+ StandardUniform: Distribution<T>,`
`110`	`111`	`{`
`111`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`112`		`- Self::new(rng.gen(), rng.gen())`
	`112`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`113`	`+ Self::new(rng.random(), rng.random())`
`113`	`114`	`}`
`114`	`115`	`}`
`115`	`116`
`116`	`117`	`pub fn gen_vec<R: Rng + ?Sized, T: Gen>(rng: &mut R, size: usize) -> Vec<T> {`
`117`		`- iter::repeat(()).map(\|_\| T::gen(rng)).take(size).collect()`
	`118`	`+ iter::repeat(()).map(\|_\| T::random(rng)).take(size).collect()`
`118`	`119`	`}`
`119`	`120`
`120`	`121`	`pub fn gen_arr<T, R>(rng: &mut R, ndim: usize) -> ArrayD<T>`
`@@ -129,9 +130,9 @@ where`
`129`	`130`	`}`
`130`	`131`
`131`	`132`	`impl<const N: usize> Gen for FixedAscii<N> {`
`132`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`133`		`- let len = rng.sample(Uniform::new_inclusive(0, N));`
`134`		`- let dist = Uniform::new_inclusive(0, 127);`
	`133`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`134`	`+ let len = rng.sample(Uniform::new_inclusive(0, N).unwrap());`
	`135`	`+ let dist = Uniform::new_inclusive(0, 127).unwrap();`
`135`	`136`	`let mut v = Vec::with_capacity(len);`
`136`	`137`	`for _ in 0..len {`
`137`	`138`	`v.push(rng.sample(dist));`
`@@ -141,11 +142,11 @@ impl<const N: usize> Gen for FixedAscii<N> {`
`141`	`142`	`}`
`142`	`143`
`143`	`144`	`impl<const N: usize> Gen for FixedUnicode<N> {`
`144`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`145`		`- let len = rng.sample(Uniform::new_inclusive(0, N));`
	`145`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`146`	`+ let len = rng.sample(Uniform::new_inclusive(0, N).unwrap());`
`146`	`147`	`let mut s = String::new();`
`147`	`148`	`for _ in 0..len {`
`148`		`- let c = rng.gen::<char>();`
	`149`	`+ let c = rng.random::<char>();`
`149`	`150`	`if c != '\0' {`
`150`	`151`	`if s.as_bytes().len() + c.len_utf8() >= len {`
`151`	`152`	`break;`
`@@ -158,9 +159,9 @@ impl<const N: usize> Gen for FixedUnicode<N> {`
`158`	`159`	`}`
`159`	`160`
`160`	`161`	`impl Gen for VarLenAscii {`
`161`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`162`		`- let len = rng.sample(Uniform::new_inclusive(0, 8));`
`163`		`- let dist = Uniform::new_inclusive(0, 127);`
	`162`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`163`	`+ let len = rng.sample(Uniform::new_inclusive(0, 8).unwrap());`
	`164`	`+ let dist = Uniform::new_inclusive(0, 127).unwrap();`
`164`	`165`	`let mut v = Vec::with_capacity(len);`
`165`	`166`	`for _ in 0..len {`
`166`	`167`	`v.push(rng.sample(dist));`
`@@ -170,11 +171,11 @@ impl Gen for VarLenAscii {`
`170`	`171`	`}`
`171`	`172`
`172`	`173`	`impl Gen for VarLenUnicode {`
`173`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`174`		`- let len = rng.sample(Uniform::new_inclusive(0, 8));`
	`174`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`175`	`+ let len = rng.sample(Uniform::new_inclusive(0, 8).unwrap());`
`175`	`176`	`let mut s = String::new();`
`176`	`177`	`while s.len() < len {`
`177`		`- let c = rng.gen::<char>();`
	`178`	`+ let c = rng.random::<char>();`
`178`	`179`	`if c != '\0' {`
`179`	`180`	`s.push(c);`
`180`	`181`	`}`
`@@ -184,11 +185,11 @@ impl Gen for VarLenUnicode {`
`184`	`185`	`}`
`185`	`186`
`186`	`187`	`impl<T: Gen + Copy> Gen for VarLenArray<T> {`
`187`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`188`		`- let len = rng.sample(Uniform::new_inclusive(0, 8));`
	`188`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`189`	`+ let len = rng.sample(Uniform::new_inclusive(0, 8).unwrap());`
`189`	`190`	`let mut v = Vec::with_capacity(len);`
`190`	`191`	`for _ in 0..len {`
`191`		`- v.push(Gen::gen(rng));`
	`192`	`+ v.push(Gen::random(rng));`
`192`	`193`	`}`
`193`	`194`	`VarLenArray::from_slice(&v)`
`194`	`195`	`}`
`@@ -202,7 +203,7 @@ pub enum Enum {`
`202`	`203`	`}`
`203`	`204`
`204`	`205`	`impl Gen for Enum {`
`205`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`206`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`206`	`207`	`*[Enum::X, Enum::Y].choose(rng).unwrap()`
`207`	`208`	`}`
`208`	`209`	`}`
`@@ -212,8 +213,8 @@ impl Gen for Enum {`
`212`	`213`	`pub struct TupleStruct(bool, Enum);`
`213`	`214`
`214`	`215`	`impl Gen for TupleStruct {`
`215`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`216`		`- TupleStruct(Gen::gen(rng), Gen::gen(rng))`
	`216`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`217`	`+ TupleStruct(Gen::random(rng), Gen::random(rng))`
`217`	`218`	`}`
`218`	`219`	`}`
`219`	`220`
`@@ -227,12 +228,12 @@ pub struct FixedStruct {`
`227`	`228`	`}`
`228`	`229`
`229`	`230`	`impl Gen for FixedStruct {`
`230`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`231`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`231`	`232`	`FixedStruct {`
`232`		`- fa: Gen::gen(rng),`
`233`		`- fu: Gen::gen(rng),`
`234`		`- tuple: (Gen::gen(rng), Gen::gen(rng), Gen::gen(rng)),`
`235`		`- array: [Gen::gen(rng), Gen::gen(rng)],`
	`233`	`+ fa: Gen::random(rng),`
	`234`	`+ fu: Gen::random(rng),`
	`235`	`+ tuple: (Gen::random(rng), Gen::random(rng), Gen::random(rng)),`
	`236`	`+ array: [Gen::random(rng), Gen::random(rng)],`
`236`	`237`	`}`
`237`	`238`	`}`
`238`	`239`	`}`
`@@ -246,8 +247,8 @@ pub struct VarLenStruct {`
`246`	`247`	`}`
`247`	`248`
`248`	`249`	`impl Gen for VarLenStruct {`
`249`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`250`		`- VarLenStruct { va: Gen::gen(rng), vu: Gen::gen(rng), vla: Gen::gen(rng) }`
	`250`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`251`	`+ VarLenStruct { va: Gen::random(rng), vu: Gen::random(rng), vla: Gen::random(rng) }`
`251`	`252`	`}`
`252`	`253`	`}`
`253`	`254`
`@@ -260,8 +261,8 @@ pub struct RenameStruct {`
`260`	`261`	`}`
`261`	`262`
`262`	`263`	`impl Gen for RenameStruct {`
`263`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`264`		`- RenameStruct { first: Gen::gen(rng), second: Gen::gen(rng) }`
	`264`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`265`	`+ RenameStruct { first: Gen::random(rng), second: Gen::random(rng) }`
`265`	`266`	`}`
`266`	`267`	`}`
`267`	`268`
`@@ -270,8 +271,8 @@ impl Gen for RenameStruct {`
`270`	`271`	`pub struct RenameTupleStruct(#[hdf5(rename = "my_boolean")] bool, #[hdf5(rename = "my_enum")] Enum);`
`271`	`272`
`272`	`273`	`impl Gen for RenameTupleStruct {`
`273`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`274`		`- RenameTupleStruct(Gen::gen(rng), Gen::gen(rng))`
	`274`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`275`	`+ RenameTupleStruct(Gen::random(rng), Gen::random(rng))`
`275`	`276`	`}`
`276`	`277`	`}`
`277`	`278`
`@@ -285,7 +286,7 @@ pub enum RenameEnum {`
`285`	`286`	`}`
`286`	`287`
`287`	`288`	`impl Gen for RenameEnum {`
`288`		`- fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {`
	`289`	`+ fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {`
`289`	`290`	`*[RenameEnum::X, RenameEnum::Y].choose(rng).unwrap()`
`290`	`291`	`}`
`291`	`292`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ use super::gen::gen_ascii;`
`3`	`3`	`use hdf5_metno as hdf5;`
`4`	`4`
`5`	`5`	`pub fn random_filename() -> String {`
`6`		`- gen_ascii(&mut rand::thread_rng(), 8)`
	`6`	`+ gen_ascii(&mut rand::rng(), 8)`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`pub fn new_in_memory_file() -> hdf5::Result<hdf5::File> {`