Make GatedReader a test-only symbol, and allow all bevy_asset tests to all run single threaded. (#18473)

# Objective

- Some tests have been disabled in single-threaded mode.
- This was because the channel blocks the executing thread when in the
asset reader. But that means we never get to the test line to open the
gate! So we need multithreading just to let the reader block and the
test can make progress in the background.

## Solution

- The solution to allowing all tests to run single threaded is to make
`GatedReader` await for gates to open rather than blocking on it.
- This however requires adding `async-channel` (already in tree). To
avoid this additional dependency in most cases, I made this a
dev-dependency.
- However, this now means that `GatedReader` can only be used in tests
(in bevy_asset). We could make this a feature flag, but it seems highly
unlikely that real users need a `GatedReader` - and if they need it for
their test, they can just fork the `GatedReader`.

## Testing

- The `bevy_asset` tests pass without setting the `--features
multi_threaded` flag!

---

## Migration Guide

`bevy_asset::io::gated::GatedReader` and
`bevy_asset::io::gated::GatedOpener` are no longer accessible to users.

Author: andriyDev

crates/bevy_asset/Cargo.toml

@@ -88,6 +88,9 @@ bevy_reflect = { path = "../bevy_reflect", version = "0.17.0-dev", default-featu
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 notify-debouncer-full = { version = "0.5.0", default-features = false, optional = true }
 
+[dev-dependencies]
+async-channel = "2"
+
 [lints]
 workspace = true
 

crates/bevy_asset/src/io/gated.rs

@@ -1,7 +1,7 @@
 use crate::io::{AssetReader, AssetReaderError, PathStream, Reader};
 use alloc::{boxed::Box, sync::Arc};
+use async_channel::{Receiver, Sender};
 use bevy_platform::collections::HashMap;
-use crossbeam_channel::{Receiver, Sender};
 use parking_lot::RwLock;
 use std::path::Path;
 
@@ -35,8 +35,8 @@ impl GateOpener {
         let mut gates = self.gates.write();
         let gates = gates
             .entry_ref(path.as_ref())
-            .or_insert_with(crossbeam_channel::unbounded);
-        gates.0.send(()).unwrap();
+            .or_insert_with(async_channel::unbounded);
+        gates.0.send_blocking(()).unwrap();
     }
 }
 
@@ -61,10 +61,10 @@ impl<R: AssetReader> AssetReader for GatedReader<R> {
             let mut gates = self.gates.write();
             let gates = gates
                 .entry_ref(path.as_ref())
-                .or_insert_with(crossbeam_channel::unbounded);
+                .or_insert_with(async_channel::unbounded);
             gates.1.clone()
         };
-        receiver.recv().unwrap();
+        receiver.recv().await.unwrap();
         let result = self.reader.read(path).await?;
         Ok(result)
     }

crates/bevy_asset/src/io/mod.rs

@@ -10,12 +10,14 @@ pub mod android;
 pub mod embedded;
 #[cfg(not(target_arch = "wasm32"))]
 pub mod file;
-pub mod gated;
 pub mod memory;
 pub mod processor_gated;
 #[cfg(target_arch = "wasm32")]
 pub mod wasm;
 
+#[cfg(test)]
+pub mod gated;
+
 mod source;
 
 pub use futures_lite::AsyncWriteExt;

crates/bevy_asset/src/lib.rs

@@ -893,10 +893,6 @@ mod tests {
 
     #[test]
     fn load_dependencies() {
-        // The particular usage of GatedReader in this test will cause deadlocking if running single-threaded
-        #[cfg(not(feature = "multi_threaded"))]
-        panic!("This test requires the \"multi_threaded\" feature, otherwise it will deadlock.\ncargo test --package bevy_asset --features multi_threaded");
-
         let dir = Dir::default();
 
         let a_path = "a.cool.ron";
@@ -1201,10 +1197,6 @@ mod tests {
 
     #[test]
     fn failure_load_states() {
-        // The particular usage of GatedReader in this test will cause deadlocking if running single-threaded
-        #[cfg(not(feature = "multi_threaded"))]
-        panic!("This test requires the \"multi_threaded\" feature, otherwise it will deadlock.\ncargo test --package bevy_asset --features multi_threaded");
-
         let dir = Dir::default();
 
         let a_path = "a.cool.ron";
@@ -1334,10 +1326,6 @@ mod tests {
 
     #[test]
     fn dependency_load_states() {
-        // The particular usage of GatedReader in this test will cause deadlocking if running single-threaded
-        #[cfg(not(feature = "multi_threaded"))]
-        panic!("This test requires the \"multi_threaded\" feature, otherwise it will deadlock.\ncargo test --package bevy_asset --features multi_threaded");
-
         let a_path = "a.cool.ron";
         let a_ron = r#"
 (
@@ -1473,10 +1461,6 @@ mod tests {
 
     #[test]
     fn manual_asset_management() {
-        // The particular usage of GatedReader in this test will cause deadlocking if running single-threaded
-        #[cfg(not(feature = "multi_threaded"))]
-        panic!("This test requires the \"multi_threaded\" feature, otherwise it will deadlock.\ncargo test --package bevy_asset --features multi_threaded");
-
         let dir = Dir::default();
         let dep_path = "dep.cool.ron";
 
@@ -1574,10 +1558,6 @@ mod tests {
 
     #[test]
     fn load_folder() {
-        // The particular usage of GatedReader in this test will cause deadlocking if running single-threaded
-        #[cfg(not(feature = "multi_threaded"))]
-        panic!("This test requires the \"multi_threaded\" feature, otherwise it will deadlock.\ncargo test --package bevy_asset --features multi_threaded");
-
         let dir = Dir::default();
 
         let a_path = "text/a.cool.ron";

release-content/migration-guides/gated_reader.md

@@ -0,0 +1,10 @@
+---
+title: `GatedReader` and `GatedOpener` are now private.
+pull_requests: [18473]
+---
+
+The `GatedReader` and `GatedOpener` for `bevy_asset` have been made private. These were really only
+for testing, but were being compiled even in release builds. Now they are guarded by `#[cfg(test)]`!
+
+If you were using this in your own tests, you could fork the `GatedReader` (it still exists in the
+Bevy repo!) into your own code, or write your own version (if more useful to you).