check wasm with atomics to run threaded tests

no feature needed

Author: PgBiel

godot-cell/tests/mock/blocking.rs

@@ -40,6 +40,10 @@ impl MyClass {
 ///
 /// This should not cause borrow failures and should not lead to deadlocks.
 #[test]
+#[cfg_attr(
+    all(target_family = "wasm", not(target_feature = "atomics")),
+    ignore = "Threading not available"
+)]
 fn calls_parallel() {
     use std::thread;
 
@@ -72,6 +76,10 @@ fn calls_parallel() {
 /// Runs each method several times in a row. This should reduce the non-determinism that comes from
 /// scheduling of threads.
 #[test]
+#[cfg_attr(
+    all(target_family = "wasm", not(target_feature = "atomics")),
+    ignore = "Threading not available"
+)]
 fn calls_parallel_many_serial() {
     use std::thread;
 
@@ -106,6 +114,10 @@ fn calls_parallel_many_serial() {
 /// Runs all the tests several times. This is different from [`calls_parallel_many_serial`] as that calls the
 /// methods like AAA...BBB...CCC..., whereas this interleaves the methods like ABC...ABC...ABC...
 #[test]
+#[cfg_attr(
+    all(target_family = "wasm", not(target_feature = "atomics")),
+    ignore = "Threading not available"
+)]
 fn calls_parallel_many_parallel() {
     use std::thread;
 
@@ -142,6 +154,10 @@ fn calls_parallel_many_parallel() {
 /// a) Thread A holds mutable reference AND thread B holds no references.
 /// b) One or more threads hold shared references AND thread A holds no references
 #[test]
+#[cfg_attr(
+    all(target_family = "wasm", not(target_feature = "atomics")),
+    ignore = "Threading not available"
+)]
 fn non_blocking_reborrow() {
     use std::thread;
     let instance_id = MyClass::init();
@@ -172,6 +188,10 @@ fn non_blocking_reborrow() {
 /// This verifies that the thread which initialized the `GdCell` does not panic when it attempts to mutably borrow while there is already a
 /// shared borrow on an other thread.
 #[test]
+#[cfg_attr(
+    all(target_family = "wasm", not(target_feature = "atomics")),
+    ignore = "Threading not available"
+)]
 fn no_mut_panic_on_main() {
     use std::thread;
     let instance_id = MyClass::init();

godot-cell/tests/mock/panicking.rs

@@ -58,6 +58,10 @@ fn all_calls_work() {
 
 /// Run each method both from the main thread and a newly created thread.
 #[test]
+#[cfg_attr(
+    all(target_family = "wasm", not(target_feature = "atomics")),
+    ignore = "Threading not available"
+)]
 fn calls_different_thread() {
     use std::thread;
 
@@ -87,6 +91,10 @@ fn calls_different_thread() {
 /// if the first call failed, so then we know the integer was incremented by 0. Otherwise, we at least know
 /// the range of values that it can be incremented by.
 #[test]
+#[cfg_attr(
+    all(target_family = "wasm", not(target_feature = "atomics")),
+    ignore = "Threading not available"
+)]
 fn calls_parallel() {
     use std::thread;
 
@@ -121,6 +129,10 @@ fn calls_parallel() {
 /// Runs each method several times in a row. This should reduce the non-determinism that comes from
 /// scheduling of threads.
 #[test]
+#[cfg_attr(
+    all(target_family = "wasm", not(target_feature = "atomics")),
+    ignore = "Threading not available"
+)]
 fn calls_parallel_many_serial() {
     use std::thread;
 
@@ -157,6 +169,10 @@ fn calls_parallel_many_serial() {
 /// Runs all the tests several times. This is different from [`calls_parallel_many_serial`] as that calls the
 /// methods like AAA...BBB...CCC..., whereas this interleaves the methods like ABC...ABC...ABC...
 #[test]
+#[cfg_attr(
+    all(target_family = "wasm", not(target_feature = "atomics")),
+    ignore = "Threading not available"
+)]
 fn calls_parallel_many_parallel() {
     use std::thread;