fn try_from(v: u8) -> Result<Self, Self::Error> {

        match v {

            1 => Ok(FractionalResolution::FourMs),

            2 => Ok(FractionalResolution::FifteenUs),

            3 => Ok(FractionalResolution::SixtyNs),

    }

pub fn convert_fractional_part_to_ns(fractional_part: FractionalPart) -> u64 {

    let div = fractional_res_to_div(fractional_part.resolution);

    assert!(fractional_part.counter <= div);

    10_u64.pow(9) * fractional_part.counter as u64 / div as u64

}

pub const fn fractional_res_to_div(res: FractionalResolution) -> u32 {

    // We do not use the full possible range for a given resolution. This is because if we did

    // that, the largest value would be equal to the counter being incremented by one. Thus, the

    // smallest allowed fractions value is 0 while the largest allowed fractions value is the

    // closest fractions value to the next counter increment.

    2_u32.pow(8 * res as u32) - 1

}

pub fn fractional_part_from_subsec_ns(res: FractionalResolution, ns: u64) -> FractionalPart {

    if res == FractionalResolution::Seconds {

        return FractionalPart::new_with_seconds_resolution();

    }

    let sec_as_ns = 10_u64.pow(9);

    if ns > sec_as_ns {

    }

    let resolution_divisor = fractional_res_to_div(res) as u64;

    // This is probably the cheapest way to calculate the fractional part without using expensive

    // floating point division.

    let fractional_counter = ns * (resolution_divisor + 1) / sec_as_ns;

    FractionalPart {

        resolution: res,

        counter: fractional_counter as u32,

    }

}

    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {

        match self {

            CucError::InvalidCounterWidth(w) => {

                write!(f, "invalid cuc counter byte width {w}")

            CucError::InvalidCounter { width, counter } => {

                write!(f, "invalid cuc counter {counter} for width {width}")

    }

    pub const fn new(resolution: FractionalResolution, counter: u32) -> Self {

        let div = fractional_res_to_div(resolution);

        assert!(counter <= div, "invalid counter for resolution");

        Self {

            resolution,

            counter,

        }

    }

    pub const fn new_with_seconds_resolution() -> Self {

        Self::new(FractionalResolution::Seconds, 0)

    }

    pub const fn new_empty() -> Self {

        Self::new_with_seconds_resolution()

    }

    pub fn resolution(&self) -> FractionalResolution {

        self.resolution

    }

    pub fn counter(&self) -> u32 {

        self.counter

    }

    pub fn new(time: CucTime, leap_seconds: u32) -> Self {

        Self { time, leap_seconds }

    }

pub fn pfield_len(pfield: u8) -> usize {

    if ((pfield >> 7) & 0b1) == 1 {

    }

    1

}

    pub fn new(counter: u32) -> Self {

        // These values are definitely valid, so it is okay to unwrap here.

        Self::new_generic(

            WidthCounterPair(4, counter),

            FractionalPart::new_with_seconds_resolution(),

        )

        .unwrap()

    }

    pub fn new_with_fractions(counter: u32, fractions: FractionalPart) -> Result<Self, CucError> {

        Self::new_generic(WidthCounterPair(4, counter), fractions)

    }

    pub fn new_with_coarse_fractions(counter: u32, subsec_fractions: u8) -> Self {

        // These values are definitely valid, so it is okay to unwrap here.

        Self::new_generic(

            WidthCounterPair(4, counter),

            FractionalPart {

                resolution: FractionalResolution::FourMs,

                counter: subsec_fractions as u32,

            },

        )

        .unwrap()

    }

    pub fn new_with_medium_fractions(counter: u32, subsec_fractions: u16) -> Self {

        // These values are definitely valid, so it is okay to unwrap here.

        Self::new_generic(

            WidthCounterPair(4, counter),

            FractionalPart {

                resolution: FractionalResolution::FifteenUs,

                counter: subsec_fractions as u32,

            },

        )

        .unwrap()

    }

    pub fn new_with_fine_fractions(counter: u32, subsec_fractions: u32) -> Result<Self, CucError> {

        Self::new_generic(

            WidthCounterPair(4, counter),

            FractionalPart {

                resolution: FractionalResolution::SixtyNs,

                counter: subsec_fractions,

            },

        )

    }

    pub fn now(

        fraction_resolution: FractionalResolution,

        leap_seconds: u32,

    ) -> Result<Self, StdTimestampError> {

        let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?;

        let mut counter =

            u32::try_from(unix_epoch_to_ccsds_epoch(now.as_secs() as i64)).map_err(|_| {

            })?;

        counter = counter

            .checked_add(leap_seconds)

            .ok_or(TimestampError::Cuc(CucError::LeapSecondCorrectionError))?;

        if fraction_resolution == FractionalResolution::Seconds {

        }

        let fractions =

            fractional_part_from_subsec_ns(fraction_resolution, now.subsec_nanos() as u64);

        Self::new_with_fractions(counter, fractions)

            .map_err(|e| StdTimestampError::Timestamp(e.into()))

    }

    pub fn update_from_now(&mut self, leap_seconds: u32) -> Result<(), StdTimestampError> {

        let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?;

        self.counter.1 = unix_epoch_to_ccsds_epoch(now.as_secs() as i64) as u32;

        self.counter.1 = self

            .counter

            .1

            .checked_add(leap_seconds)

            .ok_or(TimestampError::Cuc(CucError::LeapSecondCorrectionError))?;

        if let FractionalResolution::Seconds = self.fractions.resolution {

        }

        Ok(())

    }

    pub fn from_chrono_date_time(

        dt: &chrono::DateTime<chrono::Utc>,

        res: FractionalResolution,

        leap_seconds: u32,

    ) -> Result<Self, CucError> {

        // Year before CCSDS epoch is invalid.

        if dt.year() < 1958 {

        }

        let counter = dt

            .timestamp()

            .checked_add(i64::from(leap_seconds))

            .ok_or(CucError::LeapSecondCorrectionError)?;

        Self::new_generic(

            WidthCounterPair(4, counter as u32),

            fractional_part_from_subsec_ns(res, dt.timestamp_subsec_nanos() as u64),

        )

    }

    pub fn from_unix_time(

        unix_time: &UnixTime,

        res: FractionalResolution,

        leap_seconds: u32,

    ) -> Result<Self, CucError> {

        let counter = unix_epoch_to_ccsds_epoch(unix_time.secs);

        // Negative CCSDS epoch is invalid.

        if counter < 0 {

        }

        let mut counter = u32::try_from(counter).map_err(|_| CucError::InvalidCounter {

        })?;

        counter = counter

            .checked_add(leap_seconds)

            .ok_or(CucError::LeapSecondCorrectionError)?;

        let fractions =

            fractional_part_from_subsec_ns(res, unix_time.subsec_millis() as u64 * 10_u64.pow(6));

        Self::new_generic(WidthCounterPair(4, counter as u32), fractions)

    }

    pub fn new_generic(

        width_and_counter: WidthCounterPair,

        fractions: FractionalPart,

    ) -> Result<Self, CucError> {

        Self::verify_counter_width(width_and_counter.0)?;

        if width_and_counter.1 > (2u64.pow(width_and_counter.0 as u32 * 8) - 1) as u32 {

            return Err(CucError::InvalidCounter {

                width: width_and_counter.0,

                counter: width_and_counter.1.into(),

            });

        }

        Self::verify_fractions_value(fractions)?;

        Ok(Self {

            pfield: Self::build_p_field(width_and_counter.0, fractions.resolution),

            counter: width_and_counter,

            fractions,

        })

    }

    pub fn ccsds_time_code(&self) -> CcsdsTimeCode {

        CcsdsTimeCode::CucCcsdsEpoch

    }

    pub fn width_counter_pair(&self) -> WidthCounterPair {

        self.counter

    }

    pub fn counter_width(&self) -> u8 {

        self.counter.0

    }

    pub fn counter(&self) -> u32 {

        self.counter.1

    }

    pub fn fractions(&self) -> FractionalPart {

        self.fractions

    }

    pub fn to_leap_sec_helper(&self, leap_seconds: u32) -> CucTimeWithLeapSecs {

        CucTimeWithLeapSecs::new(*self, leap_seconds)

    }

    pub fn set_fractions(&mut self, fractions: FractionalPart) -> Result<(), CucError> {

        Self::verify_fractions_value(fractions)?;

        self.fractions = fractions;

        self.update_p_field_fractions();

        Ok(())

    }

    pub fn set_fractional_resolution(&mut self, res: FractionalResolution) {

        if res == FractionalResolution::Seconds {

        }

        if res != self.fractions().resolution() {

            self.fractions = FractionalPart::new(res, 0);

        }

    }

    fn build_p_field(counter_width: u8, resolution: FractionalResolution) -> u8 {

        let mut pfield = P_FIELD_BASE;

        if !(1..=4).contains(&counter_width) {

        }

        pfield |= (counter_width - 1) << 2;

        if resolution != FractionalResolution::Seconds {

            if !(1..=3).contains(&(resolution as u8)) {

            }

            pfield |= resolution as u8;

        }

        pfield

    }

    fn update_p_field_fractions(&mut self) {

        self.pfield &= !(0b11);

        self.pfield |= self.fractions.resolution() as u8;

    }

    pub fn len_cntr_from_pfield(pfield: u8) -> u8 {

        ((pfield >> 2) & 0b11) + 1

    }

    pub fn len_fractions_from_pfield(pfield: u8) -> u8 {

        pfield & 0b11

    }

    pub fn unix_secs(&self, leap_seconds: u32) -> i64 {

        ccsds_epoch_to_unix_epoch(self.counter.1 as i64)

            .checked_sub(leap_seconds as i64)

            .unwrap()

    }

    pub fn subsec_millis(&self) -> u16 {

        (self.subsec_nanos() / 1_000_000) as u16

    }

    pub fn len_components_and_total_from_pfield(pfield: u8) -> (u8, u8, usize) {

        let base_len: usize = 1;

        let cntr_len = Self::len_cntr_from_pfield(pfield);

        let fractions_len = Self::len_fractions_from_pfield(pfield);

        (

            cntr_len,

            fractions_len,

            base_len + cntr_len as usize + fractions_len as usize,

        )

    }

    pub fn len_packed_from_pfield(pfield: u8) -> usize {

        let mut base_len: usize = 1;

        base_len += Self::len_cntr_from_pfield(pfield) as usize;

        base_len += Self::len_fractions_from_pfield(pfield) as usize;

        base_len

    }

    fn verify_counter_width(width: u8) -> Result<(), CucError> {

        if width == 0 || width > 4 {

            return Err(CucError::InvalidCounterWidth(width));

        }

        Ok(())

    }

    fn verify_fractions_value(val: FractionalPart) -> Result<(), CucError> {

        if val.counter > 2u32.pow((val.resolution as u32) * 8) - 1 {

        }

        Ok(())

    }

    fn len_as_bytes(&self) -> usize {

        Self::len_packed_from_pfield(self.pfield)

    }

    fn subsec_nanos(&self) -> u32 {

        if self.fractions.resolution() == FractionalResolution::Seconds {

            return 0;

        }

        // Rounding down here is the correct approach.

        convert_fractional_part_to_ns(self.fractions) as u32

    }

    fn from_bytes(buf: &[u8]) -> Result<Self, TimestampError> {

        if buf.len() < MIN_CUC_LEN {

            return Err(TimestampError::ByteConversion(

                ByteConversionError::FromSliceTooSmall {

                    expected: MIN_CUC_LEN,

                    found: buf.len(),

                },

            ));

        }

        match ccsds_time_code_from_p_field(buf[0]) {

            Ok(code) => {

                if code != CcsdsTimeCode::CucCcsdsEpoch {

                    return Err(TimestampError::InvalidTimeCode {

                        expected: CcsdsTimeCode::CucCcsdsEpoch,

                        found: code as u8,

                    });

                }

        let (cntr_len, fractions_len, total_len) =

            Self::len_components_and_total_from_pfield(buf[0]);

        if buf.len() < total_len {

            return Err(TimestampError::ByteConversion(

                ByteConversionError::FromSliceTooSmall {

                    expected: total_len,

                    found: buf.len(),

                },

            ));

        }

        let mut current_idx = 1;

        let counter = match cntr_len {

            1 => buf[current_idx] as u32,

            2 => u16::from_be_bytes(buf[current_idx..current_idx + 2].try_into().unwrap()) as u32,

                let mut tmp_buf: [u8; 4] = [0; 4];

                tmp_buf[1..4].copy_from_slice(&buf[current_idx..current_idx + 3]);

                u32::from_be_bytes(tmp_buf)

            4 => u32::from_be_bytes(buf[current_idx..current_idx + 4].try_into().unwrap()),

        current_idx += cntr_len as usize;

        let mut fractions = FractionalPart::new_with_seconds_resolution();

        if fractions_len > 0 {

            match fractions_len {

                    fractions = FractionalPart::new(

                        fractions_len.try_into().unwrap(),

                        buf[current_idx] as u32,

                    )

                    fractions = FractionalPart::new(

                        fractions_len.try_into().unwrap(),

                        u16::from_be_bytes(buf[current_idx..current_idx + 2].try_into().unwrap())

                            as u32,

                    )

                    let mut tmp_buf: [u8; 4] = [0; 4];

                    tmp_buf[1..4].copy_from_slice(&buf[current_idx..current_idx + 3]);

                    fractions = FractionalPart::new(

                        fractions_len.try_into().unwrap(),

                        u32::from_be_bytes(tmp_buf),

                    )

        }

        let provider = Self::new_generic(WidthCounterPair(cntr_len, counter), fractions)?;

        Ok(provider)

    }

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

        // Cross check the sizes of the counters against byte widths in the ctor

        if bytes.len() < self.len_as_bytes() {

            return Err(TimestampError::ByteConversion(

                ByteConversionError::ToSliceTooSmall {

                    found: bytes.len(),

                    expected: self.len_as_bytes(),

                },

            ));

        }

        bytes[0] = self.pfield;

        let mut current_idx: usize = 1;

        match self.counter.0 {

            1 => {

                bytes[current_idx] = self.counter.1 as u8;

            }

            2 => {

                bytes[current_idx..current_idx + 2]

                    .copy_from_slice(&(self.counter.1 as u16).to_be_bytes());

            }

            3 => {

                bytes[current_idx..current_idx + 3]

                    .copy_from_slice(&self.counter.1.to_be_bytes()[1..4]);

            }

            4 => {

                bytes[current_idx..current_idx + 4].copy_from_slice(&self.counter.1.to_be_bytes());

            }

        current_idx += self.counter.0 as usize;

        match self.fractions.resolution() {

            FractionalResolution::FourMs => bytes[current_idx] = self.fractions.counter as u8,

            FractionalResolution::FifteenUs => bytes[current_idx..current_idx + 2]

                .copy_from_slice(&(self.fractions.counter as u16).to_be_bytes()),

            FractionalResolution::SixtyNs => bytes[current_idx..current_idx + 3]

                .copy_from_slice(&self.fractions.counter.to_be_bytes()[1..4]),

            _ => (),

        current_idx += self.fractions.resolution as usize;

        Ok(current_idx)

    }

    fn len_written(&self) -> usize {

        self.len_as_bytes()

    }

    fn ccdsd_time_code(&self) -> CcsdsTimeCode {

        self.time.ccsds_time_code()

    }

    fn unix_secs(&self) -> i64 {

        self.time.unix_secs(self.leap_seconds)

    }

    fn subsec_nanos(&self) -> u32 {

        self.time.subsec_nanos()

    }

fn get_time_values_after_duration_addition(

    time: &CucTime,

    duration: Duration,

) -> (u32, FractionalPart) {

    let mut new_counter = time.counter.1;

    let subsec_nanos = duration.subsec_nanos();

    let mut increment_counter = |amount: u32| {

        let mut sum: u64 = 0;

        let mut counter_inc_handler = |max_val: u64| {

            sum = new_counter as u64 + amount as u64;

            if sum >= max_val {

                new_counter = (sum % max_val) as u32;

                return;

            }

            new_counter = sum as u32;

        };

        match time.counter.0 {

            1 => counter_inc_handler(u8::MAX as u64),

            4 => counter_inc_handler(u32::MAX as u64),

    };

    let resolution = time.fractions().resolution();

    let fractional_increment = fractional_part_from_subsec_ns(resolution, subsec_nanos as u64);

    let mut fractional_part = FractionalPart::new_with_seconds_resolution();

    if resolution != FractionalResolution::Seconds {

        let mut new_fractions = time.fractions().counter() + fractional_increment.counter;

        let max_fractions = fractional_res_to_div(resolution);

        if new_fractions > max_fractions {

            increment_counter(1);

            new_fractions -= max_fractions;

        }

        fractional_part = FractionalPart {

            resolution,

            counter: new_fractions,

        }

    }

    increment_counter(duration.as_secs() as u32);

    (new_counter, fractional_part)

}

    fn add_assign(&mut self, duration: Duration) {

        let (new_counter, new_fractional_part) =

            get_time_values_after_duration_addition(self, duration);

        self.counter.1 = new_counter;

        self.fractions = new_fractional_part;

    }

    fn add(self, duration: Duration) -> Self::Output {

        let (new_counter, new_fractional_part) =

            get_time_values_after_duration_addition(&self, duration);

        // The generated fractional part should always be valid, so its okay to unwrap here.

        Self::new_with_fractions(new_counter, new_fractional_part).unwrap()

    }

    fn add(self, duration: Duration) -> Self::Output {

        let (new_counter, new_fractional_part) =

            get_time_values_after_duration_addition(self, duration);

        // The generated fractional part should always be valid, so its okay to unwrap here.

        Self::Output::new_with_fractions(new_counter, new_fractional_part).unwrap()

    }

    fn test_basic_zero_epoch() {

        // Do not include leap second corrections, which do not apply to dates before 1972.

        let zero_cuc = CucTime::new(0);

        assert_eq!(zero_cuc.len_as_bytes(), 5);

        assert_eq!(zero_cuc.counter_width(), zero_cuc.width_counter_pair().0);

        assert_eq!(zero_cuc.counter(), zero_cuc.width_counter_pair().1);

        let ccsds_cuc = zero_cuc.to_leap_sec_helper(0);

        assert_eq!(ccsds_cuc.ccdsd_time_code(), CcsdsTimeCode::CucCcsdsEpoch);

        let counter = zero_cuc.width_counter_pair();

        assert_eq!(counter.0, 4);

        assert_eq!(counter.1, 0);

        let fractions = zero_cuc.fractions();

        assert_eq!(fractions, FractionalPart::new_with_seconds_resolution());

        let dt = ccsds_cuc.chrono_date_time();

        if let chrono::LocalResult::Single(dt) = dt {

            assert_eq!(dt.year(), 1958);

            assert_eq!(dt.month(), 1);

            assert_eq!(dt.day(), 1);

            assert_eq!(dt.hour(), 0);

            assert_eq!(dt.minute(), 0);

            assert_eq!(dt.second(), 0);

    }

    fn test_write_no_fractions() {

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

        let zero_cuc =

            CucTime::new_generic(WidthCounterPair(4, 0x20102030), FractionalPart::new_empty());

        assert!(zero_cuc.is_ok());

        let zero_cuc = zero_cuc.unwrap();

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

        assert!(res.is_ok());

        assert_eq!(zero_cuc.subsec_nanos(), 0);

        assert_eq!(zero_cuc.len_as_bytes(), 5);

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

        let written = res.unwrap();

        assert_eq!(written, 5);

        assert_eq!((buf[0] >> 7) & 0b1, 0);

        let time_code = ccsds_time_code_from_p_field(buf[0]);

        assert!(time_code.is_ok());

        assert_eq!(time_code.unwrap(), CcsdsTimeCode::CucCcsdsEpoch);

        assert_eq!((buf[0] >> 2) & 0b11, 0b11);

        assert_eq!(buf[0] & 0b11, 0);

        let raw_counter = u32::from_be_bytes(buf[1..5].try_into().unwrap());

        assert_eq!(raw_counter, 0x20102030);

        assert_eq!(buf[5], 0);

    }

    fn test_datetime_now() {

        let now = chrono::Utc::now();

        let cuc_now = CucTime::now(FractionalResolution::SixtyNs, LEAP_SECONDS);

        assert!(cuc_now.is_ok());

        let cuc_now = cuc_now.unwrap();

        let ccsds_cuc = cuc_now.to_leap_sec_helper(LEAP_SECONDS);

        let dt_opt = ccsds_cuc.chrono_date_time();

        if let chrono::LocalResult::Single(dt) = dt_opt {

            let diff = dt - now;

            assert!(diff.num_milliseconds() < 1000);

            println!("datetime from cuc: {}", dt);

            println!("datetime now: {}", now);

    }

    fn test_read_no_fractions() {

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

        let zero_cuc = CucTime::new_generic(

            WidthCounterPair(4, 0x20102030),

            FractionalPart::new_with_seconds_resolution(),

        )

        .unwrap();

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

        let cuc_read_back = CucTime::from_bytes(&buf).expect("reading cuc timestamp failed");

        assert_eq!(cuc_read_back, zero_cuc);

        assert_eq!(cuc_read_back.width_counter_pair().1, 0x20102030);

        assert_eq!(cuc_read_back.fractions(), FractionalPart::new_empty());

    }

    fn invalid_read_len() {

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

        for i in 0..2 {

            let res = CucTime::from_bytes(&buf[0..i]);

            assert!(res.is_err());

            let err = res.unwrap_err();

                found,

                expected,

            }) = err

                assert_eq!(found, i);

                assert_eq!(expected, 2);

        let large_stamp = CucTime::new_with_fine_fractions(22, 300).unwrap();

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

        for i in 2..large_stamp.len_as_bytes() - 1 {

            let res = CucTime::from_bytes(&buf[0..i]);

            assert!(res.is_err());

            let err = res.unwrap_err();

                found,

                expected,

            }) = err

                assert_eq!(found, i);

                assert_eq!(expected, large_stamp.len_as_bytes());

    }

    fn write_and_read_tiny_stamp() {

        let mut buf = [0; 2];

        let cuc = CucTime::new_generic(WidthCounterPair(1, 200), FractionalPart::new_empty());

        assert!(cuc.is_ok());

        let cuc = cuc.unwrap();

        assert_eq!(cuc.len_as_bytes(), 2);

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

        assert!(res.is_ok());

        let written = res.unwrap();

        assert_eq!(written, 2);

        assert_eq!(buf[1], 200);

        let cuc_read_back = CucTime::from_bytes(&buf);

        assert!(cuc_read_back.is_ok());

        let cuc_read_back = cuc_read_back.unwrap();

        assert_eq!(cuc_read_back, cuc);

    }

    fn write_slightly_larger_stamp() {

        let mut buf = [0; 4];

        let cuc = CucTime::new_generic(WidthCounterPair(2, 40000), FractionalPart::new_empty());

        assert!(cuc.is_ok());

        let cuc = cuc.unwrap();

        assert_eq!(cuc.len_as_bytes(), 3);

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

        assert!(res.is_ok());

        let written = res.unwrap();

        assert_eq!(written, 3);

        assert_eq!(u16::from_be_bytes(buf[1..3].try_into().unwrap()), 40000);

        let cuc_read_back = CucTime::from_bytes(&buf);

        assert!(cuc_read_back.is_ok());

        let cuc_read_back = cuc_read_back.unwrap();

        assert_eq!(cuc_read_back, cuc);

    }

    fn invalid_buf_len_for_read() {}

    fn write_read_three_byte_cntr_stamp() {

        let mut buf = [0; 4];

        let cuc = CucTime::new_generic(

            WidthCounterPair(3, 2_u32.pow(24) - 2),

            FractionalPart::new_empty(),

        );

        assert!(cuc.is_ok());

        let cuc = cuc.unwrap();

        assert_eq!(cuc.len_as_bytes(), 4);

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

        assert!(res.is_ok());

        let written = res.unwrap();

        assert_eq!(written, 4);

        let mut temp_buf = [0; 4];

        temp_buf[1..4].copy_from_slice(&buf[1..4]);

        assert_eq!(u32::from_be_bytes(temp_buf), 2_u32.pow(24) - 2);

        let cuc_read_back = CucTime::from_bytes(&buf);

        assert!(cuc_read_back.is_ok());

        let cuc_read_back = cuc_read_back.unwrap();

        assert_eq!(cuc_read_back, cuc);

    }

    fn test_write_invalid_buf() {

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

        let res = CucTime::new_with_fine_fractions(0, 0);

        let cuc = res.unwrap();

        for i in 0..cuc.len_as_bytes() - 1 {

            let err = cuc.write_to_bytes(&mut buf[0..i]);

            assert!(err.is_err());

            let err = err.unwrap_err();

                found,

                expected,

            }) = err

                assert_eq!(expected, cuc.len_as_bytes());

                assert_eq!(found, i);

    }

    fn invalid_ccsds_stamp_type() {

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

        buf[0] |= (CcsdsTimeCode::CucAgencyEpoch as u8) << 4;

        let res = CucTime::from_bytes(&buf);

        assert!(res.is_err());

        let err = res.unwrap_err();

        if let TimestampError::InvalidTimeCode { expected, found } = err {

            assert_eq!(expected, CcsdsTimeCode::CucCcsdsEpoch);

            assert_eq!(found, CcsdsTimeCode::CucAgencyEpoch as u8);

    }

    fn test_write_with_coarse_fractions() {

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

        let cuc = CucTime::new_with_coarse_fractions(0x30201060, 120);

        assert_eq!(cuc.fractions().counter(), 120);

        assert_eq!(cuc.fractions().resolution(), FractionalResolution::FourMs);

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

        assert!(res.is_ok());

        let written = res.unwrap();

        assert_eq!(written, 6);

        assert_eq!(buf[5], 120);

        assert_eq!(buf[6], 0);

        assert_eq!(

            u32::from_be_bytes(buf[1..5].try_into().unwrap()),

            0x30201060

        );

    }

    fn test_read_with_coarse_fractions() {

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

        let cuc = CucTime::new_with_coarse_fractions(0x30201060, 120);

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

        assert!(res.is_ok());

        let res = CucTime::from_bytes(&buf);

        assert!(res.is_ok());

        let read_back = res.unwrap();

        assert_eq!(read_back, cuc);

    }

    fn test_write_with_medium_fractions() {

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

        let cuc = CucTime::new_with_medium_fractions(0x30303030, 30000);

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

        assert!(res.is_ok());

        let written = res.unwrap();

        assert_eq!(written, 7);

        assert_eq!(u16::from_be_bytes(buf[5..7].try_into().unwrap()), 30000);

        assert_eq!(buf[7], 0);

    }

    fn test_read_with_medium_fractions() {

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

        let cuc = CucTime::new_with_medium_fractions(0x30303030, 30000);

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

        assert!(res.is_ok());

        let res = CucTime::from_bytes(&buf);

        assert!(res.is_ok());

        let cuc_read_back = res.unwrap();

        assert_eq!(cuc_read_back, cuc);

    }

    fn test_write_with_fine_fractions() {

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

        let cuc = CucTime::new_with_fine_fractions(0x30303030, u16::MAX as u32 + 60000);

        assert!(cuc.is_ok());

        let cuc = cuc.unwrap();

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

        let written = res.unwrap();

        assert_eq!(written, 8);

        let mut dummy_buf: [u8; 4] = [0; 4];

        dummy_buf[1..4].copy_from_slice(&buf[5..8]);

        assert_eq!(u32::from_be_bytes(dummy_buf), u16::MAX as u32 + 60000);

        assert_eq!(buf[8], 0);

    }

    fn test_read_with_fine_fractions() {

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

        let cuc = CucTime::new_with_fine_fractions(0x30303030, u16::MAX as u32 + 60000);

        assert!(cuc.is_ok());

        let cuc = cuc.unwrap();

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

        assert!(res.is_ok());

        let res = CucTime::from_bytes(&buf);

        assert!(res.is_ok());

        let cuc_read_back = res.unwrap();

        assert_eq!(cuc_read_back, cuc);

    }

    fn test_fractional_converter() {

        let ns = convert_fractional_part_to_ns(FractionalPart {

            resolution: FractionalResolution::FourMs,

            counter: 2,

        });

        // The formula for this is 2/255 * 10e9 = 7.843.137.

        assert_eq!(ns, 7843137);

        let ns = convert_fractional_part_to_ns(FractionalPart {

            resolution: FractionalResolution::SixtyNs,

            counter: 2_u32.pow(24) - 2,

        });

        assert_eq!(ns, 999999940);

    }

    fn test_fractional_converter_invalid_input() {

        convert_fractional_part_to_ns(FractionalPart {

            resolution: FractionalResolution::FourMs,

            counter: 256,

        });

    }

    fn test_fractional_converter_invalid_input_2() {

        convert_fractional_part_to_ns(FractionalPart {

            resolution: FractionalResolution::SixtyNs,

            counter: 2_u32.pow(32) - 1,

        });

    }

    fn fractional_part_formula() {

        let fractional_part = fractional_part_from_subsec_ns(FractionalResolution::FourMs, 7843138);

        assert_eq!(fractional_part.counter, 2);

    }

    fn fractional_part_formula_2() {

        let fractional_part =

            fractional_part_from_subsec_ns(FractionalResolution::FourMs, 12000000);

        assert_eq!(fractional_part.counter, 3);

    }

    fn fractional_part_formula_3() {

        let one_fraction_with_width_two_in_ns =

            10_u64.pow(9) as f64 / (2_u32.pow(8 * 2) - 1) as f64;

        assert_eq!(one_fraction_with_width_two_in_ns.ceil(), 15260.0);

        let hundred_fractions_and_some =

            (100.0 * one_fraction_with_width_two_in_ns).floor() as u64 + 7000;

        let fractional_part = fractional_part_from_subsec_ns(

            FractionalResolution::FifteenUs,

            hundred_fractions_and_some,

        );

        assert_eq!(fractional_part.counter, 100);

        let hundred_and_one_fractions =

            (101.001 * one_fraction_with_width_two_in_ns).floor() as u64;

        let fractional_part = fractional_part_from_subsec_ns(

            FractionalResolution::FifteenUs,

            hundred_and_one_fractions,

        );

        assert_eq!(fractional_part.counter, 101);

    }

    fn update_fractions() {

        let mut stamp = CucTime::new(2000);

        let res = stamp.set_fractions(FractionalPart {

            resolution: FractionalResolution::SixtyNs,

            counter: 5000,

        });

        assert!(res.is_ok());

        assert_eq!(

            stamp.fractions().resolution(),

            FractionalResolution::SixtyNs

        );

        assert_eq!(stamp.fractions().counter(), 5000);

    }

    fn set_fract_resolution() {

        let mut stamp = CucTime::new(2000);

        stamp.set_fractional_resolution(FractionalResolution::SixtyNs);

        assert_eq!(

            stamp.fractions().resolution(),

            FractionalResolution::SixtyNs

        );

        assert_eq!(stamp.fractions().counter(), 0);

        let res = stamp.update_from_now(LEAP_SECONDS);

        assert!(res.is_ok());

    }

    fn test_small_fraction_floored_to_zero() {

        let fractions = fractional_part_from_subsec_ns(FractionalResolution::SixtyNs, 59);

        assert_eq!(fractions.counter, 0);

    }

    fn test_small_fraction_becomes_fractional_part() {

        let fractions = fractional_part_from_subsec_ns(FractionalResolution::SixtyNs, 61);

        assert_eq!(fractions.counter, 1);

    }

    fn test_smallest_resolution_small_nanoseconds_floored_to_zero() {

        let fractions =

            fractional_part_from_subsec_ns(FractionalResolution::FourMs, 3800 * 1e3 as u64);

        assert_eq!(fractions.counter, 0);

    }

    fn test_smallest_resolution_small_nanoseconds_becomes_one_fraction() {

        let fractions =

            fractional_part_from_subsec_ns(FractionalResolution::FourMs, 4000 * 1e3 as u64);

        assert_eq!(fractions.counter, 1);

    }

    fn test_smallest_resolution_large_nanoseconds_becomes_largest_fraction() {

        let fractions =

            fractional_part_from_subsec_ns(FractionalResolution::FourMs, 10u64.pow(9) - 1);

        assert_eq!(fractions.counter, 2_u32.pow(8) - 1);

    }

    fn test_largest_fractions_with_largest_resolution() {

        let fractions =

            fractional_part_from_subsec_ns(FractionalResolution::SixtyNs, 10u64.pow(9) - 1);

        // The value can not be larger than representable by 3 bytes