Move custom impl tests into a separate helper crate

Author: newpavlov

.github/workflows/build.yml

@@ -269,7 +269,7 @@ jobs:
           targets: riscv32i-unknown-none-elf
       - uses: Swatinem/rust-cache@v2
       - env:
-          RUSTFLAGS: -Dwarnings --cfg getrandom_backend="custom"
+          RUSTFLAGS: -Dwarnings --cfg getrandom_backend="unsupported"
         run: cargo build --target riscv32i-unknown-none-elf
 
   unsupported:

.github/workflows/tests.yml

@@ -78,18 +78,21 @@ jobs:
           RUSTDOCFLAGS: -Dwarnings --cfg getrandom_backend="rdrand"
         run: cargo test --features=std,sys_rng
 
-  extern_impl:
-    name: Extern Item Implementations
+  custom_impl:
+    name: Custom Implementations
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: nightly
       - uses: Swatinem/rust-cache@v2
+      - env:
+          RUSTFLAGS: -Dwarnings --cfg getrandom_backend="custom"
+        run: cargo test
       - env:
           RUSTFLAGS: -Dwarnings --cfg getrandom_backend="extern_impl"
-        run: cargo test --features=std
+        run: cargo test
 
   ios:
     name: iOS Simulator

.gitignore

@@ -2,3 +2,5 @@
 **/*.rs.bk
 nopanic_check/Cargo.lock
 nopanic_check/target/
+custom_impl_test/Cargo.lock
+custom_impl_test/target/

custom_impl_test/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "custom_impl_test"
+description = "Helper crate for testing custom implementations"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[workspace]
+
+[dependencies]
+getrandom = { path = ".." }
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = [
+  'cfg(getrandom_backend, values("custom", "extern_impl"))',
+]

custom_impl_test/src/lib.rs

@@ -0,0 +1,101 @@
+use core::mem::MaybeUninit;
+use getrandom::Error;
+
+/// Chosen by fair dice roll.
+const SEED: u64 = 0x9095_810F_1B2B_E175;
+
+struct Xoshiro128PlusPlus {
+    s: [u32; 4],
+}
+
+impl Xoshiro128PlusPlus {
+    fn new(mut seed: u64) -> Self {
+        const PHI: u64 = 0x9e3779b97f4a7c15;
+        let mut s = [0u32; 4];
+        for val in s.iter_mut() {
+            seed = seed.wrapping_add(PHI);
+            let mut z = seed;
+            z = (z ^ (z >> 30)).wrapping_mul(0xbf58476d1ce4e5b9);
+            z = (z ^ (z >> 27)).wrapping_mul(0x94d049bb133111eb);
+            z = z ^ (z >> 31);
+            *val = z as u32;
+        }
+        Self { s }
+    }
+
+    fn next_u32(&mut self) -> u32 {
+        let res = self.s[0]
+            .wrapping_add(self.s[3])
+            .rotate_left(7)
+            .wrapping_add(self.s[0]);
+
+        let t = self.s[1] << 9;
+
+        self.s[2] ^= self.s[0];
+        self.s[3] ^= self.s[1];
+        self.s[1] ^= self.s[2];
+        self.s[0] ^= self.s[3];
+
+        self.s[2] ^= t;
+
+        self.s[3] = self.s[3].rotate_left(11);
+
+        res
+    }
+}
+
+pub fn custom_impl(dst: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
+    let mut rng = Xoshiro128PlusPlus::new(SEED);
+
+    let mut chunks = dst.chunks_exact_mut(4);
+    for chunk in &mut chunks {
+        let val = rng.next_u32();
+        let dst_ptr = chunk.as_mut_ptr().cast::<u32>();
+        unsafe { core::ptr::write_unaligned(dst_ptr, val) };
+    }
+    let rem = chunks.into_remainder();
+    if !rem.is_empty() {
+        let val = rng.next_u32();
+        let src_ptr = &val as *const u32 as *const MaybeUninit<u8>;
+        assert!(rem.len() <= 4);
+        unsafe { core::ptr::copy(src_ptr, rem.as_mut_ptr(), rem.len()) };
+    }
+    Ok(())
+}
+
+#[cfg(getrandom_backend = "custom")]
+#[unsafe(no_mangle)]
+unsafe extern "Rust" fn __getrandom_v03_custom(dst_ptr: *mut u8, len: usize) -> Result<(), Error> {
+    let dst = unsafe { core::slice::from_raw_parts_mut(dst_ptr.cast(), len) };
+    custom_impl(dst)
+}
+
+#[cfg(getrandom_backend = "extern_impl")]
+#[getrandom::implementation::fill_uninit]
+fn my_fill_uninit_implementation(dst: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
+    custom_impl(dst)
+}
+
+#[test]
+fn test_custom_fill() {
+    let mut buf1 = [0u8; 256];
+    getrandom::fill(&mut buf1).unwrap();
+
+    let mut buf2 = [0u8; 256];
+    custom_impl(unsafe { core::slice::from_raw_parts_mut(buf2.as_mut_ptr().cast(), buf2.len()) })
+        .unwrap();
+
+    assert_eq!(buf1, buf2);
+}
+
+#[test]
+fn test_custom_u32() {
+    let res = getrandom::u32().unwrap();
+    assert_eq!(res, 0xEAD5_840A);
+}
+
+#[test]
+fn test_custom_u64() {
+    let res = getrandom::u64().unwrap();
+    assert_eq!(res, 0xA856_FCC4_EAD5_840A);
+}

tests/mod.rs

@@ -207,120 +207,3 @@ fn test_multithreading() {
         tx.send(()).unwrap();
     }
 }
-
-#[cfg(getrandom_backend = "custom")]
-mod custom {
-    use getrandom::Error;
-
-    struct Xoshiro128PlusPlus {
-        s: [u32; 4],
-    }
-
-    impl Xoshiro128PlusPlus {
-        fn new(mut seed: u64) -> Self {
-            const PHI: u64 = 0x9e3779b97f4a7c15;
-            let mut s = [0u32; 4];
-            for val in s.iter_mut() {
-                seed = seed.wrapping_add(PHI);
-                let mut z = seed;
-                z = (z ^ (z >> 30)).wrapping_mul(0xbf58476d1ce4e5b9);
-                z = (z ^ (z >> 27)).wrapping_mul(0x94d049bb133111eb);
-                z = z ^ (z >> 31);
-                *val = z as u32;
-            }
-            Self { s }
-        }
-
-        fn next_u32(&mut self) -> u32 {
-            let res = self.s[0]
-                .wrapping_add(self.s[3])
-                .rotate_left(7)
-                .wrapping_add(self.s[0]);
-
-            let t = self.s[1] << 9;
-
-            self.s[2] ^= self.s[0];
-            self.s[3] ^= self.s[1];
-            self.s[1] ^= self.s[2];
-            self.s[0] ^= self.s[3];
-
-            self.s[2] ^= t;
-
-            self.s[3] = self.s[3].rotate_left(11);
-
-            res
-        }
-    }
-
-    // This implementation uses current timestamp as a PRNG seed.
-    //
-    // WARNING: this custom implementation is for testing purposes ONLY!
-
-    #[unsafe(no_mangle)]
-    unsafe extern "Rust" fn __getrandom_v03_custom(dest: *mut u8, len: usize) -> Result<(), Error> {
-        use std::time::{SystemTime, UNIX_EPOCH};
-
-        assert_ne!(len, 0);
-
-        if len == 142 {
-            return Err(Error::new_custom(142));
-        }
-
-        let dest_u32 = dest.cast::<u32>();
-        let ts = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-        let mut rng = Xoshiro128PlusPlus::new(ts.as_nanos() as u64);
-        for i in 0..len / 4 {
-            let val = rng.next_u32();
-            unsafe { core::ptr::write_unaligned(dest_u32.add(i), val) };
-        }
-        if len % 4 != 0 {
-            let start = 4 * (len / 4);
-            for i in start..len {
-                let val = rng.next_u32();
-                unsafe { core::ptr::write_unaligned(dest.add(i), val as u8) };
-            }
-        }
-        Ok(())
-    }
-
-    // Test that enabling the custom feature indeed uses the custom implementation
-    #[test]
-    fn test_custom() {
-        let mut buf = [0u8; 142];
-        let res = getrandom::fill(&mut buf);
-        assert!(res.is_err());
-    }
-}
-
-#[cfg(getrandom_backend = "extern_impl")]
-mod extern_item_impls {
-    use core::mem::MaybeUninit;
-    use getrandom::Error;
-
-    // This implementation for fill_uninit will always fail.
-    //
-    // WARNING: this custom implementation is for testing purposes ONLY!
-
-    #[getrandom::implementation::fill_uninit]
-    fn my_fill_uninit_implementation(_dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-        Err(Error::new_custom(4))
-    }
-
-    // This implementation returns a fixed value to demonstrate overriding defaults.
-    //
-    // WARNING: this custom implementation is for testing purposes ONLY!
-
-    #[getrandom::implementation::u32]
-    fn my_u32_implementation() -> Result<u32, Error> {
-        // Chosen by fair dice roll
-        Ok(4)
-    }
-
-    // Test that enabling the custom feature indeed uses the custom implementation
-    #[test]
-    fn test_extern_item_impls() {
-        let mut buf = [0u8; 123];
-        assert_eq!(getrandom::fill(&mut buf), Err(Error::new_custom(4)));
-        assert_eq!(getrandom::u32(), Ok(4));
-    }
-}