Disable printing during expected panics

Author: Bromeon

godot-core/src/lib.rs

@@ -42,7 +42,7 @@ pub mod private {
 
     use crate::{log, sys};
 
-    sys::plugin_registry!(__GODOT_PLUGIN_REGISTRY: ClassPlugin);
+    sys::plugin_registry!(pub __GODOT_PLUGIN_REGISTRY: ClassPlugin);
 
     pub(crate) fn iterate_plugins(mut visitor: impl FnMut(&ClassPlugin)) {
         sys::plugin_foreach!(__GODOT_PLUGIN_REGISTRY; visitor);

godot-ffi/src/plugins.rs

@@ -15,12 +15,12 @@
 #[doc(hidden)]
 #[macro_export]
 macro_rules! plugin_registry {
-    ($registry:ident: $Type:ty) => {
+    ($vis:vis $registry:ident: $Type:ty) => {
         $crate::paste::paste! {
             #[used]
             #[allow(non_upper_case_globals)]
             #[doc(hidden)]
-            pub static [< __godot_rust_plugin_ $registry >]:
+            $vis static [< __godot_rust_plugin_ $registry >]:
                 std::sync::Mutex<Vec<$Type>> = std::sync::Mutex::new(Vec::new());
         }
     };

godot-macros/src/itest.rs

@@ -54,6 +54,8 @@ pub fn transform(input: TokenStream) -> Result<TokenStream, Error> {
 
         ::godot::sys::plugin_add!(__GODOT_ITEST in crate; crate::TestCase {
             name: #test_name_str,
+            file: std::file!(),
+            line: std::line!(),
             function: #test_name,
         });
     })

itest/rust/src/lib.rs

@@ -5,10 +5,13 @@
  */
 
 use godot::bind::{godot_api, GodotClass};
+use godot::builtin::ToVariant;
+use godot::engine::utilities::print_rich;
 use godot::init::{gdextension, ExtensionLibrary};
 use godot::sys;
 use godot::test::itest;
-use std::panic::UnwindSafe;
+use std::collections::HashSet;
+use std::panic;
 
 mod array_test;
 mod base_test;
@@ -29,17 +32,8 @@ mod utilities_test;
 mod variant_test;
 mod virtual_methods_test;
 
-
-#[derive(Copy, Clone)]
-pub struct TestCase {
-    name: &'static str,
-    function: fn(),
-}
-
 #[must_use]
 fn run_test(test: &TestCase) -> bool {
-    println!("   -- {}", test.name);
-
     // Explicit type to prevent tests from returning a value
     let success: Option<()> =
         godot::private::handle_panic(|| format!("   !! Test {} failed", test.name), test.function);
@@ -49,31 +43,25 @@ fn run_test(test: &TestCase) -> bool {
 
 sys::plugin_registry!(__GODOT_ITEST: TestCase);
 
-// fn register_classes() {
-//     object_test::register();
-//     gdscript_ffi_test::register();
-//     virtual_methods_test::register();
-// }
-
-fn run_tests() -> bool {
-    let mut tests: Vec<TestCase> = vec![];
-
-    sys::plugin_foreach!(__GODOT_ITEST; |test: &TestCase| {
-        tests.push(*test);
-    });
-
-    println!("Collected {} tests.", tests.len());
-
-
-    let mut stats = TestStats::default();
-    for test in tests {
-        stats.tests_run += 1;
-        if run_test(&test) {
-            stats.tests_passed += 1;
-        }
+fn print_test(test: &TestCase, passed: bool, last_file: &mut Option<&'static str>) {
+    // Check if we need to open a new category for a file
+    let print_file = last_file.map_or(true, |last_file| last_file != test.file);
+    if print_file {
+        let sep_pos = test.file.rfind(&['/', '\\']).unwrap_or(0);
+        println!("\n   {}:", &test.file[sep_pos + 1..]);
     }
 
-    stats.tests_run == stats.tests_passed
+    // Print the test itself
+    let outcome = if passed {
+        "[color=green]ok[/color]"
+    } else {
+        "[color=red]FAILED[/color]"
+    };
+    let output = format!("   -- {} ... {}", test.name, outcome);
+    print_rich(output.to_variant(), &[]);
+
+    // State update for file-category-print
+    *last_file = Some(test.file);
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
@@ -84,28 +72,85 @@ unsafe impl ExtensionLibrary for IntegrationTests {}
 
 #[derive(GodotClass, Debug)]
 #[class(base=Node, init)]
-struct IntegrationTests {}
+struct IntegrationTests {
+    tests_run: i64,
+    tests_passed: i64,
+    tests_skipped: i64,
+}
 
 #[godot_api]
 impl IntegrationTests {
+    // TODO could return a Stats object with properties in the future
     #[func]
-    fn test_all(&mut self) -> bool {
+    fn test_all(&mut self) {
         println!("Run Godot integration tests...");
-        run_tests()
+        self.run_tests();
+    }
+
+    #[func]
+    fn num_run(&self) -> i64 {
+        self.tests_run
+    }
+
+    #[func]
+    fn num_passed(&self) -> i64 {
+        self.tests_passed
+    }
+
+    #[func]
+    fn num_skipped(&self) -> i64 {
+        self.tests_skipped
+    }
+
+    fn run_tests(&mut self) {
+        let mut tests: Vec<TestCase> = vec![];
+
+        let mut all_files = HashSet::new();
+        sys::plugin_foreach!(__GODOT_ITEST; |test: &TestCase| {
+            all_files.insert(test.file);
+            tests.push(*test);
+        });
+
+        println!(
+            "Rust: found {} tests in {} files.",
+            tests.len(),
+            all_files.len()
+        );
+
+        let mut last_file = None;
+        for test in tests {
+            let passed = run_test(&test);
+
+            self.tests_run += 1;
+            if passed {
+                self.tests_passed += 1;
+            }
+
+            print_test(&test, passed, &mut last_file);
+        }
     }
 }
 
-pub(crate) fn expect_panic(context: &str, code: impl FnOnce() + UnwindSafe) {
-    let panic = std::panic::catch_unwind(code);
+pub(crate) fn expect_panic(context: &str, code: impl FnOnce() + panic::UnwindSafe) {
+    // Exchange panic hook, to disable printing during expected panics
+    let prev_hook = panic::take_hook();
+    panic::set_hook(Box::new(|_panic_info| {}));
+
+    // Run code that should panic, restore hook
+    let panic = panic::catch_unwind(code);
+    panic::set_hook(prev_hook);
+
     assert!(
         panic.is_err(),
         "code should have panicked but did not: {context}",
     );
 }
 
-#[derive(Default)]
-struct TestStats {
-    tests_run: usize,
-    tests_passed: usize,
-    tests_skipped: usize,
+#[derive(Copy, Clone)]
+struct TestCase {
+    name: &'static str,
+    file: &'static str,
+    #[allow(dead_code)]
+    line: u32,
+    function: fn(),
 }