pleiades-types 0.6.0

Shared typed vocabulary for the pleiades astrology workspace: angles, bodies, time scales, observers, coordinates, zodiac modes, house systems, and ayanamsas.
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use crate::*;

#[test]
fn time_range_checks_scale_and_julian_day() {
    let start = Instant::new(JulianDay::from_days(2451545.0), TimeScale::Tt);
    let end = Instant::new(JulianDay::from_days(2451546.0), TimeScale::Tt);
    let range = TimeRange::new(Some(start), Some(end));

    assert!(range.contains(Instant::new(JulianDay::from_days(2451545.5), TimeScale::Tt)));
    assert!(!range.contains(Instant::new(
        JulianDay::from_days(2451545.5),
        TimeScale::Utc
    )));
    assert_eq!(
        range.summary_line(),
        "JD 2451545.0 (TT) → JD 2451546.0 (TT)"
    );
    assert_eq!(range.to_string(), range.summary_line());
    assert!(range.validate().is_ok());
    assert_eq!(TimeRange::new(Some(start), None).validate(), Ok(()));
    assert_eq!(
        TimeRange::new(Some(start), None).to_string(),
        "from JD 2451545.0 (TT)"
    );
    assert_eq!(
        TimeRange::new(None, Some(end)).to_string(),
        "through JD 2451546.0 (TT)"
    );
    assert_eq!(TimeRange::new(None, None).to_string(), "unbounded");
}

#[test]
fn time_range_validation_rejects_non_finite_bounds_and_invalid_order() {
    let finite_start = Instant::new(JulianDay::from_days(2451545.0), TimeScale::Tt);
    let finite_end = Instant::new(JulianDay::from_days(2451546.0), TimeScale::Tt);

    let error = TimeRange::new(
        Some(Instant::new(
            JulianDay::from_days(f64::INFINITY),
            TimeScale::Tt,
        )),
        Some(finite_end),
    )
    .validate()
    .expect_err("non-finite start bounds should fail validation");
    assert_eq!(
        error.summary_line(),
        "time range bound `start` must be finite: JD inf (TT)"
    );
    assert_eq!(error.to_string(), error.summary_line());

    let error = TimeRange::new(
        Some(finite_start),
        Some(Instant::new(
            JulianDay::from_days(f64::NEG_INFINITY),
            TimeScale::Tt,
        )),
    )
    .validate()
    .expect_err("non-finite end bounds should fail validation");
    assert_eq!(
        error.summary_line(),
        "time range bound `end` must be finite: JD -inf (TT)"
    );
    assert_eq!(error.to_string(), error.summary_line());

    let error = TimeRange::new(
        Some(Instant::new(JulianDay::from_days(2451545.0), TimeScale::Tt)),
        Some(Instant::new(
            JulianDay::from_days(2451546.0),
            TimeScale::Tdb,
        )),
    )
    .validate()
    .expect_err("mixed time-scale bounds should fail validation");
    assert_eq!(
            error.summary_line(),
            "time range bounds must use the same time scale: start=JD 2451545.0 (TT); end=JD 2451546.0 (TDB)"
        );
    assert_eq!(error.to_string(), error.summary_line());

    let error = TimeRange::new(Some(finite_end), Some(finite_start))
        .validate()
        .expect_err("out-of-order ranges should fail validation");
    assert_eq!(
        error.summary_line(),
        "time range end must not precede the start: start=JD 2451546.0 (TT); end=JD 2451545.0 (TT)"
    );
    assert_eq!(error.to_string(), error.summary_line());
}

#[test]
fn time_range_contains_and_validate_respect_boundaries() {
    let start = Instant::new(JulianDay::from_days(2_451_545.0), TimeScale::Tt);
    let end = Instant::new(JulianDay::from_days(2_451_546.0), TimeScale::Tt);
    let range = TimeRange::new(Some(start), Some(end));

    // Same scale, but outside each bound: the && form excludes these; the ||
    // mutant would wrongly include a value that fails exactly one clause.
    let before = Instant::new(JulianDay::from_days(2_451_544.5), TimeScale::Tt);
    let after = Instant::new(JulianDay::from_days(2_451_546.5), TimeScale::Tt);
    assert!(
        !range.contains(before),
        "instant before start must not be contained"
    );
    assert!(
        !range.contains(after),
        "instant after end must not be contained"
    );
    // A same-scale in-range instant IS contained (guards the 37 && overall).
    assert!(range.contains(Instant::new(
        JulianDay::from_days(2_451_545.5),
        TimeScale::Tt
    )));

    // Degenerate range start == end must validate Ok; the >= mutant flags it
    // as out-of-order.
    let point = TimeRange::new(Some(start), Some(start));
    assert_eq!(point.validate(), Ok(()));
}