hegeltest 0.12.5

Property-based testing for Rust, built on Hypothesis
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

use jiff::civil::{Date, DateTime, ISOWeekDate, Time};
use jiff::tz::{AmbiguousOffset, Offset, TimeZone};
use jiff::{SignedDuration, Span, Timestamp, Zoned};

use crate::generators::{self as gs, BoxedGenerator, DefaultGenerator, Generator, Mapped, one_of};

use super::{
    DateGenerator, DateTimeGenerator, OffsetGenerator, SignedDurationGenerator, SpanGenerator,
    TimeGenerator, TimestampGenerator, ZonedGenerator, dates, datetimes, offsets, signed_durations,
    spans, times, timestamps, zoneds,
};

impl DefaultGenerator for Date {
    type Generator = DateGenerator;
    fn default_generator() -> Self::Generator {
        dates()
    }
}

impl DefaultGenerator for Time {
    type Generator = TimeGenerator;
    fn default_generator() -> Self::Generator {
        times()
    }
}

impl DefaultGenerator for DateTime {
    type Generator = DateTimeGenerator;
    fn default_generator() -> Self::Generator {
        datetimes()
    }
}

impl DefaultGenerator for ISOWeekDate {
    type Generator = Mapped<Date, ISOWeekDate, fn(Date) -> ISOWeekDate, DateGenerator>;
    fn default_generator() -> Self::Generator {
        dates().map(|d| d.iso_week_date())
    }
}

impl DefaultGenerator for Timestamp {
    type Generator = TimestampGenerator;
    fn default_generator() -> Self::Generator {
        timestamps()
    }
}

impl DefaultGenerator for Span {
    type Generator = SpanGenerator;
    fn default_generator() -> Self::Generator {
        spans()
    }
}

impl DefaultGenerator for SignedDuration {
    type Generator = SignedDurationGenerator;
    fn default_generator() -> Self::Generator {
        signed_durations()
    }
}

impl DefaultGenerator for Offset {
    type Generator = OffsetGenerator;
    fn default_generator() -> Self::Generator {
        offsets()
    }
}

impl DefaultGenerator for TimeZone {
    type Generator = BoxedGenerator<'static, TimeZone>;
    fn default_generator() -> Self::Generator {
        one_of([
            gs::just::<TimeZone>(TimeZone::UTC).boxed(),
            gs::just::<TimeZone>(TimeZone::unknown()).boxed(),
            offsets().map(TimeZone::fixed).boxed(),
        ])
        .boxed()
    }
}

impl DefaultGenerator for Zoned {
    type Generator = ZonedGenerator;
    fn default_generator() -> Self::Generator {
        zoneds()
    }
}

impl DefaultGenerator for AmbiguousOffset {
    type Generator = BoxedGenerator<'static, AmbiguousOffset>;
    fn default_generator() -> Self::Generator {
        use crate::tuples;
        one_of([
            offsets()
                .map(|offset| AmbiguousOffset::Unambiguous { offset })
                .boxed(),
            tuples!(offsets(), offsets())
                .map(|(before, after)| AmbiguousOffset::Gap { before, after })
                .boxed(),
            tuples!(offsets(), offsets())
                .map(|(before, after)| AmbiguousOffset::Fold { before, after })
                .boxed(),
        ])
        .boxed()
    }
}