bacnet-server 0.15.0

BACnet server: APDU dispatch and service handlers
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Table 13-6's event-priority → NPDU-priority projection (issue #187).
//!
//! Clause 13.2.5.4 uses Table 13-6 to map alarm/event priority to the
//! Clause 6.2.2 Network Priority. The assertion target is the encoded NPDU
//! control octet, not the
//! notification's APDU `priority` field — the APDU field was always right;
//! the NPDU bits were always Normal.
//!
//! Split from `event_notifications_tests.rs`, which is near the 700-LOC cap.

use super::event_recipient_route::network_priority_for_event;
use super::event_recipient_routing_tests::{
    address_recipient, destination_for, distribute_with_priority,
};
use bacnet_encoding::npdu::decode_npdu;
use bacnet_npdu::NetworkPriority;
use bytes::Bytes;

/// Every band edge of Table 13-6, both ends.
#[test]
fn table_13_6_band_boundaries() {
    for (event_priority, expected) in [
        (0u8, NetworkPriority::LifeSafety),
        (63, NetworkPriority::LifeSafety),
        (64, NetworkPriority::CriticalEquipment),
        (127, NetworkPriority::CriticalEquipment),
        (128, NetworkPriority::Urgent),
        (191, NetworkPriority::Urgent),
        (192, NetworkPriority::Normal),
        (255, NetworkPriority::Normal),
    ] {
        assert_eq!(
            network_priority_for_event(event_priority),
            expected,
            "event priority {event_priority}"
        );
    }
}

fn npdu_priority(frame: &Bytes) -> NetworkPriority {
    decode_npdu(frame.clone()).expect("decode NPDU").priority
}

/// An unconfirmed notification's NPDU carries the projected priority, at
/// both edges of every Table 13-6 band.
#[tokio::test]
async fn unconfirmed_notification_npdu_carries_projected_priority() {
    for (event_priority, expected) in [
        (0u8, NetworkPriority::LifeSafety),
        (63, NetworkPriority::LifeSafety),
        (64, NetworkPriority::CriticalEquipment),
        (127, NetworkPriority::CriticalEquipment),
        (128, NetworkPriority::Urgent),
        (191, NetworkPriority::Urgent),
        (192, NetworkPriority::Normal),
        (255, NetworkPriority::Normal),
    ] {
        let (broadcasts, unicasts) = distribute_with_priority(
            [event_priority; 3],
            vec![destination_for(address_recipient(0, &[]), false)],
        )
        .await;

        assert_eq!(broadcasts.len(), 1, "event priority {event_priority}");
        assert!(unicasts.is_empty());
        assert_eq!(
            npdu_priority(&broadcasts[0]),
            expected,
            "event priority {event_priority}"
        );
    }
}

/// The confirmed path — including its retry loop's send site — carries the
/// projected priority too.
#[tokio::test]
async fn confirmed_notification_npdu_carries_projected_priority() {
    let mac = [0x0A, 0x00, 0x00, 0x64, 0xBA, 0xC0];
    let (broadcasts, unicasts) = distribute_with_priority(
        [0; 3],
        vec![destination_for(address_recipient(0, &mac), true)],
    )
    .await;

    assert!(broadcasts.is_empty());
    assert_eq!(unicasts.len(), 1, "confirmed unicast goes out");
    assert_eq!(unicasts[0].0, mac);
    assert_eq!(npdu_priority(&unicasts[0].1), NetworkPriority::LifeSafety);
}

/// Every unconfirmed route shape carries the projected priority — each send
/// site is a separate call, and any one of them can regress alone.
#[tokio::test]
async fn every_unconfirmed_route_carries_projected_priority() {
    let remote_mac = [0x0A, 0x00, 0x00, 0x64, 0xBA, 0xC0];
    let recipients = [
        address_recipient(0, &[]),
        address_recipient(1000, &[]),
        address_recipient(65535, &[]),
        address_recipient(1000, &remote_mac),
    ];
    for recipient in recipients {
        let (broadcasts, unicasts) =
            distribute_with_priority([0; 3], vec![destination_for(recipient.clone(), false)]).await;

        assert_eq!(broadcasts.len(), 1, "route {recipient:?} goes out");
        assert!(unicasts.is_empty());
        assert_eq!(
            npdu_priority(&broadcasts[0]),
            NetworkPriority::LifeSafety,
            "route {recipient:?}"
        );
    }

    // The local-unicast site sends on the unicast path instead.
    let local_mac = [0x0A, 0x00, 0x00, 0x07, 0xBA, 0xC0];
    let (broadcasts, unicasts) = distribute_with_priority(
        [0; 3],
        vec![destination_for(address_recipient(0, &local_mac), false)],
    )
    .await;
    assert!(broadcasts.is_empty());
    assert_eq!(unicasts.len(), 1);
    assert_eq!(npdu_priority(&unicasts[0].1), NetworkPriority::LifeSafety);
}