mechutil 0.8.0

Utility structures and functions for mechatronics applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//
// Copyright (C) 2024 Automated Design Corp.. All Rights Reserved.
// Created Date: 2024-09-05 14:03:45
// -----
// Last Modified: 2024-09-05 16:08:10
// -----
//
//

use mechutil::actor::MechActor;
use std::sync::{Arc, Mutex};
use tokio::time::{Duration, sleep};

struct ActorStructExample {
    actor: MechActor,
    pub tick_count: Arc<Mutex<usize>>,
    pub async_count: Arc<tokio::sync::Mutex<usize>>,
}

impl ActorStructExample {
    pub fn new() -> Self {
        Self {
            actor: MechActor::new(std::time::Duration::from_millis(1000)),
            tick_count: Arc::new(Mutex::new(0)),
            async_count: Arc::new(tokio::sync::Mutex::new(0)),
        }
    }

    pub async fn start(&mut self) {
        let counter_1 = self.tick_count.clone();
        let _ = self
            .actor
            .register_tick(move || {
                let mut l = counter_1.lock().unwrap();
                *l += 1;
                println!("actor 2 tick 1 ");
            })
            .await;

        let counter_2 = self.tick_count.clone();
        let _ = self
            .actor
            .register_tick(move || {
                let mut l = counter_2.lock().unwrap();
                *l += 1;
                println!("actor 2 tick 2 ");
            })
            .await;

        let counter_3 = self.async_count.clone();
        if let Err(err) = self
            .actor
            .register_async_tick(move || {
                let async_counter = counter_3.clone();
                Box::pin(async move {
                    let mut l = async_counter.lock().await;
                    *l += 1;
                    println!("async actor 2 TICKING ASYNC, BABY!");
                })
            })
            .await
        {
            println!("Failed to register async tick: {}", err);
        }

        println!("SpawnTest registered tick callback");
    }

    pub async fn stop(&mut self) {
        let _ = self.actor.shutdown().await;
        println!("SpawnTest shutdown.");
    }
}

/// Integration test for the `MechActor` behavior
/// This test will simulate the actor's ticking functionality, both sync and async.
#[tokio::test]
async fn test_mech_actor() {
    let test_count = Arc::new(Mutex::new(0));

    // Initialize the main actor instance
    let handle = MechActor::new(Duration::from_millis(1000));

    // Initialize the test struct with an actor and start it
    let mut st = ActorStructExample::new();
    st.start().await;

    // Register additional ticks for the main actor
    let counter_1 = test_count.clone();
    let _ = handle
        .register_tick(move || {
            let mut l = counter_1.lock().unwrap();
            *l += 1;
            println!("actor 1 tick 1");
        })
        .await;

    // Stall the test for 3 seconds to allow tick events to fire
    sleep(Duration::from_millis(3000)).await;

    // Shut down the actor after ticks
    let _ = handle.shutdown().await;
    st.stop().await;

    println!("Test finished. Actors shut down.");

    // You can add assertions here to check any expected behavior, logs, or side effects
    // Example:
    // assert_eq!(/* some condition */, /* expected value */);

    {
        let l = test_count.lock().unwrap();
        assert!(*l != 0);
    }

    {
        let l = st.tick_count.lock().unwrap();
        assert!(*l != 0);
    }

    {
        let l = st.async_count.lock().await;
        assert!(*l != 0);
    }
}