rs-teststand 0.0.8

Community Rust bindings (twin API) for the National Instruments TestStand™ COM API
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

//! Which licence an application is asking for.

/// The kind of licence an application requests (`ApplicationLicenses`).
///
/// A host asks for the least it needs. Requesting an editor licence on a
/// station that only has a deployment one fails, so asking high "to be safe"
/// is how a station that would have worked refuses to start.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ApplicationLicense {
    /// Let the engine decide.
    Unspecified,
    /// An operator interface: runs sequences, does not edit them. The right
    /// request for a headless host.
    OperatorInterface,
    /// A custom sequence editor.
    CustomEditor,
    /// The full sequence editor.
    SequenceEditor,
}

impl ApplicationLicense {
    /// Maps the engine's number onto a request.
    ///
    /// # Errors
    /// The raw value, when it is one this build does not name.
    pub const fn from_bits(bits: i32) -> Result<Self, i32> {
        match bits {
            0 => Ok(Self::Unspecified),
            100 => Ok(Self::OperatorInterface),
            200 => Ok(Self::CustomEditor),
            300 => Ok(Self::SequenceEditor),
            unknown => Err(unknown),
        }
    }

    /// The engine's number for this request.
    #[must_use]
    pub const fn bits(self) -> i32 {
        match self {
            Self::Unspecified => 0,
            Self::OperatorInterface => 100,
            Self::CustomEditor => 200,
            Self::SequenceEditor => 300,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::ApplicationLicense;

    #[test]
    fn every_documented_value_round_trips() {
        for kind in [
            ApplicationLicense::Unspecified,
            ApplicationLicense::OperatorInterface,
            ApplicationLicense::CustomEditor,
            ApplicationLicense::SequenceEditor,
        ] {
            assert_eq!(ApplicationLicense::from_bits(kind.bits()), Ok(kind));
        }
    }

    #[test]
    fn the_values_are_not_ordinals() {
        // Spaced by hundreds in the type library. Treating them as 0..3 would
        // request the wrong licence and fail on a correctly licensed station.
        assert_eq!(ApplicationLicense::OperatorInterface.bits(), 100);
        assert_eq!(ApplicationLicense::SequenceEditor.bits(), 300);
        assert_eq!(ApplicationLicense::from_bits(1), Err(1));
    }
}