radio_datetime_utils/

lib.rs

// SPDX-License-Identifier: MIT OR Apache-2.0
// Copyright 2022-2025 René Ladan <rene0+codeberg@freedom.nl>

//! Definition of date/time structures commonly useful for time station decoders.

//! Build with no_std for embedded platforms.
#![cfg_attr(not(test), no_std)]

pub mod radio_datetime_helpers;

/// DST change has been announced (mutually exclusive with DST_PROCESSED)
pub const DST_ANNOUNCED: u8 = 1;
/// DST change has been processed (mutually exclusive with DST_ANNOUNCED)
pub const DST_PROCESSED: u8 = 2;
/// unexpected jump in DST state
pub const DST_JUMP: u8 = 4;
/// DST is active
pub const DST_SUMMER: u8 = 8;

/// Leap second has been announced (mutually exclusive with LEAP_PROCESSED)
pub const LEAP_ANNOUNCED: u8 = 1;
/// Leap second has been processed (mutually exclusive with LEAP_ANNOUNCED)
pub const LEAP_PROCESSED: u8 = 2;
/// Leap second is unexpectedly absent
pub const LEAP_MISSING: u8 = 4;

/// Size of bit buffer in seconds plus one spare because we cannot know
/// which method accessing the buffer is called after increase_second().
pub const BIT_BUFFER_SIZE: usize = 61 + 1;

/// Represents a date and time transmitted over radio.
#[derive(Clone, Copy, Debug)]
#[cfg_attr(test, derive(PartialEq))]
pub struct RadioDateTimeUtils {
    year: Option<u8>,
    month: Option<u8>,
    day: Option<u8>,
    weekday: Option<u8>,
    hour: Option<u8>,
    minute: Option<u8>,
    dst: Option<u8>,
    leap_second: Option<u8>,
    dut1: Option<i8>, // DUT1 in deci-seconds (MSF) or centi-seconds (RBU)
    jump_year: bool,
    jump_month: bool,
    jump_day: bool,
    jump_weekday: bool,
    jump_hour: bool,
    jump_minute: bool,
    jump_dut1: bool,
    min_weekday: u8,
    max_weekday: u8,
    minutes_running: u8,   // internal counter for set_dst() and set_leap_second()
    dst_count: u8,         // internal counter for set_dst()
    first_minute: bool,    // internal flag for set_dst()
    leap_second_count: u8, // internal counter for set_leap_second()
    is_readonly: bool,     // internal flag to mark the structure as read-only
    is_utc: Option<bool>,  // if the time is transmitted in UTC, optional until part of `new`
    utc_offset: Option<i16>,
    utc_offset_hours: Option<i8>,
    utc_offset_minutes: Option<i8>,
}

/// Macro to avoid repetition in `set_XXX()`
macro_rules! set_value {
    ($this:ident, $me:ident, $value:expr, $min:expr, $max:expr, $terms:expr, $jump_me:ident,
     $check_jump:expr) => {
        if $this.is_readonly {
            return;
        }
        let val = if $value.is_some() && $terms && ($min..=$max).contains(&$value.unwrap()) {
            $value
        } else {
            $this.$me
        };
        $this.$jump_me = $check_jump && val.is_some() && $this.$me.is_some() && val != $this.$me;
        $this.$me = val;
    };
}

/// Macro to avoid repetition in UTC/localtime conversions
macro_rules! convert_time {
    ($this:ident, $is_utc:expr, $mult:expr) => {
        if $this.is_utc.is_none() || !$this.is_valid() {
            None
        } else if $this.is_readonly || $this.is_utc.unwrap() == $is_utc {
            Some(*$this)
        } else {
            let mut u = $this.utc_offset.unwrap();
            let h;
            let m;
            if $this.dst.is_some_and(|x| x & DST_SUMMER > 0) {
                u += 60;
                h = (u / 60) as i8;
                m = (u % 60) as i8;
            } else {
                h = $this.utc_offset_hours.unwrap();
                m = $this.utc_offset_minutes.unwrap();
            }
            let mut rdt_new = if u == 0 {
                *$this
            } else if ($mult * u) > 0 {
                if m == 0 {
                    RadioDateTimeUtils::incr_hour(
                        *$this,
                        ($mult * h) as u8,
                        RadioDateTimeUtils::id_hour,
                    )
                } else {
                    RadioDateTimeUtils::incr_minute(
                        *$this,
                        ($mult * m) as u8,
                        ($mult * h) as u8,
                        RadioDateTimeUtils::id_hour,
                    )
                }
            } else if m == 0 {
                RadioDateTimeUtils::decr_hour(*$this, ($mult * -h) as u8)
            } else {
                RadioDateTimeUtils::decr_minute(*$this, ($mult * -m) as u8, ($mult * -h) as u8)
            };
            rdt_new.is_readonly = true;
            Some(rdt_new)
        }
    };
}

impl RadioDateTimeUtils {
    /// Initialize a new RadioDateTimeUtils instance
    ///
    /// # Arguments
    /// * `sunday` - the numeric value of Sunday, i.e. 7 for DCF77 or 0 for MSF
    pub fn new(sunday: u8) -> Self {
        Self {
            year: None,
            month: None,
            day: None,
            weekday: None,
            hour: None,
            minute: None,
            dst: None,
            dut1: None,
            dst_count: 0,
            leap_second: None,
            leap_second_count: 0,
            jump_year: false,
            jump_month: false,
            jump_day: false,
            jump_weekday: false,
            jump_hour: false,
            jump_minute: false,
            jump_dut1: false,
            min_weekday: (sunday != 0) as u8,
            max_weekday: if sunday == 7 { 7 } else { 6 },
            minutes_running: 0,
            first_minute: true,
            is_readonly: false,
            is_utc: None,
            utc_offset: None,
            utc_offset_hours: None,
            utc_offset_minutes: None,
        }
    }

    /// Reset the RadioDateTimeUtils instance, except for Sunday, UTC offset, and in-UTC.
    pub fn reset(&mut self) {
        self.year = None;
        self.month = None;
        self.day = None;
        self.weekday = None;
        self.hour = None;
        self.minute = None;
        self.dst = None;
        self.dut1 = None;
        self.dst_count = 0;
        self.leap_second = None;
        self.leap_second_count = 0;
        self.jump_year = false;
        self.jump_month = false;
        self.jump_day = false;
        self.jump_weekday = false;
        self.jump_hour = false;
        self.jump_minute = false;
        self.jump_dut1 = false;
        self.minutes_running = 0;
        self.first_minute = true;
        self.is_readonly = false;
    }

    /// Get the current year, truncated to two digits.
    pub fn get_year(&self) -> Option<u8> {
        self.year
    }

    /// Get the current month.
    pub fn get_month(&self) -> Option<u8> {
        self.month
    }

    /// Get the current day of the month.
    pub fn get_day(&self) -> Option<u8> {
        self.day
    }

    /// Get the current day of the week as a number.
    pub fn get_weekday(&self) -> Option<u8> {
        self.weekday
    }

    /// Get the current hour.
    pub fn get_hour(&self) -> Option<u8> {
        self.hour
    }

    /// Get the current minute.
    pub fn get_minute(&self) -> Option<u8> {
        self.minute
    }

    /// Get the current bitmask value (if any) of the daylight saving time status.
    pub fn get_dst(&self) -> Option<u8> {
        self.dst
    }

    /// Get the current bitmask value of the leap second status.
    pub fn get_leap_second(&self) -> Option<u8> {
        self.leap_second
    }

    /// Get the value of DUT1 (UT1 - UTC).
    pub fn get_dut1(&self) -> Option<i8> {
        self.dut1
    }

    /// Return if the DUT1 has jumped unexpectedly (not at midnight UTC).
    pub fn get_jump_dut1(&self) -> bool {
        self.jump_dut1
    }

    /// Return if the year has jumped unexpectedly.
    pub fn get_jump_year(&self) -> bool {
        self.jump_year
    }

    /// Return if the month has jumped unexpectedly.
    pub fn get_jump_month(&self) -> bool {
        self.jump_month
    }

    /// Return if the day-of-month has jumped unexpectedly.
    pub fn get_jump_day(&self) -> bool {
        self.jump_day
    }

    /// Return if the day-of-week has jumped unexpectedly.
    pub fn get_jump_weekday(&self) -> bool {
        self.jump_weekday
    }

    /// Return if the hour has jumped unexpectedly.
    pub fn get_jump_hour(&self) -> bool {
        self.jump_hour
    }

    /// Return if the minute has jumped unexpectedly.
    pub fn get_jump_minute(&self) -> bool {
        self.jump_minute
    }

    /// Set the time zone offset from local normal-time to UTC in minutes, eastwards being positive,
    /// and set whether the station transmits in UTC.
    ///
    /// This function is needed until `utc_offset` and `is_utc` are part of `new()`.
    ///
    /// # Arguments
    /// * `utc_offset` - the offset in minutes, between -1080 and +1080 inclusive
    /// * `is_utc` - indicates if the station transmits in UTC
    pub fn set_utc_offset(&mut self, utc_offset: i16, is_utc: bool) {
        if (-1080..=1080).contains(&utc_offset) {
            self.utc_offset = Some(utc_offset);
            self.utc_offset_hours = Some((utc_offset / 60) as i8);
            self.utc_offset_minutes = Some((utc_offset % 60) as i8);
            self.is_utc = Some(is_utc);
        }
    }

    /// Returns if the current date/time is valid (date, time, DST are all `is_some()`).
    pub fn is_valid(&self) -> bool {
        self.dst.is_some()
            && self.year.is_some()
            && self.month.is_some()
            && self.day.is_some()
            && self.weekday.is_some()
            && self.hour.is_some()
            && self.minute.is_some()
    }

    /// Clear all jump values.
    pub fn clear_jumps(&mut self) {
        if self.is_readonly {
            return;
        }
        self.jump_year = false;
        self.jump_month = false;
        self.jump_day = false;
        self.jump_weekday = false;
        self.jump_hour = false;
        self.jump_minute = false;
        if self.dst.is_some() {
            self.dst = Some(self.dst.unwrap() & !DST_JUMP);
        }
        self.jump_dut1 = false;
    }

    /// Add one minute to the current date and time, return if the operation succeeded.
    ///
    /// * Years are limited to 2 digits, so this function wraps after 100 years.
    /// * The operation is valid in local time and accounts for DST changes.
    pub fn add_minute(&mut self) -> bool {
        if self.is_readonly || !self.is_valid() {
            return false;
        }
        let rdt_new = RadioDateTimeUtils::incr_minute(*self, 1, 0, RadioDateTimeUtils::dst_hour);
        self.minute = rdt_new.minute;
        self.hour = rdt_new.hour;
        self.day = rdt_new.day;
        self.weekday = rdt_new.weekday;
        self.month = rdt_new.month;
        self.year = rdt_new.year;
        true
    }

    /// Set the year value, valid values are 0 through 99.
    ///
    /// # Arguments
    /// * `value` - the new year value. None or invalid values keep the old value.
    /// * `terms` - extra validations to pass.
    /// * `check_jump` - check if the value has jumped unexpectedly compared to `add_minute()`.
    pub fn set_year(&mut self, value: Option<u8>, terms: bool, check_jump: bool) {
        set_value!(self, year, value, 0, 99, terms, jump_year, check_jump);
    }

    /// Set the month value, valid values are 1 through 12.
    ///
    /// # Arguments
    /// * `value` - the new month value. None or invalid values keep the old value.
    /// * `terms` - extra validations to pass.
    /// * `check_jump` - check if the value has jumped unexpectedly compared to `add_minute()`.
    pub fn set_month(&mut self, value: Option<u8>, terms: bool, check_jump: bool) {
        set_value!(self, month, value, 1, 12, terms, jump_month, check_jump);
    }

    /// Set the day-of-week value, valid values are 0/1 through 6/7, depending on how this
    /// instance was created.
    ///
    /// # Arguments
    /// * `value` - the new day-of-week value. None or invalid values keep the old value.
    /// * `terms` - extra validations to pass.
    /// * `check_jump` - check if the value has jumped unexpectedly compared to `add_minute()`.
    pub fn set_weekday(&mut self, value: Option<u8>, terms: bool, check_jump: bool) {
        set_value!(
            self,
            weekday,
            value,
            self.min_weekday,
            self.max_weekday,
            terms,
            jump_weekday,
            check_jump
        );
    }

    /// Set the day-in-month value, valid values are 1 through the last day of that month.
    ///
    /// If the year, month, or weekday are absent, the last day of the month cannot be
    /// calculated which means the old day-in-month value is kept.
    ///
    /// # Arguments
    /// * `value` - the new day-in-month value. None or invalid values keep the old value.
    /// * `terms` - extra validations to pass.
    /// * `check_jump` - check if the value has jumped unexpectedly compared to `add_minute()`.
    pub fn set_day(&mut self, value: Option<u8>, terms: bool, check_jump: bool) {
        if value.is_none() {
            return;
        }
        let s_value = value.unwrap();
        if self.year.is_none()
            || self.month.is_none()
            || self.weekday.is_none()
            || !(1..=31).contains(&s_value)
        {
            return;
        }
        let last_day = self.last_day(s_value);
        set_value!(
            self,
            day,
            value,
            1,
            last_day.unwrap(),
            last_day.is_some() && terms,
            jump_day,
            check_jump
        );
    }

    /// Set the hour value, valid values are 0 through 23.
    ///
    /// # Arguments
    /// * `value` - the new hour value. None or invalid values keep the old value.
    /// * `terms` - extra validations to pass.
    /// * `check_jump` - check if the value has jumped unexpectedly compared to `add_minute()`.
    pub fn set_hour(&mut self, value: Option<u8>, terms: bool, check_jump: bool) {
        set_value!(self, hour, value, 0, 23, terms, jump_hour, check_jump);
    }

    /// Set the minute value, valid values are 0 through 59.
    ///
    /// # Arguments
    /// * `value` - the new minute value. None or invalid values keep the old value.
    /// * `terms` - extra validations to pass.
    /// * `check_jump` - check if the value has jumped unexpectedly compared to `add_minute()`.
    pub fn set_minute(&mut self, value: Option<u8>, terms: bool, check_jump: bool) {
        set_value!(self, minute, value, 0, 59, terms, jump_minute, check_jump);
    }

    /// Set the DUT1 value, valid values are -99 through 99.
    ///
    /// # Arguments
    /// * `value` - the new DUT1 value. None or invalid values keep the old value.
    /// * `terms` - extra validations to pass.
    /// * `check_jump` - check if the value has jumped unexpectedly compared to IERS.
    pub fn set_dut1(&mut self, value: Option<i8>, terms: bool, check_jump: bool) {
        set_value!(self, dut1, value, -99, 99, terms, jump_dut1, check_jump);
        if let Some(utc_time) = self.get_utc() {
            self.jump_dut1 &=
                utc_time.hour.is_some_and(|h| h != 0) || utc_time.minute.is_some_and(|m| m != 0);
        }
    }

    /// Set the month and day-in-month value from the given day-in-year and is-leap-year values.
    ///
    /// # Arguments
    /// * `day_in_year` - the new day-in-year value.
    /// * `is_leap_year` - this year is a leap year.
    /// * `terms_month` - extra validation to pass for the month.
    /// * `terms_day` - extra validation to pass for the day-in-month.
    /// * `check_jump` - check if the day-in-month or month have jumped unexpectedly compared to
    ///   `add_minute()`
    pub fn set_month_day(
        &mut self,
        day_in_year: Option<u16>,
        is_leap_year: Option<bool>,
        terms_month: bool,
        terms_day: bool,
        check_jump: bool,
    ) {
        if self.is_readonly || day_in_year.is_none() || is_leap_year.is_none() {
            return;
        }
        let s_diy = day_in_year.unwrap();
        let la = if is_leap_year.unwrap() { 1 } else { 0 };
        if s_diy < 1 || s_diy > 365 + la {
            return;
        }
        let month_idx = [
            0,
            31,
            59 + la,
            90 + la,
            120 + la,
            151 + la,
            181 + la,
            212 + la,
            243 + la,
            273 + la,
            304 + la,
            334 + la,
        ];
        let mut m = 0;
        while m < 12 && month_idx[m] < s_diy {
            m += 1;
        }
        let mo = Some(m as u8);
        set_value!(self, month, mo, 1, 12, terms_month, jump_month, check_jump);
        let dy = (s_diy - month_idx[m - 1]) as u8;
        set_value!(self, day, Some(dy), 1, 31, terms_day, jump_day, check_jump);
    }

    /// Set the DST mask value, both the actual value and any information on transitions.
    ///
    /// # Arguments
    /// * `value` - the new DST value. A None value or unannounced changes keep the current value.
    /// * `announce` - if any announcement is made on a transition. The history of this value of
    ///   the last hour (or part thereof if started later) is kept to compensate for spurious
    ///   True values.
    /// * `check_jump` - check if the value changed unexpectedly.
    pub fn set_dst(&mut self, value: Option<bool>, announce: Option<bool>, check_jump: bool) {
        if self.is_readonly || value.is_none() || announce.is_none() {
            return;
        }
        if self.dst.is_none() {
            self.dst = Some(0);
        }
        // Clear any jump flag from the previous decoding:
        self.dst = Some(self.dst.unwrap() & !DST_JUMP);
        // Determine if a DST change is announced:
        if announce == Some(true) {
            self.dst_count += 1;
        }
        if self.minute.is_some_and(|x| x > 0) {
            if 2 * self.dst_count > self.minutes_running {
                self.dst = Some(self.dst.unwrap() | DST_ANNOUNCED);
            } else {
                self.dst = Some(self.dst.unwrap() & !DST_ANNOUNCED);
            }
        }
        if value.unwrap() != ((self.dst.unwrap() & DST_SUMMER) != 0) {
            // Time offset changed.
            if self.first_minute
                || ((self.dst.unwrap() & DST_ANNOUNCED) != 0 && self.minute == Some(0))
            {
                // Change is valid.
                if value.unwrap() {
                    self.dst = Some(self.dst.unwrap() | DST_SUMMER);
                } else {
                    self.dst = Some(self.dst.unwrap() & !DST_SUMMER);
                }
            } else if check_jump {
                self.dst = Some(self.dst.unwrap() | DST_JUMP);
            }
        }
        if self.minute == Some(0) && (self.dst.unwrap() & DST_ANNOUNCED) != 0 {
            // DST change processed:
            self.dst = Some(self.dst.unwrap() | DST_PROCESSED);
        } else if self.minute.is_some() {
            self.dst = Some(self.dst.unwrap() & !DST_PROCESSED);
        }
        // Always reset announcement at the hour:
        if self.minute == Some(0) {
            self.dst = Some(self.dst.unwrap() & !DST_ANNOUNCED);
            self.dst_count = 0;
        }
        self.first_minute = false;
    }

    /// Set the leap second value.
    ///
    /// # Arguments
    /// * `announce` - if any announcement is made on a positive leap second. The history of this
    ///   value of the last hour (or part thereof if started later) is kept to compensate for
    ///   spurious Some(True) values.
    /// * `minute_length` - the length of the decoded minute in seconds.
    pub fn set_leap_second(&mut self, announce: Option<bool>, minute_length: u8) {
        if self.is_readonly || announce.is_none() || !(60..=61).contains(&minute_length) {
            return;
        }
        if self.leap_second.is_none() {
            self.leap_second = Some(0);
        }
        // Determine if a leap second is announced:
        if announce == Some(true) {
            self.leap_second_count += 1;
        }
        if self.minute.is_some_and(|x| x > 0) {
            if 2 * self.leap_second_count > self.minutes_running {
                self.leap_second = Some(self.leap_second.unwrap() | LEAP_ANNOUNCED);
            } else {
                self.leap_second = Some(self.leap_second.unwrap() & !LEAP_ANNOUNCED);
            }
        }
        // Process possible leap second:
        if self.minute == Some(0) && (self.leap_second.unwrap() & LEAP_ANNOUNCED) != 0 {
            self.leap_second = Some(self.leap_second.unwrap() | LEAP_PROCESSED);
            if minute_length == 60 {
                // Leap second processed, but missing:
                self.leap_second = Some(self.leap_second.unwrap() | LEAP_MISSING);
            } else {
                // Leap second processed and present:
                self.leap_second = Some(self.leap_second.unwrap() & !LEAP_MISSING);
            }
        } else if self.minute.is_some() {
            self.leap_second = Some(self.leap_second.unwrap() & !LEAP_PROCESSED & !LEAP_MISSING);
        }
        // Always reset announcement at the hour:
        if self.minute == Some(0) {
            self.leap_second = Some(self.leap_second.unwrap() & !LEAP_ANNOUNCED);
            self.leap_second_count = 0;
        }
    }

    /// Bump the internal minute counter needed for set_dst() and set_leap_second()
    ///
    /// The code above this library must call this function, as this library cannot
    /// know which function got called first, or if just one of them should be called.
    pub fn bump_minutes_running(&mut self) {
        if self.is_readonly {
            return;
        }
        self.minutes_running += 1;
        if self.minute == Some(0) {
            self.minutes_running = 0;
        }
    }

    /// Return a copy of the current date/time in UTC (for local time sources),
    /// does nothing for incomplete inputs or results that are already converted to UTC.
    ///
    /// The return type is Optional until utc_offset is part of `new()`.
    pub fn get_utc(&self) -> Option<RadioDateTimeUtils> {
        #![allow(clippy::neg_multiply)]
        convert_time!(self, true, -1)
    }

    /// Return a copy of the current date/time in local time (for UTC sources),
    /// does nothing for incomplete inputs or results that are already converted to local time.
    ///
    /// The return type is Optional until utc_offset is part of `new()`.
    pub fn get_local_time(&self) -> Option<RadioDateTimeUtils> {
        convert_time!(self, false, 1)
    }

    /// Return the last calendar day of the current date, or None in case of error.
    ///
    /// # Arguments
    /// * `day` - day of the month in February '00, used to see if `year` is a leap year
    fn last_day(&self, day: u8) -> Option<u8> {
        let s_year = self.year.unwrap();
        let s_month = self.month.unwrap();
        let s_weekday = self.weekday.unwrap();
        if s_month == 2 {
            if day > 29 {
                None
            } else if (s_year != 0 && s_year % 4 == 0)
                || (s_year == 0 && RadioDateTimeUtils::is_leap_century(day, s_weekday))
            {
                Some(29)
            } else {
                Some(28)
            }
        } else if s_month == 4 || s_month == 6 || s_month == 9 || s_month == 11 {
            Some(30)
        } else {
            Some(31)
        }
    }

    /// Check if the century based on the given day in February '00 is divisible by 400.
    ///
    /// Based on xx00-02-28 is a Monday <=> xx00 is a leap year
    ///
    /// # Arguments
    /// * `day` - day of the month in February '00
    /// * `weekday` - day of the week in February '00
    fn is_leap_century(day: u8, weekday: u8) -> bool {
        // Ensure Sunday is 7 when dealing with e.g. MSF :
        let wd = if weekday == 0 { 7 } else { weekday };

        // Week day 1 is a Monday, assume this is a leap year.
        // If so, we should reach Monday xx00-02-28
        if day < 29 {
            // (8 - wd) % 7 == (0,(8-2)..=(8-7)) == (0,6..=1) --> Monday=0, Tuesday=6, .., Sunday=1
            // Transpose day to 22..=28, then check if the result plus
            // the inverted day-of-week adds up to 28
            day + 7 * ((28 - day) / 7) + ((8 - wd) % 7) == 28
        } else {
            wd == 2 // Tuesday xx00-02-29
        }
    }

    /// Helper that returns the value for the hour after a DST change.
    ///
    /// Except for Troll Research Station (UTC+0/UTC+2) and Lord Howe Island (UTC+10:30/UTC+11)
    /// all DST differences are 1 hour. Neither of the above have their own time station
    /// (VNG shut down on 2002-12-31).
    ///
    /// # Arguments
    /// * `s_dst` - current DST flags
    /// * `s_hour` - current hour
    fn dst_hour(s_dst: u8, s_hour: u8) -> u8 {
        if (s_dst & DST_ANNOUNCED) != 0 {
            return if (s_dst & DST_SUMMER) != 0 {
                s_hour - 1 // changing to winter
            } else {
                s_hour + 1 // changing to summer, hour can become 24 here
            };
        }
        s_hour
    }

    /// Helper that just returns the hour unmodified.
    ///
    /// # Arguments
    /// * `_` - unused
    /// * `s_hour` - current hour
    fn id_hour(_: u8, s_hour: u8) -> u8 {
        s_hour
    }

    /// Helper that advances the given time by the given amount of minutes
    /// and calls `incr_hour()` with the callback if needed.
    ///
    /// # Arguments
    /// * `rdt` - RadioDateTimeUtils structure to advance the time of
    /// * `minutes` - amount of minutes to advance the time with
    /// * `hours` - pass-through variable for `incr_hour()`
    /// * `hour_cb` - callback function to pass to `incr_hour()`
    fn incr_minute(
        rdt: RadioDateTimeUtils,
        minutes: u8,
        hours: u8,
        hour_cb: fn(u8, u8) -> u8,
    ) -> RadioDateTimeUtils {
        let mut rdt_new = rdt;
        let mut s_minute = rdt.minute.unwrap();
        s_minute += minutes;
        if s_minute >= 60 {
            s_minute -= 60;
            rdt_new = RadioDateTimeUtils::incr_hour(rdt, hours + 1, hour_cb)
        }
        rdt_new.minute = Some(s_minute);
        rdt_new
    }

    /// Helper that advances the given time by the given amount of hours.
    ///
    /// # Arguments
    /// * `rdt` - RadioDateTimeUtils structure to advance the time of
    /// * `hours` - amount of hours to advance the time with
    /// * `hour_cb` - callback to optionally compensate for DST changes
    fn incr_hour(
        rdt: RadioDateTimeUtils,
        hours: u8,
        hour_cb: fn(u8, u8) -> u8,
    ) -> RadioDateTimeUtils {
        let mut rdt_new = rdt;
        let mut s_hour = rdt.hour.unwrap();
        s_hour += hours;
        s_hour = hour_cb(rdt_new.dst.unwrap(), s_hour);
        if s_hour >= 24 {
            s_hour -= 24;
            let mut s_day = rdt.day.unwrap();
            let old_last_day = rdt.last_day(s_day).unwrap();
            let mut s_weekday = rdt.weekday.unwrap();
            s_weekday += 1;
            if s_weekday == rdt.max_weekday + 1 {
                s_weekday = rdt.min_weekday;
            }
            s_day += 1;
            if s_day > old_last_day {
                s_day = 1;
                let mut s_month = rdt.month.unwrap();
                s_month += 1;
                if s_month == 13 {
                    s_month = 1;
                    let mut s_year = rdt.year.unwrap();
                    s_year += 1;
                    if s_year == 100 {
                        s_year = 0;
                    }
                    rdt_new.year = Some(s_year);
                }
                rdt_new.month = Some(s_month);
            }
            rdt_new.weekday = Some(s_weekday);
            rdt_new.day = Some(s_day);
        }
        rdt_new.hour = Some(s_hour);
        rdt_new
    }

    /// Helper that decreases the given time by the given amount of minutes
    /// and calls `decr_hour()` when needed.
    ///
    /// # Arguments
    /// * `rdt` - RadioDateTimeUtils structure to decrease the time of
    /// * `minutes` - amount of minutes to decrease the time with
    /// * `hours` - pass-through variable for `decr_hour()`
    fn decr_minute(rdt: RadioDateTimeUtils, minutes: u8, hours: u8) -> RadioDateTimeUtils {
        let mut s_minute = rdt.minute.unwrap();
        let mut h = hours;
        if s_minute < minutes {
            s_minute += 60 - minutes;
            h += 1;
        } else {
            s_minute -= minutes;
        }
        let mut rdt_new = RadioDateTimeUtils::decr_hour(rdt, h);
        rdt_new.minute = Some(s_minute);
        rdt_new
    }

    /// Helper that decreases the given time by the given amount of hours.
    ///
    /// # Arguments
    /// * `rdt` - RadioDateTimeUtils structure to decrease the time of
    /// * `hours` - amount of hours to decrease the time with
    fn decr_hour(rdt: RadioDateTimeUtils, hours: u8) -> RadioDateTimeUtils {
        let mut rdt_new = rdt;
        let mut s_hour = rdt.hour.unwrap();
        if s_hour < hours {
            s_hour += 24 - hours;
            let mut s_weekday = rdt.weekday.unwrap();
            if s_weekday == rdt.min_weekday {
                s_weekday = rdt.max_weekday;
            } else {
                s_weekday -= 1;
            }
            rdt_new.weekday = Some(s_weekday);
            let mut s_day = rdt.day.unwrap();
            if s_day == 1 {
                let mut s_month = rdt.month.unwrap();
                if s_month == 1 {
                    s_month = 12;
                    let mut s_year = rdt.year.unwrap();
                    if s_year == 0 {
                        s_year = 99;
                    } else {
                        s_year -= 1;
                    }
                    rdt_new.year = Some(s_year);
                } else {
                    s_month -= 1;
                }
                rdt_new.month = Some(s_month);
                s_day = rdt_new.last_day(29).unwrap();
            } else {
                s_day -= 1;
            }
            rdt_new.day = Some(s_day);
        } else {
            s_hour -= hours;
        }
        rdt_new.hour = Some(s_hour);
        rdt_new
    }
}

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

    #[test]
    fn test_set_year_some_invalid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_year(Some(22), false, true);
        assert_eq!(rdt.year, None);
        assert_eq!(rdt.jump_year, false);
    }

    #[test]
    fn test_set_year_none_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_year(None, true, true);
        assert_eq!(rdt.year, None);
        assert_eq!(rdt.jump_year, false);
    }

    #[test]
    fn test_set_year_too_large_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_year(Some(100), true, false);
        assert_eq!(rdt.year, None);
        assert_eq!(rdt.jump_year, false);
    }

    #[test]
    fn test_set_year_some_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_year(Some(22), true, false);
        assert_eq!(rdt.year, Some(22));
        assert_eq!(rdt.jump_year, false);
    }

    #[test]
    fn continue_set_year_too_large_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_year(Some(22), true, false);
        rdt.set_year(Some(100), true, true);
        assert_eq!(rdt.year, Some(22));
        assert_eq!(rdt.jump_year, false);
    }

    #[test]
    fn test_set_year_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_year(Some(22), true, true);
        assert_eq!(rdt.year, Some(22));
        assert_eq!(rdt.jump_year, false);
    }

    #[test]
    fn continue_set_year_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_year(Some(22), true, true);
        rdt.set_year(Some(23), true, true);
        assert_eq!(rdt.year, Some(23));
        assert_eq!(rdt.jump_year, true);
    }

    #[test]
    fn continue_set_year_some_none_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_year(Some(25), true, true);
        rdt.set_year(None, true, true);
        assert_eq!(rdt.year, Some(25));
        assert_eq!(rdt.jump_year, false);
    }

    #[test]
    fn continue_set_year_none_some_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_year(None, true, true);
        rdt.set_year(Some(25), true, true);
        assert_eq!(rdt.year, Some(25));
        assert_eq!(rdt.jump_year, false);
    }

    #[test]
    fn test_set_month_some_invalid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_month(Some(9), false, true);
        assert_eq!(rdt.month, None);
        assert_eq!(rdt.jump_month, false);
    }

    #[test]
    fn test_set_month_none_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_month(None, true, true);
        assert_eq!(rdt.month, None);
        assert_eq!(rdt.jump_month, false);
    }

    #[test]
    fn test_set_month_too_small_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_month(Some(0), true, false);
        assert_eq!(rdt.month, None);
        assert_eq!(rdt.jump_month, false);
    }

    #[test]
    fn test_set_month_some_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_month(Some(9), true, false);
        assert_eq!(rdt.month, Some(9));
        assert_eq!(rdt.jump_month, false);
    }

    #[test]
    fn continue_set_month_too_large_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_month(Some(9), true, false);
        rdt.set_month(Some(13), true, true);
        assert_eq!(rdt.month, Some(9));
        assert_eq!(rdt.jump_month, false);
    }

    #[test]
    fn test_set_month_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_month(Some(9), true, true);
        assert_eq!(rdt.month, Some(9));
        assert_eq!(rdt.jump_month, false);
    }

    #[test]
    fn continue_set_month_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_month(Some(9), true, true);
        rdt.set_month(Some(10), true, true);
        assert_eq!(rdt.month, Some(10));
        assert_eq!(rdt.jump_month, true);
    }

    #[test]
    fn continue_set_month_some_none_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_month(Some(1), true, true);
        rdt.set_month(None, true, true);
        assert_eq!(rdt.month, Some(1));
        assert_eq!(rdt.jump_month, false);
    }

    #[test]
    fn continue_set_month_none_some_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_month(None, true, true);
        rdt.set_month(Some(1), true, true);
        assert_eq!(rdt.month, Some(1));
        assert_eq!(rdt.jump_month, false);
    }

    #[test]
    fn test_set_day_some_invalid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_day(Some(23), false, true);
        assert_eq!(rdt.day, None);
        assert_eq!(rdt.jump_day, false);
    }

    #[test]
    fn test_set_day_none_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_day(None, true, true);
        assert_eq!(rdt.day, None);
        assert_eq!(rdt.jump_day, false);
    }

    #[test]
    fn test_set_day_too_small_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_day(Some(0), true, false);
        assert_eq!(rdt.day, None);
        assert_eq!(rdt.jump_day, false);
    }

    #[test]
    fn test_set_day_some_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // set_day() requires a full date and weekday to work
        rdt.year = Some(22);
        rdt.month = Some(9);
        rdt.weekday = Some(10); // any Some value works here because rdt.month != Some(2)
        rdt.set_day(Some(23), true, false);
        assert_eq!(rdt.day, Some(23));
        assert_eq!(rdt.jump_day, false);
    }

    #[test]
    fn continue_set_day_too_large_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // set_day() requires a full date and weekday to work
        rdt.year = Some(22);
        rdt.month = Some(9);
        rdt.weekday = Some(5); // any Some value works here because rdt.month != Some(2)
        rdt.set_day(Some(23), true, false);
        rdt.set_day(Some(32), true, true);
        assert_eq!(rdt.day, Some(23));
        assert_eq!(rdt.jump_day, false);
    }

    #[test]
    fn test_set_day_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.year = Some(22);
        rdt.month = Some(9);
        rdt.weekday = Some(0); // any Some value works here because rdt.month != Some(2)
        rdt.set_day(Some(23), true, true);
        assert_eq!(rdt.day, Some(23));
        assert_eq!(rdt.jump_day, false);
    }

    #[test]
    fn test_set_day_partial_input_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.month = Some(7);
        rdt.weekday = Some(0);
        rdt.set_day(Some(21), true, true);
        assert_eq!(rdt.day, None);
        assert_eq!(rdt.jump_day, false);
    }

    #[test]
    fn continue_set_day_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.year = Some(22);
        rdt.month = Some(9);
        rdt.weekday = Some(7); // any Some value works here because rdt.month != Some(2)
        rdt.set_day(Some(23), true, true);
        rdt.set_day(Some(24), true, true);
        assert_eq!(rdt.day, Some(24));
        assert_eq!(rdt.jump_day, true);
    }

    #[test]
    fn continue_set_day_some_none_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.year = Some(25);
        rdt.month = Some(1);
        rdt.weekday = Some(3);
        rdt.set_day(Some(1), true, true);
        rdt.set_day(None, true, true);
        assert_eq!(rdt.day, Some(1));
        assert_eq!(rdt.jump_day, false);
    }

    #[test]
    fn continue_set_day_none_some_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.year = Some(25);
        rdt.month = Some(1);
        rdt.weekday = Some(3);
        rdt.set_day(None, true, true);
        rdt.set_day(Some(1), true, true);
        assert_eq!(rdt.day, Some(1));
        assert_eq!(rdt.jump_day, false);
    }

    #[test]
    fn test_set_weekday_some_invalid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_weekday(Some(5), false, true);
        assert_eq!(rdt.weekday, None);
        assert_eq!(rdt.jump_weekday, false);
    }

    #[test]
    fn test_set_weekday_none_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_weekday(None, true, true);
        assert_eq!(rdt.weekday, None);
        assert_eq!(rdt.jump_weekday, false);
    }

    #[test]
    fn test_set_weekday_too_large_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_weekday(Some(7), true, false);
        assert_eq!(rdt.weekday, None);
        assert_eq!(rdt.jump_weekday, false);
    }

    #[test]
    fn test_set_weekday_some_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_weekday(Some(5), true, false);
        assert_eq!(rdt.weekday, Some(5));
        assert_eq!(rdt.jump_weekday, false);
    }

    #[test]
    fn continue_set_weekday_too_large_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_weekday(Some(5), true, false);
        rdt.set_weekday(Some(7), true, true);
        assert_eq!(rdt.weekday, Some(5));
        assert_eq!(rdt.jump_weekday, false);
    }

    #[test]
    fn test_set_weekday_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_weekday(Some(5), true, true);
        assert_eq!(rdt.weekday, Some(5));
        assert_eq!(rdt.jump_weekday, false);
    }

    #[test]
    fn continue_set_weekday_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_weekday(Some(5), true, true);
        rdt.set_weekday(Some(6), true, true);
        assert_eq!(rdt.weekday, Some(6));
        assert_eq!(rdt.jump_weekday, true);
    }

    #[test]
    fn continue_set_weekday_some_none_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_weekday(Some(3), true, true);
        rdt.set_weekday(None, true, true);
        assert_eq!(rdt.weekday, Some(3));
        assert_eq!(rdt.jump_weekday, false);
    }

    #[test]
    fn continue_set_weekday_none_some_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_weekday(None, true, true);
        rdt.set_weekday(Some(3), true, true);
        assert_eq!(rdt.weekday, Some(3));
        assert_eq!(rdt.jump_weekday, false);
    }

    #[test]
    fn test_set_weekday7_too_small_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.set_weekday(Some(0), true, false);
        assert_eq!(rdt.weekday, None);
        assert_eq!(rdt.jump_weekday, false);
    }

    #[test]
    fn continue_set_weekday7_too_small_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.set_weekday(Some(5), true, false);
        rdt.set_weekday(Some(0), true, true);
        assert_eq!(rdt.weekday, Some(5));
        assert_eq!(rdt.jump_weekday, false);
    }

    #[test]
    fn test_set_hour_some_invalid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_hour(Some(22), false, true);
        assert_eq!(rdt.hour, None);
        assert_eq!(rdt.jump_hour, false);
    }

    #[test]
    fn test_set_hour_none_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_hour(None, true, true);
        assert_eq!(rdt.hour, None);
        assert_eq!(rdt.jump_hour, false);
    }

    #[test]
    fn test_set_hour_too_large_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_hour(Some(24), true, false);
        assert_eq!(rdt.hour, None);
        assert_eq!(rdt.jump_hour, false);
    }

    #[test]
    fn test_set_hour_some_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_hour(Some(22), true, false);
        assert_eq!(rdt.hour, Some(22));
        assert_eq!(rdt.jump_hour, false);
    }

    #[test]
    fn continue_set_hour_too_large_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_hour(Some(22), true, false);
        rdt.set_hour(Some(24), true, true);
        assert_eq!(rdt.hour, Some(22));
        assert_eq!(rdt.jump_hour, false);
    }

    #[test]
    fn test_set_hour_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_hour(Some(22), true, true);
        assert_eq!(rdt.hour, Some(22));
        assert_eq!(rdt.jump_hour, false);
    }

    #[test]
    fn continue_set_hour_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_hour(Some(22), true, true);
        rdt.set_hour(Some(23), true, true);
        assert_eq!(rdt.hour, Some(23));
        assert_eq!(rdt.jump_hour, true);
    }

    #[test]
    fn continue_set_hour_some_none_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_hour(Some(19), true, true);
        rdt.set_hour(None, true, true);
        assert_eq!(rdt.hour, Some(19));
        assert_eq!(rdt.jump_hour, false);
    }

    #[test]
    fn continue_set_hour_none_some_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_hour(None, true, true);
        rdt.set_hour(Some(19), true, true);
        assert_eq!(rdt.hour, Some(19));
        assert_eq!(rdt.jump_hour, false);
    }

    #[test]
    fn test_set_minute_some_invalid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_minute(Some(47), false, true);
        assert_eq!(rdt.minute, None);
        assert_eq!(rdt.jump_minute, false);
    }

    #[test]
    fn test_set_minute_none_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_minute(None, true, true);
        assert_eq!(rdt.minute, None);
        assert_eq!(rdt.jump_minute, false);
    }

    #[test]
    fn test_set_minute_too_large_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_minute(Some(60), true, false);
        assert_eq!(rdt.minute, None);
        assert_eq!(rdt.jump_minute, false);
    }

    #[test]
    fn test_set_minute_some_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_minute(Some(47), true, false);
        assert_eq!(rdt.minute, Some(47));
        assert_eq!(rdt.jump_minute, false);
    }

    #[test]
    fn continue_set_minute_too_large_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_minute(Some(47), true, false);
        rdt.set_minute(Some(60), true, true);
        assert_eq!(rdt.minute, Some(47));
        assert_eq!(rdt.jump_minute, false);
    }

    #[test]
    fn test_set_minute_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_minute(Some(47), true, true);
        assert_eq!(rdt.minute, Some(47));
        assert_eq!(rdt.jump_minute, false);
    }

    #[test]
    fn continue_set_minute_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_minute(Some(47), true, true);
        rdt.set_minute(Some(48), true, true);
        assert_eq!(rdt.minute, Some(48));
        assert_eq!(rdt.jump_minute, true);
    }

    #[test]
    fn continue_set_minute_some_none_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_minute(Some(25), true, true);
        rdt.set_minute(None, true, true);
        assert_eq!(rdt.minute, Some(25));
        assert_eq!(rdt.jump_minute, false);
    }

    #[test]
    fn continue_set_minute_none_some_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_minute(None, true, true);
        rdt.set_minute(Some(25), true, true);
        assert_eq!(rdt.minute, Some(25));
        assert_eq!(rdt.jump_minute, false);
    }

    #[test]
    fn test_set_dut1_some_invalid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_dut1(Some(47), false, true);
        assert_eq!(rdt.dut1, None);
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_set_dut1_none_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_dut1(None, true, true);
        assert_eq!(rdt.dut1, None);
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_set_dut1_too_small_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_dut1(Some(-100), true, false);
        assert_eq!(rdt.dut1, None);
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_set_dut1_too_large_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_dut1(Some(100), true, false);
        assert_eq!(rdt.dut1, None);
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_set_dut1_some_valid_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_dut1(Some(47), true, false);
        assert_eq!(rdt.dut1, Some(47));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn continue_set_dut1_too_large_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_dut1(Some(47), true, false);
        rdt.set_dut1(Some(100), true, true);
        assert_eq!(rdt.dut1, Some(47));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_set_dut1_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_dut1(Some(47), true, true);
        assert_eq!(rdt.dut1, Some(47));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn continue_set_dut1_some_valid_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_dut1(Some(47), true, true);
        rdt.set_dut1(Some(48), true, true);
        assert_eq!(rdt.dut1, Some(48));
        assert_eq!(rdt.jump_dut1, true);
    }

    #[test]
    fn continue_set_dut1_some_none_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_dut1(Some(25), true, true);
        rdt.set_dut1(None, true, true);
        assert_eq!(rdt.dut1, Some(25));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn continue_set_dut1_none_some_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_dut1(None, true, true);
        rdt.set_dut1(Some(25), true, true);
        assert_eq!(rdt.dut1, Some(25));
        assert_eq!(rdt.jump_dut1, false);
    }

    fn create_dut1_rdt() -> RadioDateTimeUtils {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(0, false);
        rdt.set_year(Some(25), true, false);
        rdt.set_month(Some(5), true, false);
        rdt.set_weekday(Some(2), true, false);
        rdt.set_day(Some(20), true, false);
        rdt.set_hour(Some(22), true, false);
        rdt.set_minute(Some(16), true, false);
        rdt.set_dst(Some(true), Some(false), false);
        rdt
    }

    #[test]
    fn test_set_dut1_some_invalid_jump_utc_set() {
        let mut rdt = create_dut1_rdt();
        rdt.set_dut1(Some(47), false, true);
        assert_eq!(rdt.dut1, None);
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_set_dut1_none_valid_jump_utc_set() {
        let mut rdt = create_dut1_rdt();
        rdt.set_dut1(None, true, true);
        assert_eq!(rdt.dut1, None);
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn continue_set_dut1_too_large_valid_jump_utc_set() {
        let mut rdt = create_dut1_rdt();
        rdt.set_dut1(Some(47), true, false);
        rdt.set_dut1(Some(100), true, true);
        assert_eq!(rdt.dut1, Some(47));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_set_dut1_some_valid_jump_utc_set() {
        let mut rdt = create_dut1_rdt();
        rdt.set_dut1(Some(47), true, true);
        assert_eq!(rdt.dut1, Some(47));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn continue_set_dut1_some_valid_jump_utc_set() {
        let mut rdt = create_dut1_rdt();
        rdt.set_dut1(Some(47), true, true);
        rdt.set_dut1(Some(48), true, true);
        assert_eq!(rdt.dut1, Some(48));
        assert_eq!(rdt.jump_dut1, true);
    }

    #[test]
    fn continue_set_dut1_some_none_no_jump_utc_set() {
        let mut rdt = create_dut1_rdt();
        rdt.set_dut1(Some(25), true, true);
        rdt.set_dut1(None, true, true);
        assert_eq!(rdt.dut1, Some(25));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn continue_set_dut1_none_some_no_jump_utc_set() {
        let mut rdt = create_dut1_rdt();
        rdt.set_dut1(None, true, true);
        rdt.set_dut1(Some(25), true, true);
        assert_eq!(rdt.dut1, Some(25));
        assert_eq!(rdt.jump_dut1, false);
    }

    // below DUT1 tests adapted from msf60_utils

    #[test]
    fn test_dut1_none_none_no_jump() {
        let mut rdt = create_dut1_rdt();
        rdt.set_minute(Some(58), true, false);
        rdt.set_dut1(None, true, false);
        assert_eq!(rdt.dut1, None);
        assert_eq!(rdt.jump_dut1, false);
        rdt.set_minute(Some(59), true, true);
        rdt.set_dut1(None, true, true);
        assert_eq!(rdt.dut1, None);
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_dut1_none_some_no_jump() {
        let mut rdt = create_dut1_rdt();
        rdt.set_minute(Some(58), true, false);
        rdt.set_dut1(None, true, false);
        assert_eq!(rdt.dut1, None);
        assert_eq!(rdt.jump_dut1, false);
        rdt.set_minute(Some(59), true, true);
        rdt.set_dut1(Some(-2), true, true);
        assert_eq!(rdt.dut1, Some(-2));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_dut1_some_none_no_jump() {
        let mut rdt = create_dut1_rdt();
        rdt.set_minute(Some(58), true, false);
        rdt.set_dut1(Some(-2), true, false);
        assert_eq!(rdt.dut1, Some(-2));
        assert_eq!(rdt.jump_dut1, false);
        rdt.set_minute(Some(59), true, true);
        rdt.set_dut1(Some(-2), false, true); // simulate dut1p * dut1n != 0
        assert_eq!(rdt.dut1, Some(-2));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_dut1_some_x_some_x_no_jump() {
        let mut rdt = create_dut1_rdt();
        rdt.set_minute(Some(58), true, false);
        rdt.set_dut1(Some(-2), true, false);
        assert_eq!(rdt.dut1, Some(-2));
        assert_eq!(rdt.jump_dut1, false);
        rdt.set_minute(Some(59), true, true);
        rdt.set_dut1(Some(-2), true, true); // do nothing
        assert_eq!(rdt.dut1, Some(-2));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_dut1_some_x_some_y_jump() {
        let mut rdt = create_dut1_rdt();
        rdt.set_minute(Some(58), true, false);
        rdt.set_dut1(Some(-2), true, false);
        assert_eq!(rdt.dut1, Some(-2));
        assert_eq!(rdt.jump_dut1, false);
        rdt.set_minute(Some(59), true, true);
        rdt.set_dut1(Some(-3), true, true);
        assert_eq!(rdt.dut1, Some(-3));
        assert_eq!(rdt.jump_dut1, true);
        // no jump for DUT1=-3 on next minute (23:00):
        rdt.set_hour(Some(23), true, true);
        rdt.set_minute(Some(0), true, true);
        rdt.set_dut1(Some(-3), true, true);
        assert_eq!(rdt.dut1, Some(-3));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_dut1_some_x_some_x_midnight_no_jump() {
        let mut rdt = create_dut1_rdt();
        rdt.set_minute(Some(59), true, false);
        rdt.set_hour(Some(0), true, false); // BST active in create_dut1_rdt()
        rdt.set_dut1(Some(-2), true, false);
        assert_eq!(rdt.dut1, Some(-2));
        assert_eq!(rdt.jump_dut1, false);
        rdt.set_minute(Some(0), true, true);
        rdt.set_hour(Some(1), true, true);
        rdt.set_dut1(Some(-2), true, true); // no change
        assert_eq!(rdt.dut1, Some(-2));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_dut1_some_x_some_y_midnight_no_jump() {
        let mut rdt = create_dut1_rdt();
        assert_eq!(rdt.dst, Some(DST_SUMMER));
        rdt.set_minute(Some(59), true, false);
        rdt.set_hour(Some(0), true, false); // BST active in create_dut1_rdt()
        rdt.set_dut1(Some(-2), true, false);
        assert_eq!(rdt.dut1, Some(-2));
        assert_eq!(rdt.jump_dut1, false);
        assert_eq!(rdt.dst, Some(DST_SUMMER));
        rdt.set_minute(Some(0), true, true);
        rdt.set_hour(Some(1), true, true);
        rdt.set_dut1(Some(-3), true, true);
        assert_eq!(rdt.dut1, Some(-3));
        assert_eq!(rdt.jump_dut1, false);
    }

    #[test]
    fn test_last_day7_regular() {
        let mut dcf77 = RadioDateTimeUtils::new(7);
        dcf77.year = Some(22);
        dcf77.month = Some(6);
        dcf77.weekday = Some(7);
        assert_eq!(dcf77.last_day(5), Some(30)); // today, Sunday 2022-06-05
    }

    #[test]
    fn test_last_day7_non_existent() {
        let mut dcf77 = RadioDateTimeUtils::new(7);
        dcf77.year = Some(22);
        dcf77.month = Some(2);
        dcf77.weekday = Some(4);
        assert_eq!(dcf77.last_day(29), Some(28)); // non-existent date, Thursday 22-02-29
    }

    #[test]
    fn test_last_day7_happy_new_year() {
        let mut dcf77 = RadioDateTimeUtils::new(7);
        dcf77.year = Some(0);
        dcf77.month = Some(1);
        dcf77.weekday = Some(1);
        assert_eq!(dcf77.last_day(1), Some(31));
        // first day, weekday off/do-not-care, Monday 00-01-01
    }

    #[test]
    fn test_last_day7_regular_leap() {
        let mut dcf77 = RadioDateTimeUtils::new(7);
        dcf77.year = Some(20);
        dcf77.month = Some(2);
        dcf77.weekday = Some(3);
        assert_eq!(dcf77.last_day(3), Some(29)); // regular leap year, Wednesday 2020-02-03
    }

    #[test]
    fn test_last_day7_bogus_weekday() {
        let mut dcf77 = RadioDateTimeUtils::new(7);
        dcf77.year = Some(20);
        dcf77.month = Some(2);
        dcf77.weekday = Some(4);
        assert_eq!(dcf77.last_day(3), Some(29));
        // same date with bogus weekday, "Thursday" 2020-02-03
    }

    #[test]
    fn test_last_day7_century_leap_1() {
        let mut dcf77 = RadioDateTimeUtils::new(7);
        dcf77.year = Some(0);
        dcf77.month = Some(2);
        dcf77.weekday = Some(2);
        assert_eq!(dcf77.last_day(1), Some(29));
        // century-leap-year, day/weekday must match, Tuesday 2000-02-01
    }

    #[test]
    fn test_last_day7_century_regular() {
        let mut dcf77 = RadioDateTimeUtils::new(7);
        dcf77.year = Some(0);
        dcf77.month = Some(2);
        dcf77.weekday = Some(1);
        assert_eq!(dcf77.last_day(1), Some(28)); // century-regular-year, Monday 2100-02-01
    }

    #[test]
    fn test_last_day7_century_leap_6() {
        let mut dcf77 = RadioDateTimeUtils::new(7);
        dcf77.year = Some(0);
        dcf77.month = Some(2);
        dcf77.weekday = Some(7);
        assert_eq!(dcf77.last_day(6), Some(29)); // century-leap-year, Sunday 2000-02-06
    }

    #[test]
    fn test_last_day0_century_leap() {
        let mut msf = RadioDateTimeUtils::new(0);
        msf.year = Some(0);
        msf.month = Some(2);
        msf.weekday = Some(0);
        assert_eq!(msf.last_day(6), Some(29)); // century-leap-year, Sunday 2000-02-06
    }

    #[test]
    fn test_last_day0_too_large_day() {
        let mut msf = RadioDateTimeUtils::new(0);
        msf.year = Some(0);
        msf.month = Some(2);
        msf.weekday = Some(0);
        assert_eq!(msf.last_day(32), None); // invalid input, Sunday 00-02-32
    }

    #[test]
    fn test_dst_some_starting_no_dst_no_announcement_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // Simple initial minute update, no announcement:
        rdt.minute = Some(11);
        rdt.set_dst(Some(false), Some(false), false);
        assert_eq!(rdt.dst, Some(0)); // no flags
        assert_eq!(rdt.dst_count, 0);
    }

    #[test]
    fn test_dst_some_starting_dst_no_announcement_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // Simple initial minute update, no announcement:
        rdt.minute = Some(11);
        rdt.set_dst(Some(true), Some(false), false);
        assert_eq!(rdt.dst, Some(DST_SUMMER));
        assert_eq!(rdt.dst_count, 0);
    }

    #[test]
    fn test_dst_starting_at_new_hour_no_announcement_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // Simple initial minute update at top-of-hour, no announcement:
        rdt.minute = Some(0);
        rdt.set_dst(Some(false), Some(false), true);
        assert_eq!(rdt.dst, Some(0)); // no flags
        assert_eq!(rdt.dst_count, 0);
    }

    #[test]
    fn test_dst_running_no_announcement_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // A bit further in the hour. no announcement:
        rdt.minute = Some(15);
        rdt.minutes_running = 15;
        rdt.set_dst(Some(false), Some(false), true);
        assert_eq!(rdt.dst, Some(0)); // no flags
        assert_eq!(rdt.dst_count, 0);
    }

    #[test]
    fn test_dst_spurious_announcement_jump() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // DST change announced spuriously:
        rdt.minute = Some(15);
        rdt.minutes_running = 15;
        rdt.set_dst(Some(false), Some(true), true);
        assert_eq!(rdt.dst, Some(0)); // no flags
        assert_eq!(rdt.dst_count, 1);
    }

    #[test]
    fn test_dst_announced() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // Change our mind, the previous announcement was valid:
        // Do not cheat with self.dst_count:
        rdt.minute = Some(0);
        for _ in 0..10 {
            rdt.minute = Some(rdt.minute.unwrap() + 1);
            rdt.minutes_running += 1;
            rdt.set_dst(Some(false), Some(true), true);
        }
        assert_eq!(rdt.dst, Some(DST_ANNOUNCED));
        assert_eq!(rdt.minutes_running, 10);
        assert_eq!(rdt.dst_count, 10);
    }

    #[test]
    fn continue_dst_to_summer() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // Announcement bit was gone, but there should be enough evidence:
        rdt.minute = Some(0);
        for _ in 0..11 {
            rdt.minute = Some(rdt.minute.unwrap() + 1);
            rdt.minutes_running += 1;
            rdt.set_dst(Some(false), Some(true), true);
        }
        assert_eq!(rdt.dst, Some(DST_ANNOUNCED));
        rdt.minute = Some(0);
        rdt.set_dst(Some(true), Some(false), true);
        // Top of hour, so announcement should be reset:
        assert_eq!(rdt.dst, Some(DST_PROCESSED | DST_SUMMER));
        assert_eq!(rdt.dst_count, 0);
    }

    #[test]
    fn continue_dst_to_winter() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // Announcement bit was gone, but there should be enough evidence:
        rdt.minute = Some(0);
        for _ in 0..12 {
            rdt.minute = Some(rdt.minute.unwrap() + 1);
            rdt.minutes_running += 1;
            rdt.set_dst(Some(true), Some(true), true);
        }
        assert_eq!(rdt.dst, Some(DST_ANNOUNCED | DST_SUMMER));
        rdt.minute = Some(0);
        rdt.set_dst(Some(false), Some(false), true);
        // Top of hour, so announcement should be reset:
        assert_eq!(rdt.dst, Some(DST_PROCESSED));
        assert_eq!(rdt.dst_count, 0);
    }

    #[test]
    fn continue2_dst_none_minute() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.minute = Some(0);
        for _ in 0..13 {
            rdt.minute = Some(rdt.minute.unwrap() + 1);
            rdt.minutes_running += 1;
            rdt.set_dst(Some(false), Some(true), true);
        }
        assert_eq!(rdt.dst, Some(DST_ANNOUNCED));
        rdt.minute = Some(0);
        rdt.set_dst(Some(true), Some(false), true);
        // Nothing should change because of the None minute:
        rdt.minute = None;
        rdt.set_dst(Some(true), Some(true), true);
        assert_eq!(rdt.dst, Some(DST_PROCESSED | DST_SUMMER));
        assert_eq!(rdt.dst_count, 1);
    }

    #[test]
    fn continue_dst_jump_no_dst_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.minute = Some(11);
        rdt.set_dst(Some(false), Some(false), false);
        assert_eq!(rdt.dst, Some(0));
        assert_eq!(rdt.dst_count, 0);
        rdt.set_dst(Some(true), Some(false), false);
        assert_eq!(rdt.dst, Some(0)); // DST jumped but we do not care
        assert_eq!(rdt.dst_count, 0);
    }

    #[test]
    fn continue_dst_jump_no_dst_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.minute = Some(11);
        rdt.set_dst(Some(false), Some(false), true);
        assert_eq!(rdt.dst, Some(0));
        assert_eq!(rdt.dst_count, 0);
        rdt.set_dst(Some(true), Some(false), true);
        assert_eq!(rdt.dst, Some(DST_JUMP)); // DST jumped
        assert_eq!(rdt.dst_count, 0);
    }

    #[test]
    fn continue_dst_jump_dst_no_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.minute = Some(11);
        rdt.set_dst(Some(true), Some(false), false);
        assert_eq!(rdt.dst, Some(DST_SUMMER));
        assert_eq!(rdt.dst_count, 0);
        rdt.set_dst(Some(false), Some(false), false);
        assert_eq!(rdt.dst, Some(DST_SUMMER)); // DST jumped but we do not care
        assert_eq!(rdt.dst_count, 0);
    }

    #[test]
    fn continue_dst_jump_dst_jump() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.minute = Some(11);
        rdt.set_dst(Some(true), Some(false), true);
        assert_eq!(rdt.dst, Some(DST_SUMMER));
        assert_eq!(rdt.dst_count, 0);
        rdt.set_dst(Some(false), Some(false), true);
        assert_eq!(rdt.dst, Some(DST_JUMP | DST_SUMMER)); // DST jumped
        assert_eq!(rdt.dst_count, 0);
    }

    #[test]
    fn test_leap_second_some_starting_no_announcement() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // Simple initial minute update, no announcement:
        rdt.minute = Some(11);
        rdt.set_leap_second(Some(false), 60);
        assert_eq!(rdt.leap_second, Some(0)); // no flags
        assert_eq!(rdt.leap_second_count, 0);
    }

    #[test]
    fn test_leap_second_starting_at_new_hour_no_announcement() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // Simple initial minute update at top-of-hour, no announcement:
        rdt.minute = Some(0);
        rdt.set_leap_second(Some(false), 60);
        assert_eq!(rdt.leap_second, Some(0)); // no flags
        assert_eq!(rdt.leap_second_count, 0);
    }

    #[test]
    fn test_leap_second_running_no_announcement() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // A bit further in the hour. no announcement:
        rdt.minute = Some(15);
        rdt.minutes_running = 15;
        rdt.set_leap_second(Some(false), 60);
        assert_eq!(rdt.leap_second, Some(0)); // no flags
        assert_eq!(rdt.leap_second_count, 0);
    }

    #[test]
    fn test_leap_second_spurious_announcement() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // Leap second announced spuriously:
        rdt.minute = Some(15);
        rdt.minutes_running = 15;
        rdt.set_leap_second(Some(true), 60);
        assert_eq!(rdt.leap_second, Some(0)); // no flags
        assert_eq!(rdt.leap_second_count, 1);
    }

    #[test]
    fn test_leap_second_announced() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // Change our mind, the previous announcement was valid:
        // Do not cheat with self.leap_second_count:
        rdt.minute = Some(0);
        for _ in 0..10 {
            rdt.minute = Some(rdt.minute.unwrap() + 1);
            rdt.minutes_running += 1;
            rdt.set_leap_second(Some(true), 60);
        }
        assert_eq!(rdt.leap_second, Some(LEAP_ANNOUNCED));
        assert_eq!(rdt.minutes_running, 10);
        assert_eq!(rdt.leap_second_count, 10);
    }

    #[test]
    fn continue2_leap_second_missing() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // Missing leap second.
        // Announcement bit was gone, but there should be enough evidence:
        rdt.minute = Some(0);
        for _ in 0..11 {
            rdt.minute = Some(rdt.minute.unwrap() + 1);
            rdt.minutes_running += 1;
            rdt.set_leap_second(Some(true), 60);
        }
        assert_eq!(rdt.leap_second, Some(LEAP_ANNOUNCED));
        rdt.minute = Some(0);
        rdt.set_leap_second(Some(false), 60 /* not 61 */);
        // Top of hour, so announcement should be reset:
        assert_eq!(rdt.leap_second, Some(LEAP_PROCESSED | LEAP_MISSING));
        assert_eq!(rdt.leap_second_count, 0);
        rdt.minute = Some(1);
        // New hour has started:
        rdt.set_leap_second(Some(false), 60);
        assert_eq!(rdt.leap_second, Some(0));
    }

    #[test]
    fn continue_leap_second_present() {
        let mut rdt = RadioDateTimeUtils::new(7);
        // We got a leap second.
        // Announcement bit was gone, but there should be enough evidence:
        rdt.minute = Some(0);
        for _ in 0..12 {
            rdt.minute = Some(rdt.minute.unwrap() + 1);
            rdt.minutes_running += 1;
            rdt.set_leap_second(Some(true), 60);
        }
        assert_eq!(rdt.leap_second, Some(LEAP_ANNOUNCED));
        rdt.minute = Some(0);
        rdt.set_leap_second(Some(false), 61);
        // Top of hour, so announcement should be reset:
        assert_eq!(rdt.leap_second, Some(LEAP_PROCESSED));
        assert_eq!(rdt.leap_second_count, 0);
    }

    #[test]
    fn continue2_leap_second_none_minute() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.minute = Some(0);
        for _ in 0..13 {
            rdt.minute = Some(rdt.minute.unwrap() + 1);
            rdt.minutes_running += 1;
            rdt.set_leap_second(Some(true), 60);
        }
        assert_eq!(rdt.leap_second, Some(LEAP_ANNOUNCED));
        rdt.minute = Some(0);
        rdt.set_leap_second(Some(false), 60 /* not 61 */);
        // Nothing should happen because of the None minute:
        rdt.minute = None;
        rdt.set_leap_second(Some(true), 61);
        assert_eq!(rdt.leap_second, Some(LEAP_PROCESSED | LEAP_MISSING));
        assert_eq!(rdt.leap_second_count, 1);
    }

    #[test]
    fn test_add_minute_invalid_input() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // Test invalid input:
        assert_eq!(rdt.add_minute(), false);
        assert_eq!(rdt.minute, None);
    }

    #[test]
    fn test_add_minute_century_flip() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // Test the big century flip, these fields must all be set:
        rdt.minute = Some(59);
        rdt.hour = Some(23);
        rdt.day = Some(31);
        rdt.month = Some(12);
        rdt.year = Some(99);
        rdt.weekday = Some(5); // 1999-12-31 is a Friday
        rdt.dst = Some(0); // no flags set, i.e. daylight saving time unset
        assert_eq!(rdt.add_minute(), true);
        assert_eq!(rdt.minute, Some(0));
        assert_eq!(rdt.hour, Some(0));
        assert_eq!(rdt.day, Some(1));
        assert_eq!(rdt.month, Some(1));
        assert_eq!(rdt.year, Some(0));
        assert_eq!(rdt.weekday, Some(6));
    }

    #[test]
    fn test_add_minute_set_dst() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // Test DST becoming active, any hour and date are fine:
        rdt.minute = Some(59);
        rdt.hour = Some(17);
        rdt.day = Some(1);
        rdt.month = Some(1);
        rdt.year = Some(0);
        rdt.weekday = Some(6); // 2000-01-01 is a Saturday
        rdt.dst = Some(DST_ANNOUNCED);
        assert_eq!(rdt.add_minute(), true);
        assert_eq!(rdt.dst, Some(DST_ANNOUNCED)); // add_minute() does not change any DST flag
        assert_eq!(rdt.minute, Some(0));
        assert_eq!(rdt.hour, Some(19));
        assert_eq!(rdt.day, Some(1));
        assert_eq!(rdt.month, Some(1));
        assert_eq!(rdt.year, Some(0));
        assert_eq!(rdt.weekday, Some(6));
    }

    #[test]
    fn test_add_minute_unset_dst() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // Test DST becoming inactive:
        rdt.minute = Some(59);
        rdt.hour = Some(19);
        rdt.day = Some(1);
        rdt.month = Some(1);
        rdt.year = Some(0);
        rdt.weekday = Some(6); // 2000-01-01 is a Saturday
        rdt.dst = Some(DST_SUMMER | DST_ANNOUNCED);
        assert_eq!(rdt.add_minute(), true);
        assert_eq!(rdt.dst, Some(DST_SUMMER | DST_ANNOUNCED));
        // add_minute() does not change any DST flag
        assert_eq!(rdt.minute, Some(0));
        assert_eq!(rdt.hour, Some(19));
        assert_eq!(rdt.day, Some(1));
        assert_eq!(rdt.month, Some(1));
        assert_eq!(rdt.year, Some(0));
        assert_eq!(rdt.weekday, Some(6));
    }

    #[test]
    fn test_add_minute_msf_saturday_sunday() {
        let mut rdt = RadioDateTimeUtils::new(0);
        // Test flipping to min_weekday (MSF), Saturday 6 -> Sunday 0:
        rdt.minute = Some(59);
        rdt.hour = Some(23);
        rdt.day = Some(1);
        rdt.month = Some(1);
        rdt.year = Some(0);
        rdt.weekday = Some(6); // 2000-01-01 is a Saturday
        rdt.dst = Some(0);
        assert_eq!(rdt.add_minute(), true);
        assert_eq!(rdt.minute, Some(0));
        assert_eq!(rdt.hour, Some(0));
        assert_eq!(rdt.day, Some(2));
        assert_eq!(rdt.month, Some(1));
        assert_eq!(rdt.year, Some(0));
        assert_eq!(rdt.weekday, Some(0));
    }

    #[test]
    fn test_add_minute_dcf77_sunday_monday() {
        // Test flipping to min_weekday (DCF77), Sunday 7 -> Monday 1:
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.minute = Some(59);
        rdt.hour = Some(23);
        rdt.day = Some(2);
        rdt.month = Some(1);
        rdt.year = Some(0);
        rdt.weekday = Some(7); // 2000-01-02 is a Sunday
        rdt.dst = Some(0); // no flags set, i.e. daylight saving time unset
        assert_eq!(rdt.add_minute(), true);
        assert_eq!(rdt.minute, Some(0));
        assert_eq!(rdt.hour, Some(0));
        assert_eq!(rdt.day, Some(3));
        assert_eq!(rdt.month, Some(1));
        assert_eq!(rdt.year, Some(0));
        assert_eq!(rdt.weekday, Some(1));
    }

    #[test]
    fn test_add_minute_not_25_hours() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.minute = Some(59);
        rdt.hour = Some(23);
        rdt.day = Some(21);
        rdt.month = Some(7);
        rdt.year = Some(24);
        rdt.weekday = Some(7);
        rdt.dst = Some(DST_ANNOUNCED); // trigger DST switch
        assert_eq!(rdt.add_minute(), true);
        assert_eq!(rdt.minute, Some(0));
        assert_eq!(rdt.hour, Some(1)); // just became DST
        assert_eq!(rdt.day, Some(22));
        assert_eq!(rdt.month, Some(7));
        assert_eq!(rdt.year, Some(24));
        assert_eq!(rdt.weekday, Some(1));
    }

    #[test]
    fn continue_initial_dst_decoding() {
        // initial DST decoding bug from msf60_utils perhaps caused here?
        //   DCF77 == "240407 Su 223750 s  ", status = clear
        //   MSF   == "240407 Su 213750 w 0", status = clear

        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.minute = Some(33);
        rdt.hour = Some(21);
        rdt.day = Some(7);
        rdt.month = Some(10);
        rdt.year = Some(24);
        rdt.weekday = Some(1);
        rdt.first_minute = false;

        // Below rdt.add_minute() and rdt.bump_minutes_running() are not strictly needed as we are
        // in the middle of the hour and the announcement flag to rdt.set_dst() is set to
        // Some(false) anyway. Calling rdt.add_minute() simulates actual usage in dcf77_utils and
        // msf60_utils:

        // DCF77 and MSF apply same logic in decode_time() if minute length OK:
        //     self.radio_datetime.set_dst(
        //         dst,
        //         self.bit_buffer[16],
        //         added_minute && !self.first_minute,
        //     );
        //     self.radio_datetime.set_dst(
        //         self.bit_buffer_b[(58 + offset) as usize],
        //         self.bit_buffer_b[(53 + offset) as usize],
        //         added_minute && !self.first_minute,
        //     );

        rdt.dst = Some(0); // no flags set
        assert_eq!(rdt.add_minute(), true);
        rdt.bump_minutes_running();
        assert_eq!(rdt.minute, Some(34)); // sanity check
        assert_eq!(rdt.dst, Some(0)); // no DST flags yet
        assert_eq!(rdt.first_minute, false);

        rdt.set_dst(Some(true), Some(false), true);
        assert_eq!(rdt.add_minute(), true);
        rdt.bump_minutes_running();
        assert_eq!(rdt.minute, Some(35)); // sanity check
        assert_eq!(rdt.dst, Some(DST_JUMP)); // should stay non-DST
        assert_eq!(rdt.first_minute, false);

        rdt.first_minute = true;
        rdt.set_dst(Some(true), Some(false), true);
        assert_eq!(rdt.add_minute(), true);
        rdt.bump_minutes_running();
        assert_eq!(rdt.minute, Some(36)); // sanity check
        assert_eq!(rdt.dst, Some(DST_SUMMER)); // valid DST because first_minute was true
        assert_eq!(rdt.first_minute, false);

        rdt.set_dst(Some(false), Some(false), true);
        assert_eq!(rdt.add_minute(), true);
        rdt.bump_minutes_running();
        assert_eq!(rdt.minute, Some(37)); // sanity check
        assert_eq!(rdt.dst, Some(DST_SUMMER | DST_JUMP)); // should stay DST
        assert_eq!(rdt.first_minute, false);

        rdt.first_minute = true;
        rdt.set_dst(Some(false), Some(false), true);
        assert_eq!(rdt.add_minute(), true);
        rdt.bump_minutes_running();
        assert_eq!(rdt.minute, Some(38)); // sanity check
        assert_eq!(rdt.dst, Some(0)); // valid non-DST
        assert_eq!(rdt.first_minute, false);
    }

    // WWVB does not broadcast day-of-week (neither in the amplitude modulation nor in the phase
    // modulation format), just pick 0 here.

    #[test]
    fn test_set_wvvb_jan_1() {
        let mut wwvb = RadioDateTimeUtils::new(0);
        wwvb.set_month_day(Some(1), Some(false), true, true, false);
        assert_eq!(wwvb.month, Some(1));
        assert_eq!(wwvb.day, Some(1));
    }

    #[test]
    fn test_set_wwvb_dec_31_normal() {
        let mut wwvb = RadioDateTimeUtils::new(0);
        wwvb.set_month_day(Some(365), Some(false), true, true, false);
        assert_eq!(wwvb.month, Some(12));
        assert_eq!(wwvb.day, Some(31));
    }

    #[test]
    fn test_set_wwvb_dec_31_leap() {
        let mut wwvb = RadioDateTimeUtils::new(0);
        wwvb.set_month_day(Some(366), Some(true), true, true, false);
        assert_eq!(wwvb.month, Some(12));
        assert_eq!(wwvb.day, Some(31));
    }

    #[test]
    fn test_set_wwvb_0() {
        let mut wwvb = RadioDateTimeUtils::new(0);
        wwvb.set_month_day(Some(0), Some(false), true, true, false);
        assert_eq!(wwvb.month, None);
        assert_eq!(wwvb.day, None);
    }

    #[test]
    fn test_set_wwvb_too_large() {
        let mut wwvb = RadioDateTimeUtils::new(0);
        wwvb.set_month_day(Some(366), Some(false), true, true, false);
        assert_eq!(wwvb.month, None);
        assert_eq!(wwvb.day, None);
    }

    #[test]
    fn continue_set_wwvb_jumped() {
        let mut wwvb = RadioDateTimeUtils::new(0);
        wwvb.set_month_day(Some(311), Some(true), true, true, true);
        assert_eq!(wwvb.month, Some(11));
        assert_eq!(wwvb.day, Some(6));
        assert_eq!(wwvb.jump_month, false);
        assert_eq!(wwvb.jump_day, false);
        wwvb.set_month_day(Some(318), Some(true), true, true, true);
        assert_eq!(wwvb.month, Some(11));
        assert_eq!(wwvb.day, Some(13));
        assert_eq!(wwvb.jump_month, false);
        assert_eq!(wwvb.jump_day, true);
    }

    #[test]
    fn test_set_wwvb_no_yearday() {
        let mut wwvb = RadioDateTimeUtils::new(0);
        wwvb.set_month_day(None, Some(false), true, true, false);
        assert_eq!(wwvb.month, None);
        assert_eq!(wwvb.day, None);
    }

    #[test]
    fn test_set_wwvb_no_leap_indicator() {
        let mut wwvb = RadioDateTimeUtils::new(0);
        wwvb.set_month_day(Some(342), None, true, true, false);
        assert_eq!(wwvb.month, None);
        assert_eq!(wwvb.day, None);
    }

    #[test]
    fn test_incr_minute_leap_regular() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(24);
        rdt.month = Some(2);
        rdt.day = Some(28);
        rdt.weekday = Some(4);
        rdt.hour = Some(23);
        rdt.minute = Some(59);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::incr_minute(rdt, 1, 0, RadioDateTimeUtils::id_hour);
        assert_eq!(rdt2.minute, Some(0));
        assert_eq!(rdt2.hour, Some(0));
        assert_eq!(rdt2.weekday, Some(5));
        assert_eq!(rdt2.day, Some(29));
        assert_eq!(rdt2.month, Some(2));
        assert_eq!(rdt2.year, Some(24));
    }

    #[test]
    fn test_incr_minute_leap_2000() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(0);
        rdt.month = Some(2);
        rdt.day = Some(28);
        rdt.weekday = Some(1);
        rdt.hour = Some(23);
        rdt.minute = Some(59);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::incr_minute(rdt, 1, 0, RadioDateTimeUtils::id_hour);
        assert_eq!(rdt2.minute, Some(0));
        assert_eq!(rdt2.hour, Some(0));
        assert_eq!(rdt2.weekday, Some(2));
        assert_eq!(rdt2.day, Some(29));
        assert_eq!(rdt2.month, Some(2));
        assert_eq!(rdt2.year, Some(0));
    }

    #[test]
    fn test_incr_minute_non_leap_2100() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(0);
        rdt.month = Some(2);
        rdt.day = Some(28);
        rdt.weekday = Some(7);
        rdt.hour = Some(23);
        rdt.minute = Some(59);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::incr_minute(rdt, 1, 0, RadioDateTimeUtils::id_hour);
        assert_eq!(rdt2.minute, Some(0));
        assert_eq!(rdt2.hour, Some(0));
        assert_eq!(rdt2.weekday, Some(1));
        assert_eq!(rdt2.day, Some(1));
        assert_eq!(rdt2.month, Some(3));
        assert_eq!(rdt2.year, Some(0));
    }

    #[test]
    fn test_decr_minute_century() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(0);
        rdt.month = Some(1);
        rdt.day = Some(1);
        rdt.weekday = Some(6);
        rdt.hour = Some(0);
        rdt.minute = Some(0);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::decr_minute(rdt, 1, 0);
        assert_eq!(rdt2.minute, Some(59));
        assert_eq!(rdt2.hour, Some(23));
        assert_eq!(rdt2.weekday, Some(5));
        assert_eq!(rdt2.day, Some(31));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(99));
    }

    #[test]
    fn test_decr_minute_leap_regular() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(24);
        rdt.month = Some(3);
        rdt.day = Some(1);
        rdt.weekday = Some(5);
        rdt.hour = Some(0);
        rdt.minute = Some(0);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::decr_minute(rdt, 1, 0);
        assert_eq!(rdt2.minute, Some(59));
        assert_eq!(rdt2.hour, Some(23));
        assert_eq!(rdt2.weekday, Some(4));
        assert_eq!(rdt2.day, Some(29));
        assert_eq!(rdt2.month, Some(2));
        assert_eq!(rdt2.year, Some(24));
    }

    #[test]
    fn test_decr_minute_leap_2000() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(0);
        rdt.month = Some(3);
        rdt.day = Some(1);
        rdt.weekday = Some(3);
        rdt.hour = Some(0);
        rdt.minute = Some(0);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::decr_minute(rdt, 1, 0);
        assert_eq!(rdt2.minute, Some(59));
        assert_eq!(rdt2.hour, Some(23));
        assert_eq!(rdt2.weekday, Some(2));
        assert_eq!(rdt2.day, Some(29));
        assert_eq!(rdt2.month, Some(2));
        assert_eq!(rdt2.year, Some(0));
    }

    #[test]
    fn test_decr_minute_non_leap_2100() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(0);
        rdt.month = Some(3);
        rdt.day = Some(1);
        rdt.weekday = Some(1);
        rdt.hour = Some(0);
        rdt.minute = Some(0);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::decr_minute(rdt, 1, 0);
        assert_eq!(rdt2.minute, Some(59));
        assert_eq!(rdt2.hour, Some(23));
        assert_eq!(rdt2.weekday, Some(7));
        assert_eq!(rdt2.day, Some(28));
        assert_eq!(rdt2.month, Some(2));
        assert_eq!(rdt2.year, Some(0));
    }

    #[test]
    fn test_decr_minute_multiple() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(4);
        rdt.weekday = Some(3);
        rdt.hour = Some(15);
        rdt.minute = Some(30);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::decr_minute(rdt, 45, 5);
        assert_eq!(rdt2.minute, Some(45));
        assert_eq!(rdt2.hour, Some(9));
        assert_eq!(rdt2.weekday, Some(3));
        assert_eq!(rdt2.day, Some(4));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
    }

    #[test]
    fn test_decr_minute_multiple_large_minute() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(4);
        rdt.weekday = Some(3);
        rdt.hour = Some(15);
        rdt.minute = Some(50);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::decr_minute(rdt, 45, 5);
        assert_eq!(rdt2.minute, Some(5));
        assert_eq!(rdt2.hour, Some(10));
        assert_eq!(rdt2.weekday, Some(3));
        assert_eq!(rdt2.day, Some(4));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
    }

    #[test]
    fn test_incr_minute_multiple_overflow() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(3);
        rdt.weekday = Some(2);
        rdt.hour = Some(23);
        rdt.minute = Some(45);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::incr_minute(rdt, 45, 5, RadioDateTimeUtils::id_hour);
        assert_eq!(rdt2.minute, Some(30));
        assert_eq!(rdt2.hour, Some(5));
        assert_eq!(rdt2.weekday, Some(3));
        assert_eq!(rdt2.day, Some(4));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
    }

    #[test]
    fn test_decr_minute_multiple_underflow() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(4);
        rdt.weekday = Some(3);
        rdt.hour = Some(5);
        rdt.minute = Some(30);
        rdt.dst = Some(0); // prevent unwrapping a None
        let rdt2 = RadioDateTimeUtils::decr_minute(rdt, 45, 5);
        assert_eq!(rdt2.minute, Some(45));
        assert_eq!(rdt2.hour, Some(23));
        assert_eq!(rdt2.weekday, Some(2));
        assert_eq!(rdt2.day, Some(3));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
    }

    #[test]
    fn test_to_utc_at_winter() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(0, false);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(23);
        rdt.minute = Some(36);
        rdt.dst = Some(0); // normal time
        let rdt2 = rdt.get_utc().unwrap();
        assert_eq!(rdt2.minute, Some(36));
        assert_eq!(rdt2.hour, Some(23));
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(false));
    }

    #[test]
    fn test_to_utc_at_summer() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(0, false);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(23);
        rdt.minute = Some(36);
        rdt.dst = Some(DST_SUMMER);
        let rdt2 = rdt.get_utc().unwrap();
        assert_eq!(rdt2.minute, Some(36));
        assert_eq!(rdt2.hour, Some(22));
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(false));
    }

    #[test]
    fn test_to_local_at_winter() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(0, true);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(23);
        rdt.minute = Some(36);
        rdt.dst = Some(0); // normal time
        let rdt2 = rdt.get_local_time().unwrap();
        assert_eq!(rdt2.minute, Some(36));
        assert_eq!(rdt2.hour, Some(23));
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(true));
    }

    #[test]
    fn test_to_local_at_summer() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(0, true);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(23);
        rdt.minute = Some(36);
        rdt.dst = Some(DST_SUMMER);
        let rdt2 = rdt.get_local_time().unwrap();
        assert_eq!(rdt2.minute, Some(36));
        assert_eq!(rdt2.hour, Some(0));
        assert_eq!(rdt2.weekday, Some(0));
        assert_eq!(rdt2.day, Some(8));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(true));
    }

    // fictional time zones of -30m and +30m for UTC<->LT tests

    #[test]
    fn test_to_utc_east_winter() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(30, false);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(23);
        rdt.minute = Some(36);
        rdt.dst = Some(0); // normal time
        let rdt2 = rdt.get_utc().unwrap();
        assert_eq!(rdt2.minute, Some(6));
        assert_eq!(rdt2.hour, Some(23));
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(false));
    }

    #[test]
    fn test_to_utc_east_summer() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(30, false);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(23);
        rdt.minute = Some(36);
        rdt.dst = Some(DST_SUMMER);
        let rdt2 = rdt.get_utc().unwrap();
        assert_eq!(rdt2.minute, Some(6));
        assert_eq!(rdt2.hour, Some(22));
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(false));
    }

    #[test]
    fn test_to_local_east_winter() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(30, true);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(23);
        rdt.minute = Some(36);
        rdt.dst = Some(0); // normal time
        let rdt2 = rdt.get_local_time().unwrap();
        assert_eq!(rdt2.minute, Some(6));
        assert_eq!(rdt2.hour, Some(0));
        assert_eq!(rdt2.weekday, Some(0));
        assert_eq!(rdt2.day, Some(8));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(true));
    }

    #[test]
    fn test_to_local_east_summer() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(30, true);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(23);
        rdt.minute = Some(36);
        rdt.dst = Some(DST_SUMMER);
        let rdt2 = rdt.get_local_time().unwrap();
        assert_eq!(rdt2.minute, Some(6));
        assert_eq!(rdt2.hour, Some(1));
        assert_eq!(rdt2.weekday, Some(0));
        assert_eq!(rdt2.day, Some(8));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(true));
    }

    #[test]
    fn test_to_utc_west_winter() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(-30, false);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(21);
        rdt.minute = Some(36);
        rdt.dst = Some(0); // normal time
        let rdt2 = rdt.get_utc().unwrap();
        assert_eq!(rdt2.minute, Some(6));
        assert_eq!(rdt2.hour, Some(22));
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(false));
    }

    #[test]
    fn test_to_utc_west_summer() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(-30, false);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(21);
        rdt.minute = Some(36);
        rdt.dst = Some(DST_SUMMER);
        let rdt2 = rdt.get_utc().unwrap();
        assert_eq!(rdt2.minute, Some(6));
        assert_eq!(rdt2.hour, Some(21)); // flips from increasing time to decreasing time
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(false));
    }

    #[test]
    fn test_to_local_west_winter() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(-30, true);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(21);
        rdt.minute = Some(36);
        rdt.dst = Some(0); // normal time
        let rdt2 = rdt.get_local_time().unwrap();
        assert_eq!(rdt2.minute, Some(6));
        assert_eq!(rdt2.hour, Some(21));
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(true));
    }

    #[test]
    fn test_to_local_west_summer() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(-30, true);
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(21);
        rdt.minute = Some(36);
        rdt.dst = Some(DST_SUMMER);
        let rdt2 = rdt.get_local_time().unwrap();
        assert_eq!(rdt2.minute, Some(6));
        assert_eq!(rdt2.hour, Some(22)); // flips from decreasing time to increasing time
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(true));
    }

    #[test]
    fn test_to_utc_incomplete() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(0, false);
        assert_eq!(rdt.get_utc(), None);
    }

    #[test]
    fn test_to_local_incomplete() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(0, true);
        assert_eq!(rdt.get_local_time(), None);
    }

    #[test]
    fn test_utc_set_dst() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(0, true);
        assert_eq!(rdt.dst_count, 0);
        assert_eq!(rdt.dst, None);
        // sets DST flag to summer time in UTC mode, but does not affect date/time itself:
        let mut rdt_new = rdt;
        rdt_new.set_dst(Some(true), Some(true), false);
        // adjust original value for wholesale comparison:
        rdt.dst = Some(DST_SUMMER);
        // we did one cycle:
        rdt.dst_count = 1;
        rdt.first_minute = false;
        assert_eq!(rdt_new, rdt);
    }

    #[test]
    fn test_readonly_year() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.is_readonly = true;
        rdt.set_year(Some(24), true, false);
        assert_eq!(rdt.is_readonly, true);
        assert_eq!(rdt.year, None);
    }

    #[test]
    fn test_readonly_month() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.is_readonly = true;
        rdt.set_month(Some(12), true, false);
        assert_eq!(rdt.is_readonly, true);
        assert_eq!(rdt.month, None);
    }

    #[test]
    fn test_readonly_weekday() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.is_readonly = true;
        rdt.set_weekday(Some(7), true, false);
        assert_eq!(rdt.is_readonly, true);
        assert_eq!(rdt.weekday, None);
    }

    #[test]
    fn test_readonly_day() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.is_readonly = true;
        rdt.set_year(Some(24), true, false);
        rdt.set_month(Some(12), true, false);
        rdt.set_weekday(Some(7), true, false);
        rdt.set_day(Some(15), true, false);
        assert_eq!(rdt.is_readonly, true);
        assert_eq!(rdt.day, None);
    }

    #[test]
    fn test_readonly_hour() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.is_readonly = true;
        rdt.set_hour(Some(22), true, false);
        assert_eq!(rdt.is_readonly, true);
        assert_eq!(rdt.hour, None);
    }

    #[test]
    fn test_readonly_minute() {
        let mut rdt = RadioDateTimeUtils::new(7);
        rdt.is_readonly = true;
        rdt.set_minute(Some(50), true, false);
        assert_eq!(rdt.is_readonly, true);
        assert_eq!(rdt.minute, None);
    }

    #[test]
    fn test_readonly_to_utc_at_summer() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(0, false);
        rdt.is_readonly = true;
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(23);
        rdt.minute = Some(36);
        rdt.dst = Some(DST_SUMMER);
        let rdt2 = rdt.get_utc().unwrap();
        // input read-only, so output should be unchanged here:
        assert_eq!(rdt2.minute, Some(36));
        assert_eq!(rdt2.hour, Some(23));
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(false));
    }

    #[test]
    fn test_readonly_to_local_at_summer() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.set_utc_offset(0, true);
        rdt.is_readonly = true;
        rdt.year = Some(24);
        rdt.month = Some(12);
        rdt.day = Some(7);
        rdt.weekday = Some(6);
        rdt.hour = Some(23);
        rdt.minute = Some(36);
        rdt.dst = Some(DST_SUMMER);
        let rdt2 = rdt.get_local_time().unwrap();
        // input read-only, so output should be unchanged here:
        assert_eq!(rdt2.minute, Some(36));
        assert_eq!(rdt2.hour, Some(23));
        assert_eq!(rdt2.weekday, Some(6));
        assert_eq!(rdt2.day, Some(7));
        assert_eq!(rdt2.month, Some(12));
        assert_eq!(rdt2.year, Some(24));
        assert_eq!(rdt2.is_readonly, true);
        // is_utc indicates the UTC-ness of the transmitter, not of the result
        assert_eq!(rdt2.is_utc, Some(true));
    }

    #[test]
    fn test_readonly_clear_jumps() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.is_readonly = true;
        rdt.jump_year = true;
        rdt.jump_month = true;
        rdt.jump_weekday = true;
        rdt.jump_day = true;
        rdt.jump_hour = true;
        rdt.jump_minute = true;
        rdt.dst = Some(DST_JUMP);
        rdt.clear_jumps();
        assert_eq!(rdt.is_readonly, true);
        assert_eq!(rdt.jump_year, true);
        assert_eq!(rdt.jump_month, true);
        assert_eq!(rdt.jump_weekday, true);
        assert_eq!(rdt.jump_day, true);
        assert_eq!(rdt.jump_hour, true);
        assert_eq!(rdt.jump_minute, true);
        assert_eq!(rdt.dst, Some(DST_JUMP));
    }

    #[test]
    fn test_readonly_add_minute() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.is_readonly = true;
        assert_eq!(rdt.add_minute(), false);
    }

    #[test]
    fn test_readonly_bump_minutes_running() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.is_readonly = true;
        rdt.bump_minutes_running();
        assert_eq!(rdt.minutes_running, 0);
    }

    #[test]
    fn test_readonly_set_month_day() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.is_readonly = true;
        rdt.set_month_day(Some(60), Some(true), true, true, false);
        assert_eq!(rdt.is_readonly, true);
        assert_eq!(rdt.month, None);
        assert_eq!(rdt.day, None);
    }

    #[test]
    fn test_readonly_set_dst() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.is_readonly = true;
        assert_eq!(rdt.dst_count, 0);
        assert_eq!(rdt.dst, None);
        // should do nothing
        let mut rdt_new = rdt;
        rdt_new.set_dst(Some(true), Some(true), false);
        assert_eq!(rdt_new, rdt);
        assert_eq!(rdt_new.first_minute, true);
    }

    #[test]
    fn test_readonly_set_leap_second() {
        let mut rdt = RadioDateTimeUtils::new(0);
        rdt.is_readonly = true;
        assert_eq!(rdt.leap_second_count, 0);
        assert_eq!(rdt.leap_second, None);
        // should do nothing
        let mut rdt_new = rdt;
        rdt_new.set_leap_second(Some(true), 60);
        assert_eq!(rdt_new, rdt);
    }
}