Test Linux fallback paths without use of cfg()s

This PR changes our Linux fallback tests to test the "real" fallback
paths rather than using various `cfg()`s within the implementation.

As these tests require being run sequentally and only work on Linux,
they are configured to require manual invocation.

Also renames `tests/mod.rs` to `tests/common.rs` to reuse our tests.

Actually testing the netbsd fallback is harder, so that's best left for
a future PR.

Signed-off-by: Joe Richey <joerichey@google.com>

Author: josephlr

.github/workflows/tests.yml

@@ -53,6 +53,8 @@ jobs:
           targets: ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v2
       - run: cargo test --target=${{ matrix.target }} --features=std
+      - run: cargo test --test linux_force_fallback -- --test-threads 1
+      - run: cargo test --test linux_no_fallback -- --test-threads 1
       - env:
           RUSTFLAGS: -Dwarnings --cfg getrandom_backend="linux_getrandom"
           RUSTDOCFLAGS: -Dwarnings --cfg getrandom_backend="linux_getrandom"
@@ -61,18 +63,10 @@ jobs:
           RUSTFLAGS: -Dwarnings --cfg getrandom_backend="linux_raw"
           RUSTDOCFLAGS: -Dwarnings --cfg getrandom_backend="linux_raw"
         run: cargo test --target=${{ matrix.target }} --features=std
-      - env:
-          RUSTFLAGS: -Dwarnings --cfg getrandom_test_linux_fallback
-          RUSTDOCFLAGS: -Dwarnings --cfg getrandom_test_linux_fallback
-        run: cargo test --features=std
-      - env:
-          RUSTFLAGS: -Dwarnings --cfg getrandom_test_linux_without_fallback
-          RUSTDOCFLAGS: -Dwarnings --cfg getrandom_test_linux_without_fallback
-        run: cargo test --features=std
       - env:
           RUSTFLAGS: -Dwarnings --cfg getrandom_backend="rdrand"
           RUSTDOCFLAGS: -Dwarnings --cfg getrandom_backend="rdrand"
-        run: cargo test --features=std
+        run: cargo test --target=${{ matrix.target }} --features=std
 
   ios:
     name: iOS Simulator

CHANGELOG.md

@@ -10,8 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `efi_rng` opt-in backend [#570]
 - `linux_raw` opt-in backend [#572]
 - `.cargo/config.toml` example in the crate-level docs [#591]
-- `getrandom_test_linux_without_fallback` configuration flag to test that file fallback
-  is not triggered in the `linux_android_with_fallback` backend [#605]
+- Add tests for Linux fallback paths without hardcoding `cfg`s [#999]
 
 ### Changed
 - Remove `windows-targets` dependency and use [`raw-dylib`] directly [#627]
@@ -34,10 +33,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [#597]: https://github.com/rust-random/getrandom/pull/597
 [#602]: https://github.com/rust-random/getrandom/pull/602
 [#603]: https://github.com/rust-random/getrandom/pull/603
-[#605]: https://github.com/rust-random/getrandom/pull/605
 [#610]: https://github.com/rust-random/getrandom/pull/610
 [#614]: https://github.com/rust-random/getrandom/pull/614
 [#627]: https://github.com/rust-random/getrandom/pull/627
+[#999]: https://github.com/rust-random/getrandom/pull/999
 [`raw-dylib`]: https://doc.rust-lang.org/reference/items/external-blocks.html?highlight=link#dylib-versus-raw-dylib
 
 ## [0.3.1] - 2025-01-28

Cargo.toml

@@ -84,11 +84,17 @@ check-cfg = [
   'cfg(getrandom_backend, values("custom", "efi_rng", "rdrand", "rndr", "linux_getrandom", "linux_raw", "wasm_js"))',
   'cfg(getrandom_msan)',
   'cfg(getrandom_windows_legacy)',
-  'cfg(getrandom_test_linux_fallback)',
-  'cfg(getrandom_test_linux_without_fallback)',
   'cfg(getrandom_test_netbsd_fallback)',
 ]
 
+# Linux-specific fallback tests
+[[test]]
+name = "linux_force_fallback"
+test = false
+[[test]]
+name = "linux_no_fallback"
+test = false
+
 [package.metadata.docs.rs]
 features = ["std"]
 

src/backends/linux_android_with_fallback.rs

@@ -41,9 +41,7 @@ fn init() -> NonNull<c_void> {
             let dangling_ptr = NonNull::dangling().as_ptr();
             // Check that `getrandom` syscall is supported by kernel
             let res = unsafe { getrandom_fn(dangling_ptr, 0, 0) };
-            if cfg!(getrandom_test_linux_fallback) {
-                NOT_AVAILABLE
-            } else if res.is_negative() {
+            if res.is_negative() {
                 match util_libc::last_os_error().raw_os_error() {
                     Some(libc::ENOSYS) => NOT_AVAILABLE, // No kernel support
                     // The fallback on EPERM is intentionally not done on Android since this workaround
@@ -60,11 +58,6 @@ fn init() -> NonNull<c_void> {
         None => NOT_AVAILABLE,
     };
 
-    #[cfg(getrandom_test_linux_without_fallback)]
-    if res_ptr == NOT_AVAILABLE {
-        panic!("Fallback is triggered with enabled `getrandom_test_linux_without_fallback`")
-    }
-
     GETRANDOM_FN.store(res_ptr.as_ptr(), Ordering::Release);
     res_ptr
 }

tests/mod.rs renamed to tests/common.rs

@@ -0,0 +1,37 @@
+//! This test forces the Linux fallback path to be taken. This test must be
+//! run manually and sequentally:
+//!
+//!   cargo test --test linux_force_fallback -- --test-threads 1
+use std::{
+    ffi::c_void,
+    fs::{read_dir, DirEntry},
+    sync::atomic::{AtomicBool, Ordering},
+};
+
+use libc::{__errno_location, c_uint, size_t, ssize_t, ENOSYS};
+
+static FAKE_GETRANDOM_CALLED: AtomicBool = AtomicBool::new(false);
+
+// Override libc::getrandom to simulate failure
+#[export_name = "getrandom"]
+pub unsafe extern "C" fn fake_getrandom(_: *mut c_void, _: size_t, _: c_uint) -> ssize_t {
+    FAKE_GETRANDOM_CALLED.store(true, Ordering::SeqCst);
+    unsafe { *__errno_location() = ENOSYS };
+    -1
+}
+
+mod common;
+
+#[test]
+fn fake_getrandom_is_called() {
+    assert!(FAKE_GETRANDOM_CALLED.load(Ordering::SeqCst));
+}
+
+#[test]
+fn dev_urandom_is_open() {
+    fn is_urandom(entry: DirEntry) -> bool {
+        entry.path().canonicalize().unwrap().to_str() == Some("/dev/urandom")
+    }
+    let mut dir = read_dir("/proc/self/fd").unwrap();
+    assert!(dir.any(|path| is_urandom(path.unwrap())));
+}

tests/linux_force_fallback.rs

@@ -0,0 +1,16 @@
+//! This test ensures the Linux fallback path is not taken. As this test will
+//! fail in some Linux configurations, it must be run manually and sequentally:
+//!
+//!   cargo test --test linux_no_fallback -- --test-threads 1
+use std::fs::{read_dir, DirEntry};
+
+mod common;
+
+#[test]
+fn dev_urandom_is_not_open() {
+    fn is_urandom(entry: DirEntry) -> bool {
+        entry.path().canonicalize().unwrap().to_str() == Some("/dev/urandom")
+    }
+    let mut dir = read_dir("/proc/self/fd").unwrap();
+    assert!(dir.all(|path| !is_urandom(path.unwrap())));
+}