cu29-runtime 1.1.3

Copper Runtime Runtime crate. Copper is an engine for robotics.
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

mod payload_clearing {
    use cu29::copperlist::CuListsManager;
    use cu29::prelude::*;

    gen_cumsgs!("tests/payload_clearing.ron");

    #[test]
    fn test_clear_default_tuple_vector_payload() {
        let mut msgs = cumsgs::CuStampedDataSet::default();
        msgs.0.0.clear_payload();
        assert!(msgs.0.0.payload().is_none());
    }

    #[test]
    fn test_drop_unused_tuple_vector_pool() {
        drop(CuListsManager::<cumsgs::CuStampedDataSet, 3>::new());
    }

    // Reproduces https://github.com/copper-project/copper-rs/issues/1395.
    #[test]
    fn test_clear_fresh_copperlist_tuple_vector_payload() {
        let mut lists = CuListsManager::<cumsgs::CuStampedDataSet, 3>::new();
        for _ in 0..3 {
            let list = lists.create().unwrap();
            assert!(list.msgs.0.0.payload().is_none());
            list.msgs.0.0.clear_payload();
            assert!(list.msgs.0.0.payload().is_none());
        }
    }

    #[test]
    fn test_reuse_preserves_tuple_vector_payload() {
        let mut lists = CuListsManager::<cumsgs::CuStampedDataSet, 1>::new();
        let list = lists.create().unwrap();
        list.msgs.0.0.set_payload((true, vec![1, 2, 3]));
        list.msgs.0.0.metadata.set_status("previous cycle");
        list.msgs.0.0.metadata.process_time.start = CuTime::from_nanos(42).into();
        let address = list as *const _;
        lists.pop().unwrap();

        let reused = lists.create().unwrap();
        assert_eq!(reused as *const _, address);
        assert_eq!(reused.id, 1);
        let (flag, values) = reused.msgs.0.0.payload().unwrap();
        assert!(*flag);
        assert_eq!(values, &vec![1, 2, 3]);
        assert!(reused.msgs.0.0.metadata.status_txt.0.is_empty());
        assert!(reused.msgs.0.0.metadata.process_time.start.is_none());
        reused.msgs.0.0.clear_payload();
    }

    #[cfg(any(feature = "async-cl-io", feature = "parallel-rt"))]
    #[test]
    fn test_clear_fresh_boxed_tuple_vector_payload() {
        #[cfg(feature = "parallel-rt")]
        for mut list in cu29::curuntime::allocate_boxed_copperlists::<cumsgs::CuStampedDataSet, 3>()
        {
            assert!(list.msgs.0.0.payload().is_none());
            list.msgs.0.0.clear_payload();
        }

        #[cfg(feature = "async-cl-io")]
        {
            let mut lists =
                cu29::curuntime::AsyncCopperListsManager::<cumsgs::CuStampedDataSet, 3>::new(None)
                    .unwrap();
            for _ in 0..3 {
                let list = lists.create().unwrap();
                assert!(list.msgs.0.0.payload().is_none());
                list.msgs.0.0.clear_payload();
                list.change_state(cu29::copperlist::CopperListState::Processing);
                let id = list.id;
                lists.end_of_processing(id).unwrap();
            }
        }
    }
}

mod large_payload_initialization {
    use cu29::copperlist::CuListsManager;
    use cu29::prelude::*;

    gen_cumsgs!("tests/large_payload_initialization.ron");

    #[test]
    fn test_large_payload_initializes_on_small_stack() {
        std::thread::Builder::new()
            .stack_size(128 * 1024)
            .spawn(|| {
                let mut lists = CuListsManager::<cumsgs::CuStampedDataSet, 2>::new();
                for _ in 0..2 {
                    let list = lists.create().unwrap();
                    assert!(list.msgs.0.0.0.payload().is_none());
                    assert!(list.msgs.0.0.1.payload().is_none());
                }
            })
            .unwrap()
            .join()
            .unwrap();
    }
}