Add test for Varargs to tuple conversion

Author: B-head

test/src/test_register.rs

@@ -8,6 +8,7 @@ pub(crate) fn run_tests() -> bool {
 
     status &= test_register_property();
     status &= test_advanced_methods();
+    status &= test_varargs_to_tuple();
 
     status
 }
@@ -16,6 +17,7 @@ pub(crate) fn register(handle: InitHandle) {
     handle.add_class::<RegisterSignal>();
     handle.add_class::<RegisterProperty>();
     handle.add_class::<AdvancedMethods>();
+    handle.add_class::<VarargsToTuple>();
 }
 
 #[derive(Copy, Clone, Debug, Default)]
@@ -232,3 +234,57 @@ fn test_advanced_methods() -> bool {
 
     ok
 }
+
+#[derive(NativeClass)]
+#[inherit(Reference)]
+#[register_with(VarargsToTuple::register)]
+struct VarargsToTuple {}
+
+#[methods]
+impl VarargsToTuple {
+    fn new(_owner: TRef<Reference>) -> Self {
+        VarargsToTuple {}
+    }
+
+    fn register(builder: &ClassBuilder<VarargsToTuple>) {
+        builder.method("calc", CalcMethod).done();
+    }
+}
+
+struct CalcMethod;
+
+impl Method<VarargsToTuple> for CalcMethod {
+    fn call(
+        &self,
+        _this: TInstance<'_, VarargsToTuple>,
+        args: gdnative::export::Varargs<'_>,
+    ) -> Variant {
+        let (a, b, c): (i64, i64, i64) =
+            std::convert::TryInto::try_into(args).expect("Must be able to convert");
+        let ret = a * b - c;
+        ret.to_variant()
+    }
+}
+
+fn test_varargs_to_tuple() -> bool {
+    println!(" -- test_varargs_to_tuple");
+
+    let ok = std::panic::catch_unwind(|| {
+        let thing = Instance::<VarargsToTuple, _>::new();
+        let base = thing.base();
+
+        assert_eq!(Some(7), unsafe {
+            base.call(
+                "calc",
+                &[3_i64.to_variant(), 4_i64.to_variant(), 5_i64.to_variant()],
+            )
+            .to()
+        });
+    })
+    .is_ok();
+
+    if !ok {
+        godot_error!("   !! Test test_varargs_to_tuple failed");
+    }
+    ok
+}