|
4 | 4 | * License, v. 2.0. If a copy of the MPL was not distributed with this
|
5 | 5 | * file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
6 | 6 | */
|
7 |
| - |
8 | 7 | use crate::framework::itest;
|
9 |
| -use crate::object_tests::call_deferred_test::TestState::{Accepted, Initial}; |
| 8 | +use godot::obj::WithBaseField; |
10 | 9 | use godot::prelude::*;
|
11 | 10 | use godot::task::{SignalFuture, TaskHandle};
|
| 11 | +use std::ops::DerefMut; |
12 | 12 |
|
13 |
| -#[derive(GodotConvert, Var, Export, Clone, PartialEq, Debug)] |
14 |
| -#[godot(via = GString)] |
15 |
| -enum TestState { |
16 |
| - Initial, |
17 |
| - Accepted, |
18 |
| -} |
| 13 | +const ACCEPTED_NAME: &str = "touched"; |
19 | 14 |
|
20 | 15 | #[derive(GodotClass)]
|
21 |
| -#[class(base=Node)] |
| 16 | +#[class(init,base=Node2D)] |
22 | 17 | struct DeferredTestNode {
|
23 |
| - base: Base<Node>, |
24 |
| - state: TestState, |
| 18 | + base: Base<Node2D>, |
25 | 19 | }
|
26 | 20 |
|
27 | 21 | #[godot_api]
|
28 | 22 | impl DeferredTestNode {
|
29 | 23 | #[signal]
|
30 |
| - fn test_completed(state: TestState); |
| 24 | + fn test_completed(name: StringName); |
31 | 25 |
|
32 | 26 | #[func]
|
33 | 27 | fn accept(&mut self) {
|
34 |
| - self.state = Accepted; |
| 28 | + self.base_mut().set_name(ACCEPTED_NAME); |
35 | 29 | }
|
36 | 30 |
|
37 |
| - fn as_expectation_task(&self) -> TaskHandle { |
38 |
| - assert_eq!(Initial, self.state, "accept evaluated synchronously"); |
| 31 | + fn to_assertion_task(&self) -> TaskHandle { |
| 32 | + assert_ne!( |
| 33 | + self.base().get_name().to_string(), |
| 34 | + ACCEPTED_NAME, |
| 35 | + "accept evaluated synchronously" |
| 36 | + ); |
39 | 37 |
|
40 |
| - let test_will_succeed: SignalFuture<(Variant,)> = |
| 38 | + let test_will_succeed: SignalFuture<(StringName,)> = |
41 | 39 | Signal::from_object_signal(&self.to_gd(), "test_completed").to_future();
|
| 40 | + |
42 | 41 | godot::task::spawn(async move {
|
43 |
| - let (final_state,) = test_will_succeed.await; |
44 |
| - let final_state: TestState = final_state.to(); |
| 42 | + let (name,) = test_will_succeed.await; |
45 | 43 |
|
46 |
| - assert_eq!(Accepted, final_state); |
| 44 | + assert_eq!(name.to_string(), ACCEPTED_NAME); |
47 | 45 | })
|
48 | 46 | }
|
49 | 47 | }
|
50 | 48 |
|
51 | 49 | #[godot_api]
|
52 |
| -impl INode for DeferredTestNode { |
53 |
| - fn init(base: Base<Self::Base>) -> Self { |
54 |
| - Self { |
55 |
| - base, |
56 |
| - state: Initial, |
57 |
| - } |
| 50 | +impl INode2D for DeferredTestNode { |
| 51 | + fn process(&mut self, _delta: f64) { |
| 52 | + let name = self.base().get_name(); |
| 53 | + self.signals().test_completed().emit(&name); |
| 54 | + self.base_mut().queue_free(); |
58 | 55 | }
|
59 | 56 |
|
60 |
| - fn process(&mut self, _delta: f64) { |
61 |
| - let args = vslice![self.state]; |
62 |
| - self.base_mut().emit_signal("test_completed", args); |
| 57 | + fn ready(&mut self) { |
| 58 | + self.base_mut().set_name("verify") |
63 | 59 | }
|
64 | 60 | }
|
65 | 61 |
|
66 | 62 | #[itest(async)]
|
67 |
| -fn calls_method_names_deferred(ctx: &crate::framework::TestContext) -> TaskHandle { |
| 63 | +fn call_deferred_untyped(ctx: &crate::framework::TestContext) -> TaskHandle { |
68 | 64 | let mut test_node = DeferredTestNode::new_alloc();
|
69 | 65 | ctx.scene_tree.clone().add_child(&test_node);
|
70 |
| - |
| 66 | + |
| 67 | + // this is called through godot binding and therefore requires #[func] on the method |
71 | 68 | test_node.call_deferred("accept", &[]);
|
72 | 69 |
|
73 |
| - let handle = test_node.bind().as_expectation_task(); |
| 70 | + let handle = test_node.bind().to_assertion_task(); |
| 71 | + handle |
| 72 | +} |
| 73 | + |
| 74 | +#[itest(async)] |
| 75 | +fn call_deferred_godot_class(ctx: &crate::framework::TestContext) -> TaskHandle { |
| 76 | + let mut test_node = DeferredTestNode::new_alloc(); |
| 77 | + ctx.scene_tree.clone().add_child(&test_node); |
| 78 | + |
| 79 | + let mut gd_mut = test_node.bind_mut(); |
| 80 | + // Explicitly check that this can be invoked on &mut T. |
| 81 | + let godot_class_ref: &mut DeferredTestNode = gd_mut.deref_mut(); |
| 82 | + godot_class_ref.apply_deferred(DeferredTestNode::accept); |
| 83 | + drop(gd_mut); |
| 84 | + |
| 85 | + let handle = test_node.bind().to_assertion_task(); |
| 86 | + handle |
| 87 | +} |
| 88 | + |
| 89 | +#[itest(async)] |
| 90 | +fn call_deferred_gd_user_class(ctx: &crate::framework::TestContext) -> TaskHandle { |
| 91 | + let mut test_node = DeferredTestNode::new_alloc(); |
| 92 | + ctx.scene_tree.clone().add_child(&test_node); |
| 93 | + |
| 94 | + test_node.apply_deferred(DeferredTestNode::accept); |
| 95 | + |
| 96 | + let handle = test_node.bind().to_assertion_task(); |
| 97 | + handle |
| 98 | +} |
| 99 | + |
| 100 | +#[itest(async)] |
| 101 | +fn call_deferred_gd_engine_class(ctx: &crate::framework::TestContext) -> TaskHandle { |
| 102 | + let test_node = DeferredTestNode::new_alloc(); |
| 103 | + ctx.scene_tree.clone().add_child(&test_node); |
| 104 | + |
| 105 | + let mut node = test_node.clone().upcast::<Node>(); |
| 106 | + node.apply_deferred(|that_node| that_node.set_name(ACCEPTED_NAME)); |
| 107 | + |
| 108 | + let handle = test_node.bind().to_assertion_task(); |
74 | 109 | handle
|
75 | 110 | }
|
0 commit comments