icu_calendar 2.2.1

Date APIs for Gregorian and non-Gregorian calendars
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

use crate::calendar_arithmetic::{CONSTRUCTOR_YEAR_RANGE, VALID_RD_RANGE};
use crate::*;

// Check rd -> date -> iso -> date -> rd for whole range
super::test_all_cals!(
    #[ignore] // takes about 200 seconds in release-with-assertions
    fn check_round_trip<C: Calendar + Copy>(cal: C) {
        let low = *VALID_RD_RANGE.start();
        let high = *VALID_RD_RANGE.end();
        let mut prev = Date::from_rata_die(low, cal);
        let mut curr = low + 1;
        while curr <= high {
            let date = Date::from_rata_die(curr, cal);
            assert!(prev < date);

            assert_eq!(
                date.to_rata_die(),
                curr,
                "{}",
                cal.as_calendar().debug_name()
            );

            prev = date;
            curr += 1;
        }
    }
);

super::test_all_cals!(
    #[ignore] // takes about 90 seconds in release-with-assertions
    fn check_from_fields<C: Calendar + Copy>(cal: C) {
        let months = (1..19)
            .flat_map(|i| [types::Month::new(i), types::Month::leap(i)].into_iter())
            .collect::<Vec<_>>();
        for year in CONSTRUCTOR_YEAR_RANGE {
            if year % 50000 == 0 {
                println!("{} {year:?}", cal.as_calendar().debug_name());
            }
            for overflow in [options::Overflow::Constrain, options::Overflow::Reject] {
                #![allow(clippy::field_reassign_with_default)] // use public API
                let mut options = options::DateFromFieldsOptions::default();
                options.overflow = Some(overflow);
                for mut fields in months
                    .iter()
                    .map(|&m| {
                        let mut fields = types::DateFields::default();
                        fields.month = Some(m);
                        fields
                    })
                    .chain((1..20).map(|m| {
                        let mut fields = types::DateFields::default();
                        fields.ordinal_month = Some(m);
                        fields
                    }))
                {
                    for day in 1..50 {
                        fields.extended_year = Some(year);
                        fields.day = Some(day);
                        let _ = Date::try_from_fields(fields, options, cal);
                    }
                }
            }
        }
    }
);