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

//! A Trend Log Multiple's Log_DeviceObjectProperty resized through
//! `write_local` on a running server (#1234). Writing element 0 of an array
//! whose size writes can change sets that size (Clause 12.1.5.1); the wire
//! cases are in `handlers/tests/log_reference_writes.rs`.

use super::cov_wire_test_support::*;
use super::*;
use bacnet_objects::trend::TrendLogMultipleObject;
use bacnet_types::constructed::BACnetDeviceObjectPropertyReference;
use bacnet_types::enums::ObjectType;
use bacnet_types::error::RemoteError;

const LDOP: PropertyIdentifier = PropertyIdentifier::LOG_DEVICE_OBJECT_PROPERTY;

/// [0] analog-value 1, [1] present-value.
const AV1_PV: [u8; 7] = [0x0C, 0x00, 0x80, 0x00, 0x01, 0x19, 0x55];
/// [0] analog-input 4194303, [1] present-value: an empty element.
const EMPTY: [u8; 7] = [0x0C, 0x00, 0x3F, 0xFF, 0xFF, 0x19, 0x55];

fn tlm1() -> ObjectIdentifier {
    ObjectIdentifier::new(ObjectType::TREND_LOG_MULTIPLE, 1).unwrap()
}

async fn write_local(h: &Harness, index: Option<u32>, value: PropertyValue) -> Result<(), Error> {
    h.server
        .write_local(
            &tlm1(),
            LDOP,
            index,
            value,
            None,
            crate::LocalCommandSource::ServerDevice,
        )
        .await
}

async fn read(h: &Harness, property: PropertyIdentifier, index: Option<u32>) -> PropertyValue {
    h.server
        .database()
        .read()
        .await
        .get(&tlm1())
        .unwrap()
        .read_property(property, index)
        .unwrap()
}

/// Total_Record_Count: one more for each purge's status record.
async fn total(h: &Harness) -> PropertyValue {
    read(h, PropertyIdentifier::TOTAL_RECORD_COUNT, None).await
}

fn assert_refused(result: Result<(), Error>, class: ErrorClass, code: ErrorCode) {
    assert!(
        matches!(result, Err(Error::Remote(RemoteError::Error { class: c, code: e }))
            if c == class && e == code),
        "expected {class:?} / {code:?}, got {result:?}"
    );
}

#[tokio::test(start_paused = true)]
async fn write_local_of_index_0_resizes_the_reference_array() {
    let h = Harness::start_with(ServerConfig::default(), |db| {
        let mut tlm = TrendLogMultipleObject::new(1, "TLM-1", 8).unwrap();
        tlm.add_property_reference(BACnetDeviceObjectPropertyReference::new_local(
            av1(),
            PropertyIdentifier::PRESENT_VALUE.to_raw(),
        ))
        .unwrap();
        db.add(Box::new(tlm)).unwrap();
    })
    .await;
    assert_eq!(total(&h).await, PropertyValue::Unsigned(0));

    // Growing appends empty elements and purges the log.
    write_local(&h, Some(0), PropertyValue::Unsigned(3))
        .await
        .unwrap();
    assert_eq!(read(&h, LDOP, Some(0)).await, PropertyValue::Unsigned(3));
    assert_eq!(
        read(&h, LDOP, None).await,
        PropertyValue::List(vec![
            PropertyValue::ApplicationData(AV1_PV.to_vec()),
            PropertyValue::ApplicationData(EMPTY.to_vec()),
            PropertyValue::ApplicationData(EMPTY.to_vec()),
        ])
    );
    assert_eq!(total(&h).await, PropertyValue::Unsigned(1));

    // The size already held is no change: no purge.
    write_local(&h, Some(0), PropertyValue::Unsigned(3))
        .await
        .unwrap();
    assert_eq!(total(&h).await, PropertyValue::Unsigned(1));

    // Shrinking drops the trailing elements and purges again.
    write_local(&h, Some(0), PropertyValue::Unsigned(1))
        .await
        .unwrap();
    assert_eq!(
        read(&h, LDOP, None).await,
        PropertyValue::List(vec![PropertyValue::ApplicationData(AV1_PV.to_vec())])
    );
    assert_eq!(total(&h).await, PropertyValue::Unsigned(2));

    // Past the cap, or not an Unsigned: refused, nothing changes.
    assert_refused(
        write_local(&h, Some(0), PropertyValue::Unsigned(65)).await,
        ErrorClass::RESOURCES,
        ErrorCode::NO_SPACE_TO_WRITE_PROPERTY,
    );
    assert_refused(
        write_local(&h, Some(0), PropertyValue::Real(2.0)).await,
        ErrorClass::PROPERTY,
        ErrorCode::INVALID_DATA_TYPE,
    );
    assert_eq!(read(&h, LDOP, Some(0)).await, PropertyValue::Unsigned(1));
    assert_eq!(total(&h).await, PropertyValue::Unsigned(2));
}