1 
//! PUS Service 5 Events
2 
use num_enum::{IntoPrimitive, TryFromPrimitive};
3 
#[cfg(feature = "serde")]
4 
use serde::{Deserialize, Serialize};
5 

            

        

            

                6
            

            

                4
            

            

                
#[derive(Debug, Eq, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]

            

        

            

                7
            

            

                
            

            

                
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

            

        

            

                8
            

            

                
            

            

                
#[repr(u8)]

            

        

            

                9
            

            

                
            

            

                
pub enum Subservice {

            

        

            

                10
            

            

                
            

            

                
    TmInfoReport = 1,

            

        

            

                11
            

            

                
            

            

                
    TmLowSeverityReport = 2,

            

        

            

                12
            

            

                
            

            

                
    TmMediumSeverityReport = 3,

            

        

            

                13
            

            

                
            

            

                
    TmHighSeverityReport = 4,

            

        

            

                14
            

            

                
            

            

                
    TcEnableEventGeneration = 5,

            

        

            

                15
            

            

                
            

            

                
    TcDisableEventGeneration = 6,

            

        

            

                16
            

            

                
            

            

                
    TcReportDisabledList = 7,

            

        

            

                17
            

            

                
            

            

                
    TmDisabledEventsReport = 8,

            

        

            

                18
            

            

                
            

            

                
}

            

        

            

                19
            

            

                
            

            

                

            

        

            

                20
            

            

                
            

            

                
#[cfg(test)]

            

        

            

                21
            

            

                
            

            

                
mod tests {

            

        

            

                22
            

            

                
            

            

                
    use super::*;

            

        

            

                23
            

            

                
            

            

                

            

        

            

                24
            

            

                
            

            

                
    #[test]

            

        

            

                25
            

            

                2
            

            

                
    fn test_conv_into_u8() {

            

        

            

                26
            

            

                2
            

            

                
        let subservice: u8 = Subservice::TmLowSeverityReport.into();

            

        

            

                27
            

            

                2
            

            

                
        assert_eq!(subservice, 2);

            

        

            

                28
            

            

                2
            

            

                
    }

            

        

            

                29
            

            

                
            

            

                

            

        

            

                30
            

            

                
            

            

                
    #[test]

            

        

            

                31
            

            

                2
            

            

                
    fn test_conv_from_u8() {

            

        

            

                32
            

            

                2
            

            

                
        let subservice: Subservice = 2.try_into().unwrap();

            

        

            

                33
            

            

                2
            

            

                
        assert_eq!(subservice, Subservice::TmLowSeverityReport);

            

        

            

                34
            

            

                2
            

            

                
    }

            

        

            

                35
            

            

                
            

            

                

            

        

            

                36
            

            

                
            

            

                
    #[test]

            

        

            

                37
            

            

                2
            

            

                
    fn test_conv_fails() {

            

        

            

                38
            

            

                2
            

            

                
        let conversion = Subservice::try_from(9);

            

        

            

                39
            

            

                2
            

            

                
        assert!(conversion.is_err());

            

        

            

                40
            

            

                2
            

            

                
        let err = conversion.unwrap_err();

            

        

            

                41
            

            

                2
            

            

                
        assert_eq!(err.number, 9);

            

        

            

                42
            

            

                2
            

            

                
    }

            

        

            

                43
            

            

                
            

            

                
}