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

            

        

            

                6
            

            

                2
            

            

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

            

        

            

                7
            

            

                
            

            

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

            

        

            

                8
            

            

                
            

            

                
#[repr(u8)]

            

        

            

                9
            

            

                
            

            

                
pub enum Subservice {

            

        

            

                10
            

            

                
            

            

                
    TmAcceptanceSuccess = 1,

            

        

            

                11
            

            

                
            

            

                
    TmAcceptanceFailure = 2,

            

        

            

                12
            

            

                
            

            

                
    TmStartSuccess = 3,

            

        

            

                13
            

            

                
            

            

                
    TmStartFailure = 4,

            

        

            

                14
            

            

                
            

            

                
    TmStepSuccess = 5,

            

        

            

                15
            

            

                
            

            

                
    TmStepFailure = 6,

            

        

            

                16
            

            

                
            

            

                
    TmCompletionSuccess = 7,

            

        

            

                17
            

            

                
            

            

                
    TmCompletionFailure = 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::TmCompletionSuccess.into();

            

        

            

                27
            

            

                2
            

            

                
        assert_eq!(subservice, 7);

            

        

            

                28
            

            

                2
            

            

                
    }

            

        

            

                29
            

            

                
            

            

                

            

        

            

                30
            

            

                
            

            

                
    #[test]

            

        

            

                31
            

            

                2
            

            

                
    fn test_conv_from_u8() {

            

        

            

                32
            

            

                2
            

            

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

            

        

            

                33
            

            

                2
            

            

                
        assert_eq!(subservice, Subservice::TmCompletionSuccess);

            

        

            

                34
            

            

                2
            

            

                
    }

            

        

            

                35
            

            

                
            

            

                
}