async_foundation/net/
mod.rs

1#![cfg(feature = "net")]
2
3use std::{mem::MaybeUninit, time::Instant};
4
5use mio::Token;
6
7use crate::net::io_event_listener::IOEventListener;
8pub mod io_event_listener;
9pub mod io_event_listener_state;
10pub mod tcp_stream;
11pub mod timeouts;
12pub mod udp_socket;
13
14pub fn event_listener() -> &'static mut IOEventListener {
15    static mut SINGLETON: MaybeUninit<IOEventListener> = MaybeUninit::uninit();
16    static ONCE: std::sync::Once = std::sync::Once::new();
17    unsafe {
18        ONCE.call_once(|| {
19            SINGLETON =
20                MaybeUninit::new(IOEventListener::new().expect("Can't create IOEventListener"));
21        });
22        let singleton_ref = &raw mut SINGLETON;
23        (*singleton_ref).assume_init_mut()
24    }
25}
26
27#[derive(PartialEq, Debug)]
28pub struct TokenTimeout {
29    pub token: Token,
30    pub timeout: Instant,
31}
32
33impl TokenTimeout {
34    pub fn new(token: Token, timeout: Instant) -> Self {
35        TokenTimeout { token, timeout }
36    }
37}
38
39#[cfg(test)]
40mod tests {
41    use super::*;
42    use std::time::Duration;
43
44    #[test]
45    fn test_token_timeout_new() {
46        let token = Token(42);
47        let timeout = Instant::now();
48        let token_timeout = TokenTimeout::new(token, timeout);
49        
50        assert_eq!(token_timeout.token, token);
51        assert_eq!(token_timeout.timeout, timeout);
52    }
53
54    #[test]
55    fn test_token_timeout_debug() {
56        let token = Token(123);
57        let timeout = Instant::now();
58        let token_timeout = TokenTimeout::new(token, timeout);
59        
60        let debug_str = format!("{:?}", token_timeout);
61        assert!(debug_str.contains("TokenTimeout"));
62        assert!(debug_str.contains("123"));
63    }
64
65    #[test]
66    fn test_token_timeout_partial_eq() {
67        let token1 = Token(1);
68        let token2 = Token(2);
69        let timeout1 = Instant::now();
70        let timeout2 = timeout1 + Duration::from_secs(1);
71        
72        let tt1 = TokenTimeout::new(token1, timeout1);
73        let tt2 = TokenTimeout::new(token1, timeout1);
74        let tt3 = TokenTimeout::new(token2, timeout1);
75        let tt4 = TokenTimeout::new(token1, timeout2);
76        
77        assert_eq!(tt1, tt2); // Same token and timeout
78        assert_ne!(tt1, tt3); // Different token
79        assert_ne!(tt1, tt4); // Different timeout
80    }
81
82    #[test]
83    fn test_mio_waker_token_constant() {
84        use crate::net::io_event_listener_state::MIO_WAKER_TOKEN;
85        assert_eq!(MIO_WAKER_TOKEN, Token(0));
86    }
87}