Merge pull request #195 from NiklasEi/run_more_integration_test_for_a…

…ll_tested_feature_combinations Enable more integration tests to run with all tested feature combinations
NiklasEi · Feb 24, 2024 · 5971c0c · 5971c0c
2 parents 68627b3 + e388189
commit 5971c0c
Show file tree

Hide file tree

Showing 8 changed files with 159 additions and 184 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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::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
@@ -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
@@ -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,15 +57,15 @@ 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>) {}
 
 #[derive(Resource, AssetCollection)]
 pub struct LoadingStateCollection {
     #[asset(path = "audio/yipee.ogg")]
-    yipee: Handle<AudioSource>,
+    _yipee: Handle<AudioSource>,
 }
 
 fn probe_loading_state(_res: Res<LoadingStateCollection>) {}