tz/timezone/
mod.rs

1//! Types related to a time zone.
2
3mod rule;
4
5#[doc(inline)]
6pub use rule::{AlternateTime, Julian0WithLeap, Julian1WithoutLeap, MonthWeekDay, RuleDay, TransitionRule};
7
8use crate::error::timezone::{LocalTimeTypeError, TimeZoneError};
9use crate::error::TzError;
10use crate::utils::{binary_search_leap_seconds, binary_search_transitions};
11
12#[cfg(feature = "alloc")]
13use crate::{
14    error::parse::TzStringError,
15    parse::{parse_posix_tz, parse_tz_file},
16};
17
18use core::fmt;
19use core::str;
20
21#[cfg(feature = "alloc")]
22use alloc::{boxed::Box, format, vec, vec::Vec};
23
24/// Transition of a TZif file
25#[derive(Debug, Copy, Clone, Eq, PartialEq)]
26pub struct Transition {
27    /// Unix leap time
28    unix_leap_time: i64,
29    /// Index specifying the local time type of the transition
30    local_time_type_index: usize,
31}
32
33impl Transition {
34    /// Construct a TZif file transition
35    #[inline]
36    pub const fn new(unix_leap_time: i64, local_time_type_index: usize) -> Self {
37        Self { unix_leap_time, local_time_type_index }
38    }
39
40    /// Returns Unix leap time
41    #[inline]
42    pub const fn unix_leap_time(&self) -> i64 {
43        self.unix_leap_time
44    }
45
46    /// Returns local time type index
47    #[inline]
48    pub const fn local_time_type_index(&self) -> usize {
49        self.local_time_type_index
50    }
51}
52
53/// Leap second of a TZif file
54#[derive(Debug, Copy, Clone, Eq, PartialEq)]
55pub struct LeapSecond {
56    /// Unix leap time
57    unix_leap_time: i64,
58    /// Leap second correction
59    correction: i32,
60}
61
62impl LeapSecond {
63    /// Construct a TZif file leap second
64    #[inline]
65    pub const fn new(unix_leap_time: i64, correction: i32) -> Self {
66        Self { unix_leap_time, correction }
67    }
68
69    /// Returns Unix leap time
70    #[inline]
71    pub const fn unix_leap_time(&self) -> i64 {
72        self.unix_leap_time
73    }
74
75    /// Returns leap second correction
76    #[inline]
77    pub const fn correction(&self) -> i32 {
78        self.correction
79    }
80}
81
82/// ASCII-encoded fixed-capacity string, used for storing time zone designations
83#[derive(Copy, Clone, Eq, PartialEq)]
84struct TzAsciiStr {
85    /// Length-prefixed string buffer
86    bytes: [u8; 8],
87}
88
89impl TzAsciiStr {
90    /// Construct a time zone designation string
91    const fn new(input: &[u8]) -> Result<Self, LocalTimeTypeError> {
92        let len = input.len();
93
94        if !(3 <= len && len <= 7) {
95            return Err(LocalTimeTypeError::InvalidTimeZoneDesignationLength);
96        }
97
98        let mut bytes = [0; 8];
99        bytes[0] = input.len() as u8;
100
101        let mut i = 0;
102        while i < len {
103            let b = input[i];
104
105            if !matches!(b, b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z' | b'+' | b'-') {
106                return Err(LocalTimeTypeError::InvalidTimeZoneDesignationChar);
107            }
108
109            bytes[i + 1] = b;
110
111            i += 1;
112        }
113
114        Ok(Self { bytes })
115    }
116
117    /// Returns time zone designation as a byte slice
118    #[inline]
119    const fn as_bytes(&self) -> &[u8] {
120        match &self.bytes {
121            [3, head @ .., _, _, _, _] => head,
122            [4, head @ .., _, _, _] => head,
123            [5, head @ .., _, _] => head,
124            [6, head @ .., _] => head,
125            [7, head @ ..] => head,
126            _ => unreachable!(),
127        }
128    }
129
130    /// Returns time zone designation as a string
131    #[inline]
132    const fn as_str(&self) -> &str {
133        match str::from_utf8(self.as_bytes()) {
134            Ok(s) => s,
135            Err(_) => panic!("unreachable code: ASCII is valid UTF-8"),
136        }
137    }
138
139    /// Check if two time zone designations are equal
140    #[inline]
141    const fn equal(&self, other: &Self) -> bool {
142        u64::from_ne_bytes(self.bytes) == u64::from_ne_bytes(other.bytes)
143    }
144}
145
146impl fmt::Debug for TzAsciiStr {
147    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
148        self.as_str().fmt(f)
149    }
150}
151
152/// Local time type associated to a time zone
153#[derive(Debug, Copy, Clone, Eq, PartialEq)]
154pub struct LocalTimeType {
155    /// Offset from UTC in seconds
156    ut_offset: i32,
157    /// Daylight Saving Time indicator
158    is_dst: bool,
159    /// Time zone designation
160    time_zone_designation: Option<TzAsciiStr>,
161}
162
163impl LocalTimeType {
164    /// Construct a local time type
165    pub const fn new(ut_offset: i32, is_dst: bool, time_zone_designation: Option<&[u8]>) -> Result<Self, LocalTimeTypeError> {
166        if ut_offset == i32::MIN {
167            return Err(LocalTimeTypeError::InvalidUtcOffset);
168        }
169
170        let time_zone_designation = match time_zone_designation {
171            None => None,
172            Some(time_zone_designation) => match TzAsciiStr::new(time_zone_designation) {
173                Err(error) => return Err(error),
174                Ok(time_zone_designation) => Some(time_zone_designation),
175            },
176        };
177
178        Ok(Self { ut_offset, is_dst, time_zone_designation })
179    }
180
181    /// Construct the local time type associated to UTC
182    #[inline]
183    pub const fn utc() -> Self {
184        Self { ut_offset: 0, is_dst: false, time_zone_designation: None }
185    }
186
187    /// Construct a local time type with the specified UTC offset in seconds
188    #[inline]
189    pub const fn with_ut_offset(ut_offset: i32) -> Result<Self, LocalTimeTypeError> {
190        if ut_offset == i32::MIN {
191            return Err(LocalTimeTypeError::InvalidUtcOffset);
192        }
193
194        Ok(Self { ut_offset, is_dst: false, time_zone_designation: None })
195    }
196
197    /// Returns offset from UTC in seconds
198    #[inline]
199    pub const fn ut_offset(&self) -> i32 {
200        self.ut_offset
201    }
202
203    /// Returns daylight saving time indicator
204    #[inline]
205    pub const fn is_dst(&self) -> bool {
206        self.is_dst
207    }
208
209    /// Returns time zone designation
210    #[inline]
211    pub const fn time_zone_designation(&self) -> &str {
212        match &self.time_zone_designation {
213            Some(s) => s.as_str(),
214            None => "",
215        }
216    }
217
218    /// Check if two local time types are equal
219    #[inline]
220    const fn equal(&self, other: &Self) -> bool {
221        self.ut_offset == other.ut_offset
222            && self.is_dst == other.is_dst
223            && match (&self.time_zone_designation, &other.time_zone_designation) {
224                (Some(x), Some(y)) => x.equal(y),
225                (None, None) => true,
226                _ => false,
227            }
228    }
229}
230
231/// Reference to a time zone
232#[derive(Debug, Copy, Clone, Eq, PartialEq)]
233pub struct TimeZoneRef<'a> {
234    /// List of transitions
235    transitions: &'a [Transition],
236    /// List of local time types (cannot be empty)
237    local_time_types: &'a [LocalTimeType],
238    /// List of leap seconds
239    leap_seconds: &'a [LeapSecond],
240    /// Extra transition rule applicable after the last transition
241    extra_rule: &'a Option<TransitionRule>,
242}
243
244impl<'a> TimeZoneRef<'a> {
245    /// Construct a time zone reference
246    pub const fn new(
247        transitions: &'a [Transition],
248        local_time_types: &'a [LocalTimeType],
249        leap_seconds: &'a [LeapSecond],
250        extra_rule: &'a Option<TransitionRule>,
251    ) -> Result<Self, TzError> {
252        let time_zone_ref = Self::new_unchecked(transitions, local_time_types, leap_seconds, extra_rule);
253
254        if let Err(error) = time_zone_ref.check_inputs() {
255            return Err(error);
256        }
257
258        Ok(time_zone_ref)
259    }
260
261    /// Construct the time zone reference associated to UTC
262    #[inline]
263    pub const fn utc() -> Self {
264        Self { transitions: &[], local_time_types: &[const { LocalTimeType::utc() }], leap_seconds: &[], extra_rule: &None }
265    }
266
267    /// Returns list of transitions
268    #[inline]
269    pub const fn transitions(&self) -> &'a [Transition] {
270        self.transitions
271    }
272
273    /// Returns list of local time types
274    #[inline]
275    pub const fn local_time_types(&self) -> &'a [LocalTimeType] {
276        self.local_time_types
277    }
278
279    /// Returns list of leap seconds
280    #[inline]
281    pub const fn leap_seconds(&self) -> &'a [LeapSecond] {
282        self.leap_seconds
283    }
284
285    /// Returns extra transition rule applicable after the last transition
286    #[inline]
287    pub const fn extra_rule(&self) -> &'a Option<TransitionRule> {
288        self.extra_rule
289    }
290
291    /// Find the local time type associated to the time zone at the specified Unix time in seconds
292    pub const fn find_local_time_type(&self, unix_time: i64) -> Result<&'a LocalTimeType, TzError> {
293        let extra_rule = match self.transitions {
294            [] => match self.extra_rule {
295                Some(extra_rule) => extra_rule,
296                None => return Ok(&self.local_time_types[0]),
297            },
298            [.., last_transition] => {
299                let unix_leap_time = match self.unix_time_to_unix_leap_time(unix_time) {
300                    Ok(unix_leap_time) => unix_leap_time,
301                    Err(error) => return Err(error),
302                };
303
304                if unix_leap_time >= last_transition.unix_leap_time {
305                    match self.extra_rule {
306                        Some(extra_rule) => extra_rule,
307                        None => return Err(TzError::NoAvailableLocalTimeType),
308                    }
309                } else {
310                    let index = match binary_search_transitions(self.transitions, unix_leap_time) {
311                        Ok(x) => x + 1,
312                        Err(x) => x,
313                    };
314
315                    let local_time_type_index = if index > 0 { self.transitions[index - 1].local_time_type_index } else { 0 };
316                    return Ok(&self.local_time_types[local_time_type_index]);
317                }
318            }
319        };
320
321        extra_rule.find_local_time_type(unix_time)
322    }
323
324    /// Construct a reference to a time zone
325    #[inline]
326    const fn new_unchecked(
327        transitions: &'a [Transition],
328        local_time_types: &'a [LocalTimeType],
329        leap_seconds: &'a [LeapSecond],
330        extra_rule: &'a Option<TransitionRule>,
331    ) -> Self {
332        Self { transitions, local_time_types, leap_seconds, extra_rule }
333    }
334
335    /// Check time zone inputs
336    const fn check_inputs(&self) -> Result<(), TzError> {
337        use crate::constants::*;
338
339        // Check local time types
340        let local_time_types_size = self.local_time_types.len();
341        if local_time_types_size == 0 {
342            return Err(TzError::TimeZone(TimeZoneError::NoLocalTimeType));
343        }
344
345        // Check transitions
346        let mut i_transition = 0;
347        while i_transition < self.transitions.len() {
348            if self.transitions[i_transition].local_time_type_index >= local_time_types_size {
349                return Err(TzError::TimeZone(TimeZoneError::InvalidLocalTimeTypeIndex));
350            }
351
352            if i_transition + 1 < self.transitions.len() && self.transitions[i_transition].unix_leap_time >= self.transitions[i_transition + 1].unix_leap_time {
353                return Err(TzError::TimeZone(TimeZoneError::InvalidTransition));
354            }
355
356            i_transition += 1;
357        }
358
359        // Check leap seconds
360        if !(self.leap_seconds.is_empty() || self.leap_seconds[0].unix_leap_time >= 0 && self.leap_seconds[0].correction.saturating_abs() == 1) {
361            return Err(TzError::TimeZone(TimeZoneError::InvalidLeapSecond));
362        }
363
364        let min_interval = SECONDS_PER_28_DAYS - 1;
365
366        let mut i_leap_second = 0;
367        while i_leap_second < self.leap_seconds.len() {
368            if i_leap_second + 1 < self.leap_seconds.len() {
369                let x0 = &self.leap_seconds[i_leap_second];
370                let x1 = &self.leap_seconds[i_leap_second + 1];
371
372                let diff_unix_leap_time = x1.unix_leap_time.saturating_sub(x0.unix_leap_time);
373                let abs_diff_correction = x1.correction.saturating_sub(x0.correction).saturating_abs();
374
375                if !(diff_unix_leap_time >= min_interval && abs_diff_correction == 1) {
376                    return Err(TzError::TimeZone(TimeZoneError::InvalidLeapSecond));
377                }
378            }
379            i_leap_second += 1;
380        }
381
382        // Check extra rule
383        if let (Some(extra_rule), [.., last_transition]) = (&self.extra_rule, self.transitions) {
384            let last_local_time_type = &self.local_time_types[last_transition.local_time_type_index];
385
386            let unix_time = match self.unix_leap_time_to_unix_time(last_transition.unix_leap_time) {
387                Ok(unix_time) => unix_time,
388                Err(error) => return Err(error),
389            };
390
391            let rule_local_time_type = match extra_rule.find_local_time_type(unix_time) {
392                Ok(rule_local_time_type) => rule_local_time_type,
393                Err(error) => return Err(error),
394            };
395
396            if !last_local_time_type.equal(rule_local_time_type) {
397                return Err(TzError::TimeZone(TimeZoneError::InconsistentExtraRule));
398            }
399        }
400
401        Ok(())
402    }
403
404    /// Convert Unix time to Unix leap time, from the list of leap seconds in a time zone
405    pub(crate) const fn unix_time_to_unix_leap_time(&self, unix_time: i64) -> Result<i64, TzError> {
406        let mut unix_leap_time = unix_time;
407
408        let mut i = 0;
409        while i < self.leap_seconds.len() {
410            let leap_second = &self.leap_seconds[i];
411
412            if unix_leap_time < leap_second.unix_leap_time {
413                break;
414            }
415
416            unix_leap_time = match unix_time.checked_add(leap_second.correction as i64) {
417                Some(unix_leap_time) => unix_leap_time,
418                None => return Err(TzError::OutOfRange),
419            };
420
421            i += 1;
422        }
423
424        Ok(unix_leap_time)
425    }
426
427    /// Convert Unix leap time to Unix time, from the list of leap seconds in a time zone
428    pub(crate) const fn unix_leap_time_to_unix_time(&self, unix_leap_time: i64) -> Result<i64, TzError> {
429        if unix_leap_time == i64::MIN {
430            return Err(TzError::OutOfRange);
431        }
432
433        let index = match binary_search_leap_seconds(self.leap_seconds, unix_leap_time - 1) {
434            Ok(x) => x + 1,
435            Err(x) => x,
436        };
437
438        let correction = if index > 0 { self.leap_seconds[index - 1].correction } else { 0 };
439
440        match unix_leap_time.checked_sub(correction as i64) {
441            Some(unix_time) => Ok(unix_time),
442            None => Err(TzError::OutOfRange),
443        }
444    }
445}
446
447/// Time zone
448#[cfg(feature = "alloc")]
449#[derive(Debug, Clone, Eq, PartialEq)]
450pub struct TimeZone {
451    /// List of transitions
452    transitions: Vec<Transition>,
453    /// List of local time types (cannot be empty)
454    local_time_types: Vec<LocalTimeType>,
455    /// List of leap seconds
456    leap_seconds: Vec<LeapSecond>,
457    /// Extra transition rule applicable after the last transition
458    extra_rule: Option<TransitionRule>,
459}
460
461#[cfg(feature = "alloc")]
462impl TimeZone {
463    /// Construct a time zone
464    pub fn new(
465        transitions: Vec<Transition>,
466        local_time_types: Vec<LocalTimeType>,
467        leap_seconds: Vec<LeapSecond>,
468        extra_rule: Option<TransitionRule>,
469    ) -> Result<Self, TzError> {
470        TimeZoneRef::new_unchecked(&transitions, &local_time_types, &leap_seconds, &extra_rule).check_inputs()?;
471        Ok(Self { transitions, local_time_types, leap_seconds, extra_rule })
472    }
473
474    /// Returns a reference to the time zone
475    #[inline]
476    pub fn as_ref(&self) -> TimeZoneRef<'_> {
477        TimeZoneRef::new_unchecked(&self.transitions, &self.local_time_types, &self.leap_seconds, &self.extra_rule)
478    }
479
480    /// Construct the time zone associated to UTC
481    #[inline]
482    pub fn utc() -> Self {
483        Self { transitions: Vec::new(), local_time_types: vec![LocalTimeType::utc()], leap_seconds: Vec::new(), extra_rule: None }
484    }
485
486    /// Construct a time zone with the specified UTC offset in seconds
487    #[inline]
488    pub fn fixed(ut_offset: i32) -> Result<Self, LocalTimeTypeError> {
489        Ok(Self { transitions: Vec::new(), local_time_types: vec![LocalTimeType::with_ut_offset(ut_offset)?], leap_seconds: Vec::new(), extra_rule: None })
490    }
491
492    /// Find the local time type associated to the time zone at the specified Unix time in seconds
493    pub fn find_local_time_type(&self, unix_time: i64) -> Result<&LocalTimeType, TzError> {
494        self.as_ref().find_local_time_type(unix_time)
495    }
496
497    /// Construct a time zone from the contents of a time zone file
498    pub fn from_tz_data(bytes: &[u8]) -> Result<Self, TzError> {
499        parse_tz_file(bytes)
500    }
501
502    /// Returns local time zone.
503    ///
504    /// This method in not supported on non-UNIX platforms, and returns the UTC time zone instead.
505    ///
506    #[cfg(feature = "std")]
507    pub fn local() -> Result<Self, crate::Error> {
508        TimeZoneSettings::DEFAULT.parse_local()
509    }
510
511    /// Construct a time zone from a POSIX TZ string, as described in [the POSIX documentation of the `TZ` environment variable](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html).
512    #[cfg(feature = "std")]
513    pub fn from_posix_tz(tz_string: &str) -> Result<Self, crate::Error> {
514        TimeZoneSettings::DEFAULT.parse_posix_tz(tz_string)
515    }
516
517    /// Find the current local time type associated to the time zone
518    #[cfg(feature = "std")]
519    pub fn find_current_local_time_type(&self) -> Result<&LocalTimeType, TzError> {
520        self.find_local_time_type(crate::utils::current_unix_time())
521    }
522}
523
524/// Read file function type alias
525#[cfg(feature = "alloc")]
526type ReadFileFn = fn(path: &str) -> Result<Vec<u8>, Box<dyn core::error::Error + Send + Sync + 'static>>;
527
528/// Time zone settings
529#[cfg(feature = "alloc")]
530#[derive(Debug)]
531pub struct TimeZoneSettings<'a> {
532    /// Possible system timezone directories
533    directories: &'a [&'a str],
534    /// Read file function
535    read_file_fn: ReadFileFn,
536}
537
538#[cfg(feature = "alloc")]
539impl<'a> TimeZoneSettings<'a> {
540    /// Default possible system timezone directories
541    pub const DEFAULT_DIRECTORIES: &'static [&'static str] = &["/usr/share/zoneinfo", "/share/zoneinfo", "/etc/zoneinfo"];
542
543    /// Default read file function
544    #[cfg(feature = "std")]
545    pub const DEFAULT_READ_FILE_FN: ReadFileFn = |path| Ok(std::fs::read(path)?);
546
547    /// Default time zone settings
548    #[cfg(feature = "std")]
549    pub const DEFAULT: TimeZoneSettings<'static> = TimeZoneSettings { directories: Self::DEFAULT_DIRECTORIES, read_file_fn: Self::DEFAULT_READ_FILE_FN };
550
551    /// Construct time zone settings
552    pub const fn new(directories: &'a [&'a str], read_file_fn: ReadFileFn) -> TimeZoneSettings<'a> {
553        Self { directories, read_file_fn }
554    }
555
556    /// Returns local time zone using current settings.
557    ///
558    /// This method in not supported on non-UNIX platforms, and returns the UTC time zone instead.
559    ///
560    pub fn parse_local(&self) -> Result<TimeZone, crate::Error> {
561        #[cfg(not(unix))]
562        let local_time_zone = TimeZone::utc();
563
564        #[cfg(unix)]
565        let local_time_zone = self.parse_posix_tz("localtime")?;
566
567        Ok(local_time_zone)
568    }
569
570    /// Construct a time zone from a POSIX TZ string using current settings,
571    /// as described in [the POSIX documentation of the `TZ` environment variable](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html).
572    pub fn parse_posix_tz(&self, tz_string: &str) -> Result<TimeZone, crate::Error> {
573        if tz_string.is_empty() {
574            return Err(TzStringError::Empty.into());
575        }
576
577        if tz_string == "localtime" {
578            return Ok(parse_tz_file(&(self.read_file_fn)("/etc/localtime").map_err(crate::Error::Io)?)?);
579        }
580
581        let mut chars = tz_string.chars();
582        if chars.next() == Some(':') {
583            return Ok(parse_tz_file(&self.read_tz_file(chars.as_str())?)?);
584        }
585
586        match self.read_tz_file(tz_string) {
587            Ok(bytes) => Ok(parse_tz_file(&bytes)?),
588            Err(_) => {
589                let tz_string = tz_string.trim_matches(|c: char| c.is_ascii_whitespace());
590
591                // TZ string extensions are not allowed
592                let rule = parse_posix_tz(tz_string.as_bytes(), false)?;
593
594                let local_time_types = match rule {
595                    TransitionRule::Fixed(local_time_type) => vec![local_time_type],
596                    TransitionRule::Alternate(alternate_time) => vec![*alternate_time.std(), *alternate_time.dst()],
597                };
598
599                Ok(TimeZone::new(vec![], local_time_types, vec![], Some(rule))?)
600            }
601        }
602    }
603
604    /// Read the TZif file corresponding to a TZ string using current settings
605    fn read_tz_file(&self, tz_string: &str) -> Result<Vec<u8>, crate::Error> {
606        let read_file_fn = |path: &str| (self.read_file_fn)(path).map_err(crate::Error::Io);
607
608        // Don't check system timezone directories on non-UNIX platforms
609        #[cfg(not(unix))]
610        return Ok(read_file_fn(tz_string)?);
611
612        #[cfg(unix)]
613        if tz_string.starts_with('/') {
614            Ok(read_file_fn(tz_string)?)
615        } else {
616            self.directories
617                .iter()
618                .find_map(|folder| read_file_fn(&format!("{folder}/{tz_string}")).ok())
619                .ok_or_else(|| crate::Error::Io("file was not found".into()))
620        }
621    }
622}
623
624#[cfg(test)]
625mod tests {
626    use super::*;
627
628    #[test]
629    fn test_tz_ascii_str() -> Result<(), TzError> {
630        assert!(matches!(TzAsciiStr::new(b""), Err(LocalTimeTypeError::InvalidTimeZoneDesignationLength)));
631        assert!(matches!(TzAsciiStr::new(b"1"), Err(LocalTimeTypeError::InvalidTimeZoneDesignationLength)));
632        assert!(matches!(TzAsciiStr::new(b"12"), Err(LocalTimeTypeError::InvalidTimeZoneDesignationLength)));
633        assert_eq!(TzAsciiStr::new(b"123")?.as_bytes(), b"123");
634        assert_eq!(TzAsciiStr::new(b"1234")?.as_bytes(), b"1234");
635        assert_eq!(TzAsciiStr::new(b"12345")?.as_bytes(), b"12345");
636        assert_eq!(TzAsciiStr::new(b"123456")?.as_bytes(), b"123456");
637        assert_eq!(TzAsciiStr::new(b"1234567")?.as_bytes(), b"1234567");
638        assert!(matches!(TzAsciiStr::new(b"12345678"), Err(LocalTimeTypeError::InvalidTimeZoneDesignationLength)));
639        assert!(matches!(TzAsciiStr::new(b"123456789"), Err(LocalTimeTypeError::InvalidTimeZoneDesignationLength)));
640        assert!(matches!(TzAsciiStr::new(b"1234567890"), Err(LocalTimeTypeError::InvalidTimeZoneDesignationLength)));
641
642        assert!(matches!(TzAsciiStr::new(b"123\0\0\0"), Err(LocalTimeTypeError::InvalidTimeZoneDesignationChar)));
643
644        Ok(())
645    }
646
647    #[cfg(feature = "alloc")]
648    #[test]
649    fn test_time_zone() -> Result<(), TzError> {
650        let utc = LocalTimeType::utc();
651        let cet = LocalTimeType::with_ut_offset(3600)?;
652
653        let utc_local_time_types = vec![utc];
654        let fixed_extra_rule = TransitionRule::Fixed(cet);
655
656        let time_zone_1 = TimeZone::new(vec![], utc_local_time_types.clone(), vec![], None)?;
657        let time_zone_2 = TimeZone::new(vec![], utc_local_time_types.clone(), vec![], Some(fixed_extra_rule))?;
658        let time_zone_3 = TimeZone::new(vec![Transition::new(0, 0)], utc_local_time_types.clone(), vec![], None)?;
659        let time_zone_4 = TimeZone::new(vec![Transition::new(i32::MIN.into(), 0), Transition::new(0, 1)], vec![utc, cet], vec![], Some(fixed_extra_rule))?;
660
661        assert_eq!(*time_zone_1.find_local_time_type(0)?, utc);
662        assert_eq!(*time_zone_2.find_local_time_type(0)?, cet);
663
664        assert_eq!(*time_zone_3.find_local_time_type(-1)?, utc);
665        assert!(matches!(time_zone_3.find_local_time_type(0), Err(TzError::NoAvailableLocalTimeType)));
666
667        assert_eq!(*time_zone_4.find_local_time_type(-1)?, utc);
668        assert_eq!(*time_zone_4.find_local_time_type(0)?, cet);
669
670        let time_zone_err = TimeZone::new(vec![Transition::new(0, 0)], utc_local_time_types, vec![], Some(fixed_extra_rule));
671        assert!(time_zone_err.is_err());
672
673        Ok(())
674    }
675
676    #[cfg(feature = "std")]
677    #[test]
678    fn test_time_zone_from_posix_tz() -> Result<(), crate::Error> {
679        #[cfg(unix)]
680        {
681            let time_zone_local = TimeZone::local()?;
682            let time_zone_local_1 = TimeZone::from_posix_tz("localtime")?;
683            let time_zone_local_2 = TimeZone::from_posix_tz("/etc/localtime")?;
684            let time_zone_local_3 = TimeZone::from_posix_tz(":/etc/localtime")?;
685
686            assert_eq!(time_zone_local, time_zone_local_1);
687            assert_eq!(time_zone_local, time_zone_local_2);
688            assert_eq!(time_zone_local, time_zone_local_3);
689
690            assert!(matches!(time_zone_local.find_current_local_time_type(), Ok(_) | Err(TzError::NoAvailableLocalTimeType)));
691
692            let time_zone_utc = TimeZone::from_posix_tz("UTC")?;
693            assert_eq!(time_zone_utc.find_local_time_type(0)?.ut_offset(), 0);
694        }
695
696        assert!(TimeZone::from_posix_tz("EST5EDT,0/0,J365/25").is_err());
697        assert!(TimeZone::from_posix_tz("").is_err());
698
699        Ok(())
700    }
701
702    #[cfg(feature = "alloc")]
703    #[test]
704    fn test_leap_seconds() -> Result<(), TzError> {
705        let time_zone = TimeZone::new(
706            vec![],
707            vec![LocalTimeType::new(0, false, Some(b"UTC"))?],
708            vec![
709                LeapSecond::new(78796800, 1),
710                LeapSecond::new(94694401, 2),
711                LeapSecond::new(126230402, 3),
712                LeapSecond::new(157766403, 4),
713                LeapSecond::new(189302404, 5),
714                LeapSecond::new(220924805, 6),
715                LeapSecond::new(252460806, 7),
716                LeapSecond::new(283996807, 8),
717                LeapSecond::new(315532808, 9),
718                LeapSecond::new(362793609, 10),
719                LeapSecond::new(394329610, 11),
720                LeapSecond::new(425865611, 12),
721                LeapSecond::new(489024012, 13),
722                LeapSecond::new(567993613, 14),
723                LeapSecond::new(631152014, 15),
724                LeapSecond::new(662688015, 16),
725                LeapSecond::new(709948816, 17),
726                LeapSecond::new(741484817, 18),
727                LeapSecond::new(773020818, 19),
728                LeapSecond::new(820454419, 20),
729                LeapSecond::new(867715220, 21),
730                LeapSecond::new(915148821, 22),
731                LeapSecond::new(1136073622, 23),
732                LeapSecond::new(1230768023, 24),
733                LeapSecond::new(1341100824, 25),
734                LeapSecond::new(1435708825, 26),
735                LeapSecond::new(1483228826, 27),
736            ],
737            None,
738        )?;
739
740        let time_zone_ref = time_zone.as_ref();
741
742        assert!(matches!(time_zone_ref.unix_leap_time_to_unix_time(1136073621), Ok(1136073599)));
743        assert!(matches!(time_zone_ref.unix_leap_time_to_unix_time(1136073622), Ok(1136073600)));
744        assert!(matches!(time_zone_ref.unix_leap_time_to_unix_time(1136073623), Ok(1136073600)));
745        assert!(matches!(time_zone_ref.unix_leap_time_to_unix_time(1136073624), Ok(1136073601)));
746
747        assert!(matches!(time_zone_ref.unix_time_to_unix_leap_time(1136073599), Ok(1136073621)));
748        assert!(matches!(time_zone_ref.unix_time_to_unix_leap_time(1136073600), Ok(1136073623)));
749        assert!(matches!(time_zone_ref.unix_time_to_unix_leap_time(1136073601), Ok(1136073624)));
750
751        Ok(())
752    }
753
754    #[cfg(feature = "alloc")]
755    #[test]
756    fn test_leap_seconds_overflow() -> Result<(), TzError> {
757        let time_zone_err = TimeZone::new(
758            vec![Transition::new(i64::MIN, 0)],
759            vec![LocalTimeType::utc()],
760            vec![LeapSecond::new(0, 1)],
761            Some(TransitionRule::Fixed(LocalTimeType::utc())),
762        );
763        assert!(time_zone_err.is_err());
764
765        let time_zone = TimeZone::new(vec![Transition::new(i64::MAX, 0)], vec![LocalTimeType::utc()], vec![LeapSecond::new(0, 1)], None)?;
766        assert!(matches!(time_zone.find_local_time_type(i64::MAX), Err(TzError::OutOfRange)));
767
768        Ok(())
769    }
770}
tz/timezone/mod.rs

tz/timezone/
mod.rs
