From 5bcae7455be5042f10e770488129c5b150a21aea Mon Sep 17 00:00:00 2001
From: Niklas Eicker <git@nikl.me>
Date: Sat, 24 Feb 2024 10:54:27 +0100
Subject: [PATCH 1/2] Enable more integration tests to run with all tested
 feature combinations

---
 .../tests/can_run_without_next_state.rs       | 44 ++++++------
 .../tests/continues_to_failure_state.rs       | 18 ++---
 .../tests/continues_without_collection.rs     | 16 ++---
 bevy_asset_loader/tests/init_resource.rs      | 42 +++++------
 .../tests/mapped_path_use_slash.rs            | 40 +++++------
 .../tests/multiple_asset_collections.rs       | 46 ++++++------
 bevy_asset_loader/tests/multiple_states.rs    | 68 +++++++++---------
 .../tests/reload_dynamic_asset_files.rs       | 70 +++++++++----------
 8 files changed, 158 insertions(+), 186 deletions(-)

diff --git a/bevy_asset_loader/tests/can_run_without_next_state.rs b/bevy_asset_loader/tests/can_run_without_next_state.rs
index 973891e..75c2094 100644
--- a/bevy_asset_loader/tests/can_run_without_next_state.rs
+++ b/bevy_asset_loader/tests/can_run_without_next_state.rs
@@ -1,35 +1,31 @@
-#![allow(dead_code, unused_imports)]
-
 use bevy::app::AppExit;
 use bevy::asset::AssetPlugin;
 use bevy::audio::AudioPlugin;
 use bevy::prelude::*;
 use bevy_asset_loader::prelude::*;
 
-#[cfg(all(
-    not(feature = "2d"),
-    not(feature = "3d"),
-    not(feature = "progress_tracking")
-))]
 #[test]
 fn can_run_without_next_state() {
-    App::new()
-        .init_state::<MyStates>()
-        .add_plugins((
-            MinimalPlugins,
-            AssetPlugin::default(),
-            AudioPlugin::default(),
-        ))
-        .add_loading_state(LoadingState::new(MyStates::Load).load_collection::<MyAssets>())
-        .init_resource::<TestState>()
-        .add_systems(
-            Update,
-            (
-                expect.run_if(in_state(MyStates::Load)),
-                timeout.run_if(in_state(MyStates::Load)),
-            ),
-        )
-        .run();
+    let mut app = App::new();
+    app.init_state::<MyStates>();
+
+    #[cfg(feature = "progress_tracking")]
+    app.add_plugins(iyes_progress::ProgressPlugin::new(MyStates::Load));
+    app.add_plugins((
+        MinimalPlugins,
+        AssetPlugin::default(),
+        AudioPlugin::default(),
+    ))
+    .add_loading_state(LoadingState::new(MyStates::Load).load_collection::<MyAssets>())
+    .init_resource::<TestState>()
+    .add_systems(
+        Update,
+        (
+            expect.run_if(in_state(MyStates::Load)),
+            timeout.run_if(in_state(MyStates::Load)),
+        ),
+    )
+    .run();
 }
 
 fn timeout(time: Res<Time>) {
diff --git a/bevy_asset_loader/tests/continues_to_failure_state.rs b/bevy_asset_loader/tests/continues_to_failure_state.rs
index 33f6783..da5fa13 100644
--- a/bevy_asset_loader/tests/continues_to_failure_state.rs
+++ b/bevy_asset_loader/tests/continues_to_failure_state.rs
@@ -1,20 +1,16 @@
-#![allow(dead_code, unused_imports)]
-
 use bevy::app::AppExit;
 use bevy::asset::AssetPlugin;
 use bevy::prelude::*;
 use bevy_asset_loader::prelude::*;
 
-#[cfg(all(
-    not(feature = "2d"),
-    not(feature = "3d"),
-    not(feature = "progress_tracking")
-))]
 #[test]
 fn continues_to_failure_state() {
-    App::new()
-        .init_state::<MyStates>()
-        .add_plugins((MinimalPlugins, AssetPlugin::default()))
+    let mut app = App::new();
+    app.init_state::<MyStates>();
+
+    #[cfg(feature = "progress_tracking")]
+    app.add_plugins(iyes_progress::ProgressPlugin::new(MyStates::Load));
+    app.add_plugins((MinimalPlugins, AssetPlugin::default()))
         .add_loading_state(
             LoadingState::new(MyStates::Load)
                 .continue_to_state(MyStates::Next)
@@ -44,7 +40,7 @@ fn timeout(time: Res<Time>) {
 #[derive(AssetCollection, Resource)]
 struct Audio {
     #[asset(path = "audio/plop.ogg")]
-    no_loader_for_ogg_files: Handle<AudioSource>,
+    _no_loader_for_ogg_files: Handle<AudioSource>,
 }
 
 #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
diff --git a/bevy_asset_loader/tests/continues_without_collection.rs b/bevy_asset_loader/tests/continues_without_collection.rs
index b55d3db..e8aedf7 100644
--- a/bevy_asset_loader/tests/continues_without_collection.rs
+++ b/bevy_asset_loader/tests/continues_without_collection.rs
@@ -1,20 +1,16 @@
-#![allow(dead_code, unused_imports)]
-
 use bevy::app::AppExit;
 use bevy::asset::AssetPlugin;
 use bevy::prelude::*;
 use bevy_asset_loader::prelude::*;
 
-#[cfg(all(
-    not(feature = "2d"),
-    not(feature = "3d"),
-    not(feature = "progress_tracking")
-))]
 #[test]
 fn continues_without_collection() {
-    App::new()
-        .init_state::<MyStates>()
-        .add_plugins((MinimalPlugins, AssetPlugin::default()))
+    let mut app = App::new();
+    app.init_state::<MyStates>();
+
+    #[cfg(feature = "progress_tracking")]
+    app.add_plugins(iyes_progress::ProgressPlugin::new(MyStates::Load));
+    app.add_plugins((MinimalPlugins, AssetPlugin::default()))
         .add_loading_state(LoadingState::new(MyStates::Load).continue_to_state(MyStates::Next))
         .init_resource::<TestState>()
         .add_systems(Update, expect.run_if(in_state(MyStates::Load)))
diff --git a/bevy_asset_loader/tests/init_resource.rs b/bevy_asset_loader/tests/init_resource.rs
index e42cf00..1905389 100644
--- a/bevy_asset_loader/tests/init_resource.rs
+++ b/bevy_asset_loader/tests/init_resource.rs
@@ -1,34 +1,30 @@
-#![allow(dead_code, unused_imports)]
-
 use bevy::app::AppExit;
 use bevy::asset::AssetPlugin;
 use bevy::audio::AudioPlugin;
 use bevy::prelude::*;
 use bevy_asset_loader::prelude::*;
 
-#[cfg(all(
-    not(feature = "2d"),
-    not(feature = "3d"),
-    not(feature = "progress_tracking")
-))]
 #[test]
 fn init_resource() {
-    App::new()
-        .init_state::<MyStates>()
-        .add_plugins((
-            MinimalPlugins,
-            AssetPlugin::default(),
-            AudioPlugin::default(),
-        ))
-        .add_loading_state(
-            LoadingState::new(MyStates::Load)
-                .continue_to_state(MyStates::Next)
-                .load_collection::<MyAssets>()
-                .init_resource::<PostProcessed>(),
-        )
-        .add_systems(Update, timeout.run_if(in_state(MyStates::Load)))
-        .add_systems(OnEnter(MyStates::Next), expect)
-        .run();
+    let mut app = App::new();
+    app.init_state::<MyStates>();
+
+    #[cfg(feature = "progress_tracking")]
+    app.add_plugins(iyes_progress::ProgressPlugin::new(MyStates::Load));
+    app.add_plugins((
+        MinimalPlugins,
+        AssetPlugin::default(),
+        AudioPlugin::default(),
+    ))
+    .add_loading_state(
+        LoadingState::new(MyStates::Load)
+            .continue_to_state(MyStates::Next)
+            .load_collection::<MyAssets>()
+            .init_resource::<PostProcessed>(),
+    )
+    .add_systems(Update, timeout.run_if(in_state(MyStates::Load)))
+    .add_systems(OnEnter(MyStates::Next), expect)
+    .run();
 }
 
 fn timeout(time: Res<Time>) {
diff --git a/bevy_asset_loader/tests/mapped_path_use_slash.rs b/bevy_asset_loader/tests/mapped_path_use_slash.rs
index 8425992..371f362 100644
--- a/bevy_asset_loader/tests/mapped_path_use_slash.rs
+++ b/bevy_asset_loader/tests/mapped_path_use_slash.rs
@@ -1,5 +1,3 @@
-#![allow(dead_code, unused_imports)]
-
 use bevy::app::AppExit;
 use bevy::asset::AssetPlugin;
 use bevy::audio::AudioPlugin;
@@ -7,28 +5,26 @@ use bevy::prelude::*;
 use bevy::utils::HashMap;
 use bevy_asset_loader::prelude::*;
 
-#[cfg(all(
-    not(feature = "2d"),
-    not(feature = "3d"),
-    not(feature = "progress_tracking")
-))]
 #[test]
 fn mapped_path_use_slash() {
-    App::new()
-        .init_state::<MyStates>()
-        .add_plugins((
-            MinimalPlugins,
-            AssetPlugin::default(),
-            AudioPlugin::default(),
-        ))
-        .add_loading_state(
-            LoadingState::new(MyStates::Load)
-                .continue_to_state(MyStates::Next)
-                .load_collection::<AudioCollection>(),
-        )
-        .add_systems(Update, timeout.run_if(in_state(MyStates::Load)))
-        .add_systems(OnEnter(MyStates::Next), expect)
-        .run();
+    let mut app = App::new();
+    app.init_state::<MyStates>();
+
+    #[cfg(feature = "progress_tracking")]
+    app.add_plugins(iyes_progress::ProgressPlugin::new(MyStates::Load));
+    app.add_plugins((
+        MinimalPlugins,
+        AssetPlugin::default(),
+        AudioPlugin::default(),
+    ))
+    .add_loading_state(
+        LoadingState::new(MyStates::Load)
+            .continue_to_state(MyStates::Next)
+            .load_collection::<AudioCollection>(),
+    )
+    .add_systems(Update, timeout.run_if(in_state(MyStates::Load)))
+    .add_systems(OnEnter(MyStates::Next), expect)
+    .run();
 }
 
 fn timeout(time: Res<Time>) {
diff --git a/bevy_asset_loader/tests/multiple_asset_collections.rs b/bevy_asset_loader/tests/multiple_asset_collections.rs
index e99f8bd..362a627 100644
--- a/bevy_asset_loader/tests/multiple_asset_collections.rs
+++ b/bevy_asset_loader/tests/multiple_asset_collections.rs
@@ -1,34 +1,30 @@
-#![allow(dead_code, unused_imports)]
-
 use bevy::app::AppExit;
 use bevy::asset::AssetPlugin;
 use bevy::audio::AudioPlugin;
 use bevy::prelude::*;
 use bevy_asset_loader::prelude::*;
 
-#[cfg(all(
-    not(feature = "2d"),
-    not(feature = "3d"),
-    not(feature = "progress_tracking")
-))]
 #[test]
 fn multiple_asset_collections() {
-    App::new()
-        .init_state::<MyStates>()
-        .add_plugins((
-            MinimalPlugins,
-            AssetPlugin::default(),
-            AudioPlugin::default(),
-        ))
-        .add_loading_state(
-            LoadingState::new(MyStates::Load)
-                .continue_to_state(MyStates::Next)
-                .load_collection::<PlopAudio>()
-                .load_collection::<BackgroundAudio>(),
-        )
-        .add_systems(Update, timeout.run_if(in_state(MyStates::Load)))
-        .add_systems(OnEnter(MyStates::Next), expect)
-        .run();
+    let mut app = App::new();
+    app.init_state::<MyStates>();
+
+    #[cfg(feature = "progress_tracking")]
+    app.add_plugins(iyes_progress::ProgressPlugin::new(MyStates::Load));
+    app.add_plugins((
+        MinimalPlugins,
+        AssetPlugin::default(),
+        AudioPlugin::default(),
+    ))
+    .add_loading_state(
+        LoadingState::new(MyStates::Load)
+            .continue_to_state(MyStates::Next)
+            .load_collection::<PlopAudio>()
+            .load_collection::<BackgroundAudio>(),
+    )
+    .add_systems(Update, timeout.run_if(in_state(MyStates::Load)))
+    .add_systems(OnEnter(MyStates::Next), expect)
+    .run();
 }
 
 fn timeout(time: Res<Time>) {
@@ -52,13 +48,13 @@ fn expect(
 #[derive(AssetCollection, Resource)]
 struct PlopAudio {
     #[asset(path = "audio/plop.ogg")]
-    plop: Handle<AudioSource>,
+    _plop: Handle<AudioSource>,
 }
 
 #[derive(AssetCollection, Resource)]
 struct BackgroundAudio {
     #[asset(path = "audio/background.ogg")]
-    background: Handle<AudioSource>,
+    _background: Handle<AudioSource>,
 }
 
 #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
diff --git a/bevy_asset_loader/tests/multiple_states.rs b/bevy_asset_loader/tests/multiple_states.rs
index 681e130..e795683 100644
--- a/bevy_asset_loader/tests/multiple_states.rs
+++ b/bevy_asset_loader/tests/multiple_states.rs
@@ -1,43 +1,41 @@
-#![allow(dead_code, unused_imports)]
-
 use bevy::app::AppExit;
 use bevy::audio::AudioPlugin;
 use bevy::prelude::*;
 use bevy_asset_loader::prelude::*;
 
-#[cfg(all(
-    not(feature = "2d"),
-    not(feature = "3d"),
-    not(feature = "progress_tracking")
-))]
 #[test]
 fn main() {
-    App::new()
-        .add_plugins((
-            MinimalPlugins,
-            AssetPlugin::default(),
-            AudioPlugin::default(),
-        ))
-        .init_state::<Prepare>()
-        .init_state::<Game>()
-        .add_loading_state(
-            LoadingState::new(Game::Booting)
-                .continue_to_state(Game::Loading)
-                .load_collection::<GameStateCollection>(),
-        )
-        .add_loading_state(
-            LoadingState::new(Prepare::Loading)
-                .continue_to_state(Prepare::Finalize)
-                .load_collection::<LoadingStateCollection>(),
-        )
-        .add_systems(Update, (quit.run_if(in_state(Game::Play)), timeout))
-        .add_systems(
-            OnEnter(Game::Loading),
-            (go_to_loading_loading, probe_game_state),
-        )
-        .add_systems(OnEnter(Prepare::Finalize), go_to_game_play_loading_done)
-        .add_systems(OnEnter(Game::Play), probe_loading_state)
-        .run();
+    let mut app = App::new();
+    app.init_state::<Prepare>().init_state::<Game>();
+
+    #[cfg(feature = "progress_tracking")]
+    app.add_plugins((
+        iyes_progress::ProgressPlugin::new(Game::Booting),
+        iyes_progress::ProgressPlugin::new(Prepare::Loading),
+    ));
+    app.add_plugins((
+        MinimalPlugins,
+        AssetPlugin::default(),
+        AudioPlugin::default(),
+    ))
+    .add_loading_state(
+        LoadingState::new(Game::Booting)
+            .continue_to_state(Game::Loading)
+            .load_collection::<GameStateCollection>(),
+    )
+    .add_loading_state(
+        LoadingState::new(Prepare::Loading)
+            .continue_to_state(Prepare::Finalize)
+            .load_collection::<LoadingStateCollection>(),
+    )
+    .add_systems(Update, (quit.run_if(in_state(Game::Play)), timeout))
+    .add_systems(
+        OnEnter(Game::Loading),
+        (go_to_loading_loading, probe_game_state),
+    )
+    .add_systems(OnEnter(Prepare::Finalize), go_to_game_play_loading_done)
+    .add_systems(OnEnter(Game::Play), probe_loading_state)
+    .run();
 }
 
 #[derive(Clone, Copy, Debug, States, Default, PartialEq, Eq, Hash)]
@@ -59,7 +57,7 @@ enum Prepare {
 #[derive(Resource, AssetCollection)]
 pub struct GameStateCollection {
     #[asset(path = "audio/background.ogg")]
-    background: Handle<AudioSource>,
+    _background: Handle<AudioSource>,
 }
 
 fn probe_game_state(_res: Res<GameStateCollection>) {}
@@ -67,7 +65,7 @@ fn probe_game_state(_res: Res<GameStateCollection>) {}
 #[derive(Resource, AssetCollection)]
 pub struct LoadingStateCollection {
     #[asset(path = "audio/yipee.ogg")]
-    yipee: Handle<AudioSource>,
+    _yipee: Handle<AudioSource>,
 }
 
 fn probe_loading_state(_res: Res<LoadingStateCollection>) {}
diff --git a/bevy_asset_loader/tests/reload_dynamic_asset_files.rs b/bevy_asset_loader/tests/reload_dynamic_asset_files.rs
index 4262d99..80c86f0 100644
--- a/bevy_asset_loader/tests/reload_dynamic_asset_files.rs
+++ b/bevy_asset_loader/tests/reload_dynamic_asset_files.rs
@@ -1,56 +1,54 @@
-#![allow(dead_code, unused_imports)]
-
 use bevy::app::AppExit;
 use bevy::audio::AudioPlugin;
 use bevy::prelude::*;
 use bevy_asset_loader::prelude::*;
 
-#[cfg(all(
-    feature = "2d",
-    feature = "3d",
-    feature = "standard_dynamic_assets",
-    not(feature = "progress_tracking"),
-))]
 #[test]
 fn main() {
-    App::new()
-        .init_state::<MyStates>()
-        .add_plugins((
-            MinimalPlugins,
-            AssetPlugin::default(),
-            AudioPlugin::default(),
-        ))
-        .insert_resource(SplashTimer(Timer::from_seconds(1.0, TimerMode::Once)))
-        .add_loading_state(
-            LoadingState::new(MyStates::SplashAssetLoading)
-                .continue_to_state(MyStates::Splash)
-                .with_dynamic_assets_file::<StandardDynamicAssetCollection>(
-                    "full_dynamic_collection.assets.ron",
-                ),
-        )
-        .add_systems(Update, splash_countdown.run_if(in_state(MyStates::Splash)))
-        .add_loading_state(
-            LoadingState::new(MyStates::MainMenuAssetLoading)
-                .continue_to_state(MyStates::MainMenu)
-                .with_dynamic_assets_file::<StandardDynamicAssetCollection>(
-                    "full_dynamic_collection.assets.ron",
-                )
-                .load_collection::<MainMenuAssets>(),
-        )
-        .add_systems(Update, (timeout, quit.run_if(in_state(MyStates::MainMenu))))
-        .run();
+    let mut app = App::new();
+    app.init_state::<MyStates>();
+
+    #[cfg(feature = "progress_tracking")]
+    app.add_plugins((
+        iyes_progress::ProgressPlugin::new(MyStates::SplashAssetLoading),
+        iyes_progress::ProgressPlugin::new(MyStates::MainMenuAssetLoading),
+    ));
+    app.add_plugins((
+        MinimalPlugins,
+        AssetPlugin::default(),
+        AudioPlugin::default(),
+    ))
+    .insert_resource(SplashTimer(Timer::from_seconds(1.0, TimerMode::Once)))
+    .add_loading_state(
+        LoadingState::new(MyStates::SplashAssetLoading)
+            .continue_to_state(MyStates::Splash)
+            .with_dynamic_assets_file::<StandardDynamicAssetCollection>(
+                "full_dynamic_collection.assets.ron",
+            ),
+    )
+    .add_systems(Update, splash_countdown.run_if(in_state(MyStates::Splash)))
+    .add_loading_state(
+        LoadingState::new(MyStates::MainMenuAssetLoading)
+            .continue_to_state(MyStates::MainMenu)
+            .with_dynamic_assets_file::<StandardDynamicAssetCollection>(
+                "full_dynamic_collection.assets.ron",
+            )
+            .load_collection::<MainMenuAssets>(),
+    )
+    .add_systems(Update, (timeout, quit.run_if(in_state(MyStates::MainMenu))))
+    .run();
 }
 
 #[derive(AssetCollection, Resource)]
 struct SplashAssets {
     #[asset(key = "single_file")]
-    another_file: Handle<AudioSource>,
+    _another_file: Handle<AudioSource>,
 }
 
 #[derive(AssetCollection, Resource)]
 struct MainMenuAssets {
     #[asset(key = "single_file")]
-    single_file: Handle<AudioSource>,
+    _single_file: Handle<AudioSource>,
 }
 
 #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]

From ca07c1fa8abddf1d855f9a69b34eff858d26f5a1 Mon Sep 17 00:00:00 2001
From: Niklas Eicker <git@nikl.me>
Date: Sat, 24 Feb 2024 12:40:41 +0100
Subject: [PATCH 2/2] Only run dynamic asset test when standard_dynamic_assets
 feature is enabled

---
 bevy_asset_loader/tests/reload_dynamic_asset_files.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bevy_asset_loader/tests/reload_dynamic_asset_files.rs b/bevy_asset_loader/tests/reload_dynamic_asset_files.rs
index 80c86f0..e204863 100644
--- a/bevy_asset_loader/tests/reload_dynamic_asset_files.rs
+++ b/bevy_asset_loader/tests/reload_dynamic_asset_files.rs
@@ -1,8 +1,11 @@
+#![allow(dead_code, unused_imports)]
+
 use bevy::app::AppExit;
 use bevy::audio::AudioPlugin;
 use bevy::prelude::*;
 use bevy_asset_loader::prelude::*;
 
+#[cfg(feature = "standard_dynamic_assets")]
 #[test]
 fn main() {
     let mut app = App::new();