fn try_from(header: crate::ecss::tm::PusTmSecondaryHeader) -> Result<Self, Self::Error> {

            if header.pus_version != PusVersion::PusC {

            }

            Ok(PusTmSecHeaderWithoutTimestamp {

                pus_version_and_sc_time_ref_status: ((header.pus_version as u8) << 4)

                    | header.sc_time_ref_status,

                service: header.service,

                subservice: header.subservice,

                msg_counter: U16::from(header.msg_counter),

                dest_id: U16::from(header.dest_id),

            })

        }

        pub fn write_to_bytes(&self, slice: &mut [u8]) -> Option<()> {

            self.write_to(slice)

        }

        pub fn from_bytes(slice: &[u8]) -> Option<Self> {

            Self::read_from(slice)

        }

        fn pus_version(&self) -> PusVersion {

            PusVersion::try_from(self.pus_version_and_sc_time_ref_status >> 4 & 0b1111)

                .unwrap_or(PusVersion::Invalid)

        }

        fn sc_time_ref_status(&self) -> u8 {

            self.pus_version_and_sc_time_ref_status & 0b1111

        }

        fn service(&self) -> u8 {

            self.service

        }

        fn subservice(&self) -> u8 {

            self.subservice

        }

        fn msg_counter(&self) -> u16 {

            self.msg_counter.get()

        }

        fn dest_id(&self) -> u16 {

            self.dest_id.get()

        }

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

    pub fn new_simple(service: u8, subservice: u8, timestamp: &'stamp [u8]) -> Self {

        Self::new(service, subservice, 0, 0, timestamp)

    }

    pub fn new_simple_no_timestamp(service: u8, subservice: u8) -> Self {

        Self::new(service, subservice, 0, 0, &[])

    }

    pub fn new(

        service: u8,

        subservice: u8,

        msg_counter: u16,

        dest_id: u16,

        timestamp: &'stamp [u8],

    ) -> Self {

        PusTmSecondaryHeader {

            pus_version: PusVersion::PusC,

            sc_time_ref_status: 0,

            service,

            subservice,

            msg_counter,

            dest_id,

            timestamp,

        }

    }

    fn pus_version(&self) -> PusVersion {

        self.pus_version

    }

    fn sc_time_ref_status(&self) -> u8 {

        self.sc_time_ref_status

    }

    fn service(&self) -> u8 {

        self.service

    }

    fn subservice(&self) -> u8 {

        self.subservice

    }

    fn msg_counter(&self) -> u16 {

        self.msg_counter

    }

    fn dest_id(&self) -> u16 {

        self.dest_id

    }

    fn try_from(sec_header: zc::PusTmSecHeader<'slice>) -> Result<Self, Self::Error> {

        Ok(PusTmSecondaryHeader {

            pus_version: sec_header.zc_header.pus_version(),

            sc_time_ref_status: sec_header.zc_header.sc_time_ref_status(),

            service: sec_header.zc_header.service(),

            subservice: sec_header.zc_header.subservice(),

            msg_counter: sec_header.zc_header.msg_counter(),

            dest_id: sec_header.zc_header.dest_id(),

            timestamp: sec_header.timestamp,

        })

    }

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

    pub fn new(

        mut sp_header: SpHeader,

        sec_header: PusTmSecondaryHeader<'time>,

        source_data: &'src_data [u8],

        set_ccsds_len: bool,

    ) -> Self {

        sp_header.set_packet_type(PacketType::Tm);

        sp_header.set_sec_header_flag();

        let mut pus_tm = Self {

            sp_header,

            source_data,

            sec_header,

            calc_crc_on_serialization: true,

        };

        if set_ccsds_len {

            pus_tm.update_ccsds_data_len();

        }

        pus_tm

    }

    pub fn new_simple(

        sp_header: SpHeader,

        service: u8,

        subservice: u8,

        time_provider: &impl TimeWriter,

        stamp_buf: &'time mut [u8],

        source_data: &'src_data [u8],

        set_ccsds_len: bool,

    ) -> Result<Self, TimestampError> {

        let stamp_size = time_provider.write_to_bytes(stamp_buf)?;

        let sec_header =

            PusTmSecondaryHeader::new_simple(service, subservice, &stamp_buf[0..stamp_size]);

        Ok(Self::new(sp_header, sec_header, source_data, set_ccsds_len))

    }

    pub fn new_no_source_data(

        sp_header: SpHeader,

        sec_header: PusTmSecondaryHeader<'time>,

        set_ccsds_len: bool,

    ) -> Self {

        Self::new(sp_header, sec_header, &[], set_ccsds_len)

    }

    pub fn timestamp(&self) -> &[u8] {

        self.sec_header.timestamp

    }

    pub fn source_data(&self) -> &[u8] {

        self.source_data

    }

    pub fn set_dest_id(&mut self, dest_id: u16) {

        self.sec_header.dest_id = dest_id;

    }

    pub fn set_msg_counter(&mut self, msg_counter: u16) {

        self.sec_header.msg_counter = msg_counter

    }

    pub fn set_sc_time_ref_status(&mut self, sc_time_ref_status: u8) {

        self.sec_header.sc_time_ref_status = sc_time_ref_status & 0b1111;

    }

    pub fn update_ccsds_data_len(&mut self) {

        self.sp_header.data_len =

            self.len_written() as u16 - size_of::<crate::zc::SpHeader>() as u16 - 1;

    }

    pub fn calc_own_crc16(&self) -> u16 {

        let mut digest = CRC_CCITT_FALSE.digest();

        let sph_zc = crate::zc::SpHeader::from(self.sp_header);

        digest.update(sph_zc.as_bytes());

        let pus_tc_header = zc::PusTmSecHeaderWithoutTimestamp::try_from(self.sec_header).unwrap();

        digest.update(pus_tc_header.as_bytes());

        digest.update(self.sec_header.timestamp);

        digest.update(self.source_data);

        digest.finalize()

    }

    pub fn update_packet_fields(&mut self) {

        self.update_ccsds_data_len();

    }

    pub fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, ByteConversionError> {

        let mut curr_idx = 0;

        let total_size = self.len_written();

        if total_size > slice.len() {

            return Err(ByteConversionError::ToSliceTooSmall {

                found: slice.len(),

                expected: total_size,

            });

        }

        self.sp_header

            .write_to_be_bytes(&mut slice[0..CCSDS_HEADER_LEN])?;

        curr_idx += CCSDS_HEADER_LEN;

        let sec_header_len = size_of::<zc::PusTmSecHeaderWithoutTimestamp>();

        let sec_header = zc::PusTmSecHeaderWithoutTimestamp::try_from(self.sec_header).unwrap();

        sec_header

            .write_to_bytes(&mut slice[curr_idx..curr_idx + sec_header_len])

            .ok_or(ByteConversionError::ZeroCopyToError)?;

        curr_idx += sec_header_len;

        slice[curr_idx..curr_idx + self.sec_header.timestamp.len()]

            .copy_from_slice(self.sec_header.timestamp);

        curr_idx += self.sec_header.timestamp.len();

        slice[curr_idx..curr_idx + self.source_data.len()].copy_from_slice(self.source_data);

        curr_idx += self.source_data.len();

        let mut digest = CRC_CCITT_FALSE.digest();

        digest.update(&slice[0..curr_idx]);

        slice[curr_idx..curr_idx + 2].copy_from_slice(&digest.finalize().to_be_bytes());

        curr_idx += 2;

        Ok(curr_idx)

    }

    pub fn append_to_vec(&self, vec: &mut Vec<u8>) -> Result<usize, PusError> {

        let sph_zc = crate::zc::SpHeader::from(self.sp_header);

        let mut appended_len = PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA + self.sec_header.timestamp.len();

        appended_len += self.source_data.len();

        let start_idx = vec.len();

        vec.extend_from_slice(sph_zc.as_bytes());

        // The PUS version is hardcoded to PUS C

        let sec_header = zc::PusTmSecHeaderWithoutTimestamp::try_from(self.sec_header).unwrap();

        vec.extend_from_slice(sec_header.as_bytes());

        vec.extend_from_slice(self.sec_header.timestamp);

        vec.extend_from_slice(self.source_data);

        let mut digest = CRC_CCITT_FALSE.digest();

        digest.update(&vec[start_idx..start_idx + appended_len - 2]);

        vec.extend_from_slice(&digest.finalize().to_be_bytes());

        Ok(appended_len)

    }

    fn len_written(&self) -> usize {

        PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA

            + self.sec_header.timestamp.len()

            + self.source_data.len()

    }

    fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, PusError> {

        Ok(Self::write_to_bytes(self, slice)?)

    }

    fn eq(&self, other: &Self) -> bool {

        self.sp_header == other.sp_header

            && self.sec_header == other.sec_header

            && self.source_data == other.source_data

    }

        fn pus_version(&self) -> PusVersion;

        fn service(&self) -> u8;

        fn subservice(&self) -> u8;

    fn user_data(&self) -> &[u8] {

        self.source_data

    }

    fn crc16(&self) -> Option<u16> {

        Some(self.calc_own_crc16())

    }

        fn pus_version(&self) -> PusVersion;

        fn service(&self) -> u8;

        fn subservice(&self) -> u8;

        fn dest_id(&self) -> u16;

        fn msg_counter(&self) -> u16;

        fn sc_time_ref_status(&self) -> u8;

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

    pub fn new(slice: &'raw_data [u8], timestamp_len: usize) -> Result<(Self, usize), PusError> {

        let raw_data_len = slice.len();

        if raw_data_len < PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA {

            return Err(ByteConversionError::FromSliceTooSmall {

                found: raw_data_len,

                expected: PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA,

            }

            .into());

        }

        let mut current_idx = 0;

        let (sp_header, _) = SpHeader::from_be_bytes(&slice[0..CCSDS_HEADER_LEN])?;

        current_idx += 6;

        let total_len = sp_header.total_len();

        if raw_data_len < total_len {

            return Err(ByteConversionError::FromSliceTooSmall {

                found: raw_data_len,

                expected: total_len,

            }

            .into());

        }

        if total_len < PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA {

        }

        let sec_header_zc = zc::PusTmSecHeaderWithoutTimestamp::from_bytes(

            &slice[current_idx..current_idx + PUS_TM_MIN_SEC_HEADER_LEN],

        )

        .ok_or(ByteConversionError::ZeroCopyFromError)?;

        current_idx += PUS_TM_MIN_SEC_HEADER_LEN;

        let zc_sec_header_wrapper = zc::PusTmSecHeader {

            zc_header: sec_header_zc,

            timestamp: &slice[current_idx..current_idx + timestamp_len],

        };

        current_idx += timestamp_len;

        let raw_data = &slice[0..total_len];

        let pus_tm = Self {

            sp_header,

            sec_header: PusTmSecondaryHeader::try_from(zc_sec_header_wrapper).unwrap(),

            raw_data: &slice[0..total_len],

            source_data: user_data_from_raw(current_idx, total_len, slice)?,

            crc16: crc_from_raw_data(raw_data)?,

        verify_crc16_ccitt_false_from_raw_to_pus_error(raw_data, pus_tm.crc16)?;

        Ok((pus_tm, total_len))

    }

    pub fn len_packed(&self) -> usize {

        self.sp_header.total_len()

    }

    pub fn source_data(&self) -> &[u8] {

        self.user_data()

    }

    pub fn timestamp(&self) -> &[u8] {

        self.sec_header.timestamp

    }

    pub fn raw_data(&self) -> &[u8] {

        self.raw_data

    }

    fn eq(&self, other: &Self) -> bool {

        self.sec_header == other.sec_header

            && self.source_data == other.source_data

            && self.sp_header == other.sp_header

            && self.crc16 == other.crc16

    }

        fn pus_version(&self) -> PusVersion;

        fn service(&self) -> u8;

        fn subservice(&self) -> u8;

    fn user_data(&self) -> &[u8] {

        self.source_data

    }

    fn crc16(&self) -> Option<u16> {

        Some(self.crc16)

    }

        fn pus_version(&self) -> PusVersion;

        fn service(&self) -> u8;

        fn subservice(&self) -> u8;

        fn dest_id(&self) -> u16;

        fn msg_counter(&self) -> u16;

        fn sc_time_ref_status(&self) -> u8;

    fn eq(&self, other: &PusTmReader<'_>) -> bool {

        self.sp_header == other.sp_header

            && self.sec_header == other.sec_header

            && self.source_data == other.source_data

    }

    pub fn new(raw_tm: &'raw mut [u8], timestamp_len: usize) -> Option<Self> {

        let raw_tm_len = raw_tm.len();

        if raw_tm_len < CCSDS_HEADER_LEN + PUS_TM_MIN_SEC_HEADER_LEN + timestamp_len {

        }

        let sp_header = crate::zc::SpHeader::from_bytes(&raw_tm[0..CCSDS_HEADER_LEN]).unwrap();

        if raw_tm_len < sp_header.total_len() {

        }

        let writer = Self {

            raw_tm: &mut raw_tm[..sp_header.total_len()],

            timestamp_len,

        };

        Some(writer)

    }

    pub fn set_apid(&mut self, apid: u16) -> bool {

        if apid > MAX_APID {

            return false;

        }

        // Clear APID part of the raw packet ID

        let updated_apid =

            ((((self.raw_tm[0] as u16) << 8) | self.raw_tm[1] as u16) & !MAX_APID) | apid;

        self.raw_tm[0..2].copy_from_slice(&updated_apid.to_be_bytes());

        true

    }

    pub fn set_msg_count(&mut self, msg_count: u16) {

        self.raw_tm[9..11].copy_from_slice(&msg_count.to_be_bytes());

    }

    pub fn set_destination_id(&mut self, dest_id: u16) {

        self.raw_tm[11..13].copy_from_slice(&dest_id.to_be_bytes())

    }

    pub fn sp_header(&self) -> crate::zc::SpHeader {

        // Valid minimum length of packet was checked before.

        crate::zc::SpHeader::from_bytes(&self.raw_tm[0..CCSDS_HEADER_LEN]).unwrap()

    }

    pub fn sec_header_without_timestamp(&self) -> PusTmSecHeaderWithoutTimestamp {

        // Valid minimum length of packet was checked before.

        PusTmSecHeaderWithoutTimestamp::from_bytes(

            &self.raw_tm[CCSDS_HEADER_LEN..CCSDS_HEADER_LEN + PUS_TM_MIN_SEC_HEADER_LEN],

        )

        .unwrap()

    }

    pub fn set_seq_count(&mut self, seq_count: u16) -> bool {

        if seq_count > MAX_SEQ_COUNT {

        }

        let new_psc =

            (u16::from_be_bytes(self.raw_tm[2..4].try_into().unwrap()) & 0xC000) | seq_count;

        self.raw_tm[2..4].copy_from_slice(&new_psc.to_be_bytes());

        true

    }

    pub fn finish(self) {

        let slice_len = self.raw_tm.len();

        let crc16 = calc_pus_crc16(&self.raw_tm[..slice_len - 2]);

        self.raw_tm[slice_len - 2..].copy_from_slice(&crc16.to_be_bytes());

    }

    fn packet_id(&self) -> crate::PacketId {

        self.sp_header().packet_id()

    }

    fn psc(&self) -> crate::PacketSequenceCtrl {

        self.sp_header().psc()

    }

    fn service(&self) -> u8 {

        self.raw_tm[7]

    }

    fn subservice(&self) -> u8 {

        self.raw_tm[8]

    }

    fn user_data(&self) -> &[u8] {

        &self.raw_tm[CCSDS_HEADER_LEN + PUS_TM_MIN_SEC_HEADER_LEN + self.timestamp_len

            ..self.sp_header().total_len() - 2]

    }

    fn crc16(&self) -> Option<u16> {

        Some(u16::from_be_bytes(

            self.raw_tm[self.sp_header().total_len() - 2..self.sp_header().total_len()]

                .try_into()

                .unwrap(),

        ))

    }

            fn msg_counter(&self) -> u16;

            fn dest_id(&self) -> u16;

    fn base_ping_reply_full_ctor(timestamp: &[u8]) -> PusTmCreator {

        let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();

        let tm_header = PusTmSecondaryHeader::new_simple(17, 2, timestamp);

        PusTmCreator::new_no_source_data(sph, tm_header, true)

    }

    fn ping_reply_with_data(timestamp: &[u8]) -> PusTmCreator {

        let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();

        let tm_header = PusTmSecondaryHeader::new_simple(17, 2, timestamp);

        PusTmCreator::new(sph, tm_header, DUMMY_DATA, true)

    }

    fn base_hk_reply<'a, 'b>(timestamp: &'a [u8], src_data: &'b [u8]) -> PusTmCreator<'a, 'b> {

        let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();

        let tc_header = PusTmSecondaryHeader::new_simple(3, 5, timestamp);

        PusTmCreator::new(sph, tc_header, src_data, true)

    }

    fn dummy_timestamp() -> &'static [u8] {

        &[0, 1, 2, 3, 4, 5, 6]

    }

    fn test_basic() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        verify_ping_reply(&pus_tm, false, 22, dummy_timestamp());

    }

    fn test_basic_simple_api() {

        let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();

        let time_provider = CdsTime::new_with_u16_days(0, 0);

        let mut stamp_buf: [u8; 8] = [0; 8];

        let pus_tm =

            PusTmCreator::new_simple(sph, 17, 2, &time_provider, &mut stamp_buf, &[], true)

                .unwrap();

        verify_ping_reply(&pus_tm, false, 22, &[64, 0, 0, 0, 0, 0, 0]);

    }

    fn test_serialization_no_source_data() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        let mut buf: [u8; 32] = [0; 32];

        let ser_len = pus_tm

            .write_to_bytes(&mut buf)

            .expect("Serialization failed");

        assert_eq!(ser_len, 22);

        verify_raw_ping_reply(pus_tm.crc16().unwrap(), &buf);

    }

    fn test_serialization_with_source_data() {

        let src_data = [1, 2, 3];

        let hk_reply = base_hk_reply(dummy_timestamp(), &src_data);

        let mut buf: [u8; 32] = [0; 32];

        let ser_len = hk_reply

            .write_to_bytes(&mut buf)

            .expect("Serialization failed");

        assert_eq!(ser_len, 25);

        assert_eq!(buf[20], 1);

        assert_eq!(buf[21], 2);

        assert_eq!(buf[22], 3);

    }

    fn test_setters() {

        let timestamp = dummy_timestamp();

        let mut pus_tm = base_ping_reply_full_ctor(timestamp);

        pus_tm.set_sc_time_ref_status(0b1010);

        pus_tm.set_dest_id(0x7fff);

        pus_tm.set_msg_counter(0x1f1f);

        assert_eq!(pus_tm.sc_time_ref_status(), 0b1010);

        assert_eq!(pus_tm.dest_id(), 0x7fff);

        assert_eq!(pus_tm.msg_counter(), 0x1f1f);

        assert!(pus_tm.set_apid(0x7ff));

        assert_eq!(pus_tm.apid(), 0x7ff);

    }

    fn test_write_into_vec() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        let tm_vec = pus_tm.to_vec().expect("Serialization failed");

        assert_eq!(tm_vec.len(), 22);

        let (tm_deserialized, size) =

            PusTmReader::new(tm_vec.as_slice(), 7).expect("Deserialization failed");

        assert_eq!(tm_vec.len(), size);

        verify_ping_reply_with_reader(&tm_deserialized, false, 22, dummy_timestamp());

    }

    fn test_deserialization_no_source_data() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        let mut buf: [u8; 32] = [0; 32];

        let ser_len = pus_tm

            .write_to_bytes(&mut buf)

            .expect("Serialization failed");

        assert_eq!(ser_len, 22);

        let (tm_deserialized, size) = PusTmReader::new(&buf, 7).expect("Deserialization failed");

        assert_eq!(ser_len, size);

        assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());

        assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);

        assert_eq!(tm_deserialized.crc16().unwrap(), pus_tm.crc16().unwrap());

        verify_ping_reply_with_reader(&tm_deserialized, false, 22, dummy_timestamp());

    }

    fn test_deserialization_faulty_crc() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        let mut buf: [u8; 32] = [0; 32];

        let ser_len = pus_tm

            .write_to_bytes(&mut buf)

            .expect("Serialization failed");

        assert_eq!(ser_len, 22);

        buf[ser_len - 2] = 0;

        buf[ser_len - 1] = 0;

        let tm_error = PusTmReader::new(&buf, 7);

        assert!(tm_error.is_err());

        let tm_error = tm_error.unwrap_err();

        if let PusError::ChecksumFailure(crc) = tm_error {

            assert_eq!(crc, 0);

            assert_eq!(

                tm_error.to_string(),

                "checksum verification for crc16 0x0000 failed"

            );

    }

    fn test_manual_field_update() {

        let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();

        let tc_header = PusTmSecondaryHeader::new_simple(17, 2, dummy_timestamp());

        let mut tm = PusTmCreator::new_no_source_data(sph, tc_header, false);

        tm.calc_crc_on_serialization = false;

        assert_eq!(tm.data_len(), 0x00);

        let mut buf: [u8; 32] = [0; 32];

        tm.update_ccsds_data_len();

        assert_eq!(tm.data_len(), 15);

        tm.calc_own_crc16();

        let res = tm.write_to_bytes(&mut buf);

        assert!(res.is_ok());

        tm.sp_header.data_len = 0;

        tm.update_packet_fields();

        assert_eq!(tm.data_len(), 15);

    }

    fn test_target_buf_too_small() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        let mut buf: [u8; 16] = [0; 16];

        let res = pus_tm.write_to_bytes(&mut buf);

        assert!(res.is_err());

        let error = res.unwrap_err();

        if let ByteConversionError::ToSliceTooSmall { found, expected } = error {

            assert_eq!(expected, 22);

            assert_eq!(found, 16);

    }

    fn test_append_to_vec() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        let mut vec = Vec::new();

        let res = pus_tm.append_to_vec(&mut vec);

        assert!(res.is_ok());

        assert_eq!(res.unwrap(), 22);

        verify_raw_ping_reply(pus_tm.crc16().unwrap(), vec.as_slice());

    }

    fn test_append_to_vec_with_src_data() {

        let src_data = [1, 2, 3];

        let hk_reply = base_hk_reply(dummy_timestamp(), &src_data);

        let mut vec = Vec::new();

        vec.push(4);

        let res = hk_reply.append_to_vec(&mut vec);

        assert!(res.is_ok());

        assert_eq!(res.unwrap(), 25);

        assert_eq!(vec.len(), 26);

    }

    fn verify_raw_ping_reply(crc16: u16, buf: &[u8]) {

        // Secondary header is set -> 0b0000_1001 , APID occupies last bit of first byte

        assert_eq!(buf[0], 0x09);

        assert_eq!(buf[1], 0x23);

        assert_eq!(buf[2], 0xc2);

        assert_eq!(buf[3], 0x34);

        assert_eq!(((buf[4] as u16) << 8) | buf[5] as u16, 15);

        assert_eq!(buf[6], (PusC as u8) << 4);

        assert_eq!(buf[7], 17);

        assert_eq!(buf[8], 2);

        assert_eq!(buf[9], 0x00);

        assert_eq!(buf[10], 0x00);

        assert_eq!(buf[11], 0x00);

        assert_eq!(buf[12], 0x00);

        assert_eq!(&buf[13..20], dummy_timestamp());

        let mut digest = CRC_CCITT_FALSE.digest();

        digest.update(&buf[0..20]);

        let crc16_calced = digest.finalize();

        assert_eq!(((crc16 >> 8) & 0xff) as u8, buf[20]);

        assert_eq!((crc16 & 0xff) as u8, buf[21]);

        assert_eq!(crc16, crc16_calced);

    }

    fn verify_ping_reply(

        tm: &PusTmCreator,

        has_user_data: bool,

        exp_full_len: usize,

        exp_timestamp: &[u8],

    ) {

        assert_eq!(tm.len_written(), exp_full_len);

        assert_eq!(tm.timestamp(), exp_timestamp);

        assert_eq!(tm.source_data(), tm.user_data());

        verify_ping_reply_generic(tm, has_user_data, exp_full_len);

    }

    fn verify_ping_reply_with_reader(

        tm: &PusTmReader,

        has_user_data: bool,

        exp_full_len: usize,

        exp_timestamp: &[u8],

    ) {

        assert_eq!(tm.len_packed(), exp_full_len);

        assert_eq!(tm.timestamp(), exp_timestamp);

        verify_ping_reply_generic(tm, has_user_data, exp_full_len);

    }

    fn verify_ping_reply_generic(

        tm: &(impl CcsdsPacket + GenericPusTmSecondaryHeader + PusPacket),

        has_user_data: bool,

        exp_full_len: usize,

    ) {

        assert!(tm.is_tm());

        assert_eq!(PusPacket::service(tm), 17);

        assert_eq!(GenericPusTmSecondaryHeader::service(tm), 17);

        assert_eq!(PusPacket::subservice(tm), 2);

        assert_eq!(GenericPusTmSecondaryHeader::subservice(tm), 2);

        assert!(tm.sec_header_flag());

        if has_user_data {

        }

        assert_eq!(PusPacket::pus_version(tm), PusC);

        assert_eq!(tm.apid(), 0x123);

        assert_eq!(tm.seq_count(), 0x234);

        assert_eq!(PusPacket::pus_version(tm), PusVersion::PusC);

        assert_eq!(

            GenericPusTmSecondaryHeader::pus_version(tm),

            PusVersion::PusC

        );

        assert_eq!(tm.data_len(), exp_full_len as u16 - 7);

        assert_eq!(tm.dest_id(), 0x0000);

        assert_eq!(tm.msg_counter(), 0x0000);

        assert_eq!(tm.sc_time_ref_status(), 0b0000);

    }

    fn partial_eq_pus_tm() {

        let timestamp = dummy_timestamp();

        let pus_tm_1 = base_ping_reply_full_ctor(timestamp);

        let pus_tm_2 = base_ping_reply_full_ctor(timestamp);

        assert_eq!(pus_tm_1, pus_tm_2);

    }

    fn partial_eq_serialized_vs_derialized() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        let mut buf = [0; 32];

        pus_tm.write_to_bytes(&mut buf).unwrap();

        assert_eq!(pus_tm, PusTmReader::new(&buf, timestamp.len()).unwrap().0);

    }

    fn test_zero_copy_writer() {

        let ping_tm = base_ping_reply_full_ctor(dummy_timestamp());

        let mut buf: [u8; 64] = [0; 64];

        let tm_size = ping_tm

            .write_to_bytes(&mut buf)

            .expect("writing PUS ping TM failed");

        let mut writer = PusTmZeroCopyWriter::new(&mut buf[..tm_size], 7)

            .expect("Creating zero copy writer failed");

        writer.set_destination_id(55);

        writer.set_msg_count(100);

        writer.set_seq_count(MAX_SEQ_COUNT);

        writer.set_apid(MAX_APID);

        assert!(!writer.set_apid(MAX_APID + 1));

        assert!(!writer.set_apid(MAX_SEQ_COUNT + 1));

        writer.finish();

        // This performs all necessary checks, including the CRC check.

        let (tm_read_back, tm_size_read_back) =

            PusTmReader::new(&buf, 7).expect("Re-creating PUS TM failed");

        assert_eq!(tm_size_read_back, tm_size);

        assert_eq!(tm_read_back.msg_counter(), 100);

        assert_eq!(tm_read_back.dest_id(), 55);

        assert_eq!(tm_read_back.seq_count(), MAX_SEQ_COUNT);

        assert_eq!(tm_read_back.apid(), MAX_APID);

    }

    fn test_zero_copy_writer_ccsds_api() {

        let ping_tm = base_ping_reply_full_ctor(dummy_timestamp());

        let mut buf: [u8; 64] = [0; 64];

        let tm_size = ping_tm

            .write_to_bytes(&mut buf)

            .expect("writing PUS ping TM failed");

        let mut writer = PusTmZeroCopyWriter::new(&mut buf[..tm_size], 7)

            .expect("Creating zero copy writer failed");

        writer.set_destination_id(55);

        writer.set_msg_count(100);

        writer.set_seq_count(MAX_SEQ_COUNT);

        writer.set_apid(MAX_APID);

        assert_eq!(PusPacket::service(&writer), 17);

        assert_eq!(PusPacket::subservice(&writer), 2);

        assert_eq!(writer.apid(), MAX_APID);

        assert_eq!(writer.seq_count(), MAX_SEQ_COUNT);

    }

    fn test_zero_copy_pus_api() {

        let ping_tm = ping_reply_with_data(dummy_timestamp());

        let mut buf: [u8; 64] = [0; 64];

        let tm_size = ping_tm

            .write_to_bytes(&mut buf)

            .expect("writing PUS ping TM failed");

        let crc16_raw = u16::from_be_bytes(buf[tm_size - 2..tm_size].try_into().unwrap());

        let mut writer = PusTmZeroCopyWriter::new(&mut buf[..tm_size], 7)

            .expect("Creating zero copy writer failed");

        writer.set_destination_id(55);

        writer.set_msg_count(100);

        writer.set_seq_count(MAX_SEQ_COUNT);

        writer.set_apid(MAX_APID);

        assert_eq!(PusPacket::service(&writer), 17);

        assert_eq!(PusPacket::subservice(&writer), 2);

        assert_eq!(writer.dest_id(), 55);

        assert_eq!(writer.msg_counter(), 100);

        assert_eq!(writer.sec_header_without_timestamp().dest_id(), 55);

        assert_eq!(writer.sec_header_without_timestamp().msg_counter(), 100);

        assert_eq!(writer.user_data(), DUMMY_DATA);

        let crc16 = writer.crc16();

        assert!(crc16.is_some());

        assert_eq!(crc16.unwrap(), crc16_raw);

        writer.finish();

    }

    fn test_sec_header_without_stamp() {

        let sec_header = PusTmSecondaryHeader::new_simple_no_timestamp(17, 1);

        assert_eq!(sec_header.timestamp, &[]);

    }

    fn test_reader_partial_eq() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        let mut buf = [0; 32];

        pus_tm.write_to_bytes(&mut buf).unwrap();

        let (tm_0, _) = PusTmReader::new(&buf, timestamp.len()).unwrap();

        let (tm_1, _) = PusTmReader::new(&buf, timestamp.len()).unwrap();

        assert_eq!(tm_0, tm_1);

    }

    fn test_reader_buf_too_small_2() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        let mut buf = [0; 32];

        let written = pus_tm.write_to_bytes(&mut buf).unwrap();

        let tm_error = PusTmReader::new(

            &buf[0..PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA + 1],

            timestamp.len(),

        );

        assert!(tm_error.is_err());

        let tm_error = tm_error.unwrap_err();

            found,

            expected,

        }) = tm_error

            assert_eq!(found, PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA + 1);

            assert_eq!(expected, written);

    }

    fn test_reader_buf_too_small() {

        let timestamp = dummy_timestamp();

        let pus_tm = base_ping_reply_full_ctor(timestamp);

        let mut buf = [0; 32];

        pus_tm.write_to_bytes(&mut buf).unwrap();

        let tm_error = PusTmReader::new(&buf[0..5], timestamp.len());

        assert!(tm_error.is_err());

        let tm_error = tm_error.unwrap_err();

            found,

            expected,

        }) = tm_error

            assert_eq!(found, 5);

            assert_eq!(expected, PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA);

    }

    fn test_serialization_creator_serde() {

        let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();

        let time_provider = CdsTime::new_with_u16_days(0, 0);

        let mut stamp_buf: [u8; 8] = [0; 8];

        let pus_tm =

            PusTmCreator::new_simple(sph, 17, 2, &time_provider, &mut stamp_buf, &[], true)

                .unwrap();

        let output = to_allocvec(&pus_tm).unwrap();

        let output_converted_back: PusTmCreator = from_bytes(&output).unwrap();

        assert_eq!(output_converted_back, pus_tm);

    }

    fn test_serialization_reader_serde() {

        let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();

        let time_provider = CdsTime::new_with_u16_days(0, 0);

        let mut stamp_buf: [u8; 8] = [0; 8];

        let pus_tm =

            PusTmCreator::new_simple(sph, 17, 2, &time_provider, &mut stamp_buf, &[], true)

                .unwrap();

        let pus_tm_vec = pus_tm.to_vec().unwrap();

        let (tm_reader, _) = PusTmReader::new(&pus_tm_vec, time_provider.len_as_bytes()).unwrap();

        let output = to_allocvec(&tm_reader).unwrap();

        let output_converted_back: PusTmReader = from_bytes(&output).unwrap();

        assert_eq!(output_converted_back, tm_reader);

    }