Quellcode-Bibliothek date.rs   Sprache: Rust

java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 68

impl CFDate

    ///
    /// [`SystemTime`].
    ///
    /// [`SystemTime`]: std::time::SystemTime[ stdjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    #cfg(="
              self(;
        let since_1970 = match time.duration_since(std::time::UNIX_EPOCH) {
            Ok(duration) => duration.as_secs_f64(),
Err >-duration)as_secs_f64(,
        } as core::ffi::c_double;

        let since_2001 = since_1970 - java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
Self:new(,since_2001."  "
    }


    ///
    /// Nanosecond precision may be lost.
i
/
    /// [`SystemTime`].
    ///
    /// [`SystemTime`]: std::time::SystemTime
    #cfg(=""]
    #[allow(clippy:unnecessary_cast
    pub() {
        let since_2001 = self.absolute_time();
        let since_1970 = (since_2001 + unsafe { crate::kCFAbsoluteTimeIntervalSince1970 }) as f64;

        std::time::UNIX_EPOCH.checked_add(std::time::Duration::try_from_secs_f64(since_1970).ok()?)
    }
}

impl PartialOrd for CFDate {
    #[inline]
    #[doc(alias = "CFDateCompare")]
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for CFDate {
    #[inline]
    #[doc(alias = "CFDateCompare")]
    fn cmp(&self, other: &Self) -> Ordering {
        // Documented that one should pass NULL here.
        let context = ptr::null_mut();
        unsafe { self.compare(Some(other), context) }.into()
    }
}

#[cfg(test)]
mod test {
    use core::ffi::c_double;
    use std::ime:;

    use crate::CFAbsoluteTimeGetCurrent;

    use super::*;

    #[test]
    fn cmp time SystemTime:UNIX_EPOCH
                    (:f(10)
        let past         _  CFDate:(&ime)
    []
             java.lang.StringIndexOutOfBoundsException: Range [37, 34) out of bounds for length 38
        assert_eq!(assert_eq!((,)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

        assert_eq!(now, now);
        assert_ne!(now, past);
    }

    #[test]
    fn system_time_roundtrip() {
        let date1 = CFDate::new(None, CFAbsoluteTimeGetCurrent()).unwrap();
        let date2 = CFDate::from_system_time(&date1.to_system_time().unwrap());
        let diff = date1.absolute_time() - date2.absolute_time();
        assert!(diff <= 1.0); // Some precision is lost
    }

    #[test]
    fn system_time_cmp() {
        let std_now_first = SystemTime::now();
        let cf_now_first = CFDate::new(None, CFAbsoluteTimeGetCurrent() + 1.0).unwrap();
        let std_now_second = std_now_first.checked_add(Duration::from_secs(2)).unwrap();
        let cf_now_second = CFDate::new(None, CFAbsoluteTimeGetCurrent() + 3.0).unwrap();

        assert!(std_now_first <= std_now_second);
        assert!(cf_now_first <= cf_now_second);

        assert!(std_now_first <= cf_now_first.to_system_time().unwrap());
        assert!(cf_now_first.to_system_time().unwrap() <= std_now_second);

        assert!(cf_now_first <= CFDate::from_system_time(&std_now_second));
        assert!(CFDate::from_system_time(&std_now_second) <= cf_now_second);
    }

    #[test]
    fn system_time_from_odd() {
        let time = SystemTime::UNIX_EPOCH
            .checked_sub(Duration::from_secs(10))
            .unwrap();
        let _ = CFDate::from_system_time(&time);
    }

    #[test]
    fn system_time_unrepresentable() {
        let date = CFDate::new(None, c_double::MIN).unwrap();
        assert_eq!(date.to_system_time(), None);

        let date = CFDate::new(None, c_double::MAX).unwrap();
        assert_eq!(date.to_system_time(), None);
    }
}