echonet 1.3.2

ECHONET Lite framework for Rust
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

// Copyright (C) 2022 The uecho-rs Authors All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#[cfg(test)]
mod tests {
    use std::net::IpAddr;
    use std::sync::Arc;
    use std::sync::Mutex;
    use std::thread;
    use std::time;

    #[cfg(feature = "unix")]
    use crate::transport::interface_unix::*;

    #[cfg(not(feature = "unix"))]
    use crate::transport::interface::*;

    use crate::protocol::ESV;
    use crate::protocol::Message;
    use crate::transport::unicast_server::*;

    use crate::log::Logger;
    use crate::transport::notify_manager_test::*;

    #[test]
    fn unicast_server() {
        fn test_udp_server(ifaddr: IpAddr) {
            Logger::init();

            const TEST_OBSERVER_COUNT: i32 = 5;
            let counter = Arc::new(Mutex::new(0));

            let mut server = UnicastServer::new();

            let observer = TestNotifyCounter::new(counter.clone());
            assert!(server.add_observer(Arc::new(Mutex::new(observer))));

            assert!(server.bind(ifaddr));
            assert!(server.start());
            thread::sleep(time::Duration::from_secs(5));

            let mut msg = Message::new();
            msg.set_esv(ESV::ReadRequest);
            for _ in 0..TEST_OBSERVER_COUNT {
                let server_addr = server.ifaddr();
                assert!(server_addr.is_ok());
                assert!(server.send(server_addr.unwrap(), &msg));
                thread::sleep(time::Duration::from_secs(1));
            }

            let counter = counter.lock();
            // NOTE: GitHub Action is slow and may drop to send UDP packets.
            // assert_eq!(*counter.unwrap(), TEST_OBSERVER_COUNT);
            if counter.is_ok() {
                assert!(0 < *counter.unwrap());
            }

            assert!(server.stop());
        }

        for ifaddr in get_all_interfaces() {
            test_udp_server(ifaddr);
        }
    }
}