zbus 5.18.0

API for D-Bus communication
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

#![cfg(all(unix, feature = "p2p"))]

use std::os::unix::net::UnixStream;

use ntest::timeout;
use test_log::test;
use zbus::{Guid, block_on, connection::Builder};

#[test]
#[timeout(15000)]
fn closed_resolves_when_peer_disconnects() {
    block_on(async {
        let (s0, s1) = UnixStream::pair().unwrap();
        let guid = Guid::generate();

        let server_builder = Builder::unix_stream(s0).server(guid).unwrap().p2p();
        let client_builder = Builder::unix_stream(s1).p2p();

        let (server, client) = futures_util::join!(server_builder.build(), client_builder.build());
        let server = server.unwrap();
        let client = client.unwrap();

        assert!(!server.is_closed());

        // Drop the client connection, closing the socket.
        drop(client);

        // closed() should resolve now that the peer is gone.
        server.closed().await;
        assert!(server.is_closed());
    });
}

#[test]
#[timeout(15000)]
fn closed_resolves_on_explicit_close() {
    block_on(async {
        let (s0, s1) = UnixStream::pair().unwrap();
        let guid = Guid::generate();

        let server_builder = Builder::unix_stream(s0).server(guid).unwrap().p2p();
        let client_builder = Builder::unix_stream(s1).p2p();

        let (server, client) = futures_util::join!(server_builder.build(), client_builder.build());
        let server = server.unwrap();
        let client = client.unwrap();

        assert!(!client.is_closed());

        client.close().await.unwrap();

        // closed() should resolve after an explicit close() call.
        server.closed().await;
        assert!(server.is_closed());
    });
}

#[test]
#[timeout(15000)]
fn closed_resolves_immediately_if_already_closed() {
    block_on(async {
        let (s0, s1) = UnixStream::pair().unwrap();
        let guid = Guid::generate();

        let server_builder = Builder::unix_stream(s0).server(guid).unwrap().p2p();
        let client_builder = Builder::unix_stream(s1).p2p();

        let (server, client) = futures_util::join!(server_builder.build(), client_builder.build());
        let server = server.unwrap();
        let client = client.unwrap();

        drop(client);
        server.closed().await;

        // Calling closed() again should return immediately.
        server.closed().await;
        assert!(server.is_closed());
    });
}