itests for Unique type

Some tests to check if it works as intended. More real world use-cases would help.

Author: TitanNano

check.sh

@@ -195,7 +195,7 @@ function cmd_test() {
 
 function cmd_itest() {
     findGodot && \
-        run cargo build -p itest "${extraCargoArgs[@]}" || return 1
+        run cargo build -p itest --features itest/experimental-threads --features itest/codegen-full "${extraCargoArgs[@]}" || return 1
 
     # Keep in sync with: .github/composite/godot-itest/action.yml (steps "Run Godot integration tests" and "Check for memory leaks").
 

itest/rust/src/object_tests/mod.rs

@@ -33,5 +33,8 @@ mod validate_property_test;
 mod virtual_methods_niche_test;
 mod virtual_methods_test;
 
+#[cfg(feature = "experimental-threads")]
+mod thread_safety;
+
 // Need to test this in the init level method.
 pub use init_stage_test::*;

itest/rust/src/object_tests/thread_safety.rs

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use godot::builtin::VarDictionary;
+use godot::classes::class_macros::private::virtuals::Os::Vector3;
+use godot::classes::mesh::PrimitiveType;
+use godot::classes::{ArrayMesh, Node, RefCounted, Resource};
+use godot::meta::{ToGodot, owned_into_arg};
+use godot::obj::{Gd, NewAlloc, NewGd, Unique};
+
+use crate::framework::{expect_panic_or_nothing, itest};
+
+#[itest]
+fn valid_use_case() {
+    std::thread::spawn(|| {
+        let shadow_mesh: Unique<Gd<ArrayMesh>> = Unique::new_gd();
+        let mut mesh: Unique<Gd<ArrayMesh>> = Unique::new_gd();
+
+        mesh.apply_gd(|mesh| {
+            mesh.set_shadow_mesh(shadow_mesh);
+        });
+    })
+    .join()
+    .unwrap();
+}
+
+#[itest]
+fn trying_to_cheat() {
+    std::thread::spawn(|| {
+        thread_local! {
+            static CHILD_NODE: Gd<Node> = Node::new_alloc();
+        }
+
+        let mut node = Unique::<Gd<Node>>::new_alloc();
+        let mut dict = Unique::<VarDictionary>::new();
+
+        expect_panic_or_nothing("thread should panic when passing by ref", || {
+            node.apply_gd(|node: &mut Node| {
+                let owned_node = CHILD_NODE.with(|value: &Gd<Node>| value.clone());
+                node.add_child(&owned_node);
+            });
+        });
+
+        expect_panic_or_nothing("thread should panic when passing by option ref", || {
+            node.apply_gd(|node: &mut Node| {
+                let owned_node = CHILD_NODE.with(|value: &Gd<Node>| value.clone());
+                node.set_owner(&owned_node);
+            });
+        });
+
+        expect_panic_or_nothing("thread should panic when passing object by variant", || {
+            dict.apply(|dict| {
+                let obj = RefCounted::new_gd();
+                dict.contains_key(&obj.to_variant());
+            });
+        });
+
+        expect_panic_or_nothing("thread should panic when passing by own reference", || {
+            dict.apply(|dict| {
+                let _ = dict.insert("key", &dict.clone());
+            });
+        });
+
+        expect_panic_or_nothing("thread should panic when passing by Gd<T> by value", || {
+            node.apply_gd(|node: &mut Node| {
+                let owned_node = CHILD_NODE.with(|value: &Gd<Node>| value.clone());
+                node.add_child(owned_into_arg(owned_node));
+            });
+        });
+
+        // Test clean-up to avoid memory leaks.
+        CHILD_NODE.with(|value| value.clone().free());
+        node.share().free();
+    })
+    .join()
+    .unwrap();
+}
+
+#[itest]
+fn recursive_unique_check() {
+    let resource = Resource::new_gd();
+
+    let unique_res = Unique::try_from_ref_counted(resource);
+
+    assert!(
+        unique_res.is_some(),
+        "Uniqueness verification with a single ref should succeed"
+    );
+
+    let resource = unique_res.unwrap().share();
+    let second_ref = resource.clone();
+
+    assert!(
+        Unique::try_from_ref_counted(resource).is_none(),
+        "Uniqueness verification with two refs should fail"
+    );
+
+    drop(second_ref);
+}
+
+#[itest]
+#[cfg(feature = "codegen-full")]
+fn sub_thread_surface_tool() {
+    use godot::classes::SurfaceTool;
+
+    let result = std::thread::spawn(|| {
+        let mut builder: Gd<SurfaceTool> = SurfaceTool::new_gd();
+
+        builder.begin(PrimitiveType::TRIANGLES);
+        builder.add_vertex(Vector3::new(1.0, 1.0, 1.0));
+        builder.add_vertex(Vector3::new(1.0, 2.0, 1.0));
+        builder.add_vertex(Vector3::new(1.0, 1.0, 2.0));
+
+        let existing_mesh: Unique<Gd<ArrayMesh>> = Unique::new_gd();
+
+        let result = builder.commit_ex().existing(existing_mesh).done().unwrap();
+
+        Unique::try_from_ref_counted(result).unwrap()
+    })
+    .join()
+    .expect("sub-thread should not have paniced");
+
+    assert_eq!(result.share().get_reference_count(), 1);
+}