wl-proxy 0.1.2

Wayland connection proxy
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

use {
    crate::{
        client::ClientHandler,
        object::ObjectCoreApi,
        protocols::ObjectInterface,
        test_framework::proxy::{TestProxy, TestProxyClient, dispatch_blocking, test_proxy},
    },
    std::{cell::Cell, rc::Rc},
};

#[test]
fn disconnected() {
    let TestProxy {
        _proxy_destructor,
        proxy_state,
        client:
            TestProxyClient {
                _destructor: client_destructor,
                proxy_client,
                proxy_test: _proxy_test,
                state: client_state,
                display: client_display,
                test: client_test,
                fd: client_fd,
            },
        ..
    } = test_proxy();

    drop(client_destructor);
    drop(client_state);
    drop(client_display);
    drop(client_test);
    drop(client_fd);

    struct H(Rc<Cell<bool>>);
    impl ClientHandler for H {
        fn disconnected(self: Box<Self>) {
            self.0.set(true);
        }
    }
    let disconnected = Rc::new(Cell::new(false));
    proxy_client.set_handler(H(disconnected.clone()));
    assert!(!disconnected.get());
    while !disconnected.get() {
        dispatch_blocking([&proxy_state]).unwrap();
    }

    struct H2(Rc<Cell<bool>>);
    impl ClientHandler for H2 {}
    impl Drop for H2 {
        fn drop(&mut self) {
            self.0.set(true);
        }
    }
    let dropped = Rc::new(Cell::new(false));
    proxy_client.set_handler(H2(dropped.clone()));
    assert!(dropped.get());
}

#[test]
fn unset_handler() {
    struct H2(Rc<Cell<bool>>);
    impl ClientHandler for H2 {}
    impl Drop for H2 {
        fn drop(&mut self) {
            self.0.set(true);
        }
    }
    let dropped = Rc::new(Cell::new(false));
    let tp = test_proxy();
    tp.client.proxy_client.set_handler(H2(dropped.clone()));

    assert!(!dropped.get());
    tp.client.proxy_client.unset_handler();
    assert!(dropped.get());
}

#[test]
fn objects() {
    let tp = test_proxy();
    let mut objects = vec![];
    tp.client.proxy_client.objects(&mut objects);
    assert_eq!(objects.len(), 3);
    let mut has_display = false;
    let mut has_registry = false;
    let mut has_test = false;
    for obj in objects {
        use ObjectInterface::*;
        match obj.interface() {
            WlDisplay => has_display = true,
            WlRegistry => has_registry = true,
            WlproxyTest => has_test = true,
            _ => unreachable!(),
        }
    }
    assert!(has_display);
    assert!(has_registry);
    assert!(has_test);

    let mut objects = vec![];
    tp.client.proxy_client.disconnect();
    tp.client.proxy_client.objects(&mut objects);
    assert_eq!(objects.len(), 0);
}