apeirogond 0.18.0

Daemon for Apeirogon, a cross-platform software KVM
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

// SPDX-License-Identifier: GPL-3.0-or-later

use super::*;

#[tokio::test]
async fn cross_edge_diagonal_push_uses_corner_unless_edge_exists_or_segment_is_blocked() {
    // Arrange
    for (dy, edge_neighbour, blocked, expected) in [
        (1, false, 0, Some(2)),
        (0, false, 0, None),
        (1, true, 0, Some(3)),
        (1, false, 1 << 8, None),
        (1, true, 1 << 8, None),
        (1, false, 1 << 6, Some(2)),
    ] {
        let (mut daemon, _dir, _input) = daemon(true);
        let own = daemon.identity.machine_id;
        let mut placements = vec![Placement {
            id: own,
            x: 0,
            y: 0,
            width: 100,
            height: 100,
            blocked,
        }];
        for (byte, y) in [(2, 100), (3, 0)] {
            if byte == 3 && !edge_neighbour {
                continue;
            }
            let id = MachineId::try_from(&[byte; MachineId::LEN][..]).unwrap();
            daemon.pins.add(Entry {
                machine_id: id,
                pin: daemon.identity.pin,
                name: format!("peer-{byte}"),
                spki_der: None,
                hw_addr: Some([byte; 6]),
                screen_mm: None,
            });
            placements.push(Placement {
                id,
                x: 100,
                y,
                width: 100,
                height: 100,
                blocked: u16::MAX,
            });
        }
        daemon.layout.state = daemon.layout.state.edit(placements, own).unwrap();
        daemon.wol.sender = Box::new(|_| Ok(()));
        let bounds = daemon.input.capture.as_ref().unwrap().bounds;
        let dx = i32::try_from(limits::DEFAULT_RESISTANCE_PX).unwrap();

        // Act
        daemon.cross_edge(bounds, 99, 98, dx, dy, false).await;

        // Assert
        assert_eq!(
            daemon.wol.pending.as_ref().map(|pending| pending.peer),
            expected.map(|byte| MachineId::try_from(&[byte; MachineId::LEN][..]).unwrap())
        );
    }
}