pipecircuit 0.0.23

Correct. Robust. Fast. Portable. Pick four.
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
121
122
123
124
125
126
127
128

use super::*;

#[test]
fn counters_make_overflow_explicit() {
    let mut counter = EvidenceCounter::new();
    assert!(!counter.saturated());
    counter.record(u64::MAX);
    assert!(!counter.saturated());
    assert!(counter.valid());
    counter.record(1);

    assert_eq!(counter.total(), u64::MAX);
    assert!(counter.saturated());
    assert!(!counter.valid());

    counter.reset();

    assert_eq!(counter, EvidenceCounter::new());
}

#[test]
fn counter_merges_preserve_totals_and_saturation() {
    let mut left = EvidenceCounter::new();
    left.record(2);
    let mut right = EvidenceCounter::new();
    right.record(3);
    left.merge(right);

    assert_eq!(left.total(), 5);
    assert!(left.valid());

    right.record(u64::MAX);
    left.merge(right);

    assert_eq!(left.total(), u64::MAX);
    assert!(left.saturated());

    let mut empty = EvidenceCounter::new();
    empty.merge(right);
    assert_eq!(empty.total(), u64::MAX);
    assert!(empty.saturated());
    assert!(!empty.valid());
}

#[test]
fn high_water_marks_only_retain_the_largest_observation() {
    let mut high_water_mark = EvidenceHighWaterMark::new();
    high_water_mark.observe(4);
    high_water_mark.observe(2);
    high_water_mark.observe(9);

    assert_eq!(high_water_mark.maximum(), 9);

    high_water_mark.reset();

    assert_eq!(high_water_mark, EvidenceHighWaterMark::new());
}

#[test]
fn gauges_preserve_current_pressure_and_high_water() {
    let mut gauge = EvidenceGauge::new(2);
    assert!(!gauge.invalid());
    assert_eq!(gauge.high_water().maximum(), 2);
    gauge.increase(3);
    gauge.decrease(1);

    assert_eq!(gauge.current(), 4);
    assert_eq!(gauge.high_water().maximum(), 5);
    assert!(gauge.valid());
    assert!(!gauge.invalid());
}

#[test]
fn gauges_invalidate_impossible_pressure_changes() {
    let mut gauge = EvidenceGauge::new(0);
    gauge.decrease(1);

    assert_eq!(gauge.current(), 0);
    assert!(gauge.invalid());
    assert!(!gauge.valid());
}

#[test]
fn gauges_retain_overflow_evidence_after_pressure_falls() {
    let mut gauge = EvidenceGauge::new(u64::MAX.saturating_sub(2));
    gauge.increase(2);
    assert_eq!(gauge.current(), u64::MAX);
    assert!(gauge.valid());
    gauge.increase(1);
    assert_eq!(gauge.current(), u64::MAX);
    assert_eq!(gauge.high_water().maximum(), u64::MAX);
    assert!(gauge.invalid());
    assert!(!gauge.valid());
    gauge.decrease(7);
    assert_eq!(gauge.current(), u64::MAX.saturating_sub(7));
    assert_eq!(gauge.high_water().maximum(), u64::MAX);
    assert!(gauge.invalid());
    assert!(!gauge.valid());
}

#[test]
fn histograms_group_zero_and_successive_powers_of_two() {
    let mut histogram = EvidencePowerOfTwoHistogram::<4>::default();
    assert_eq!(histogram, EvidencePowerOfTwoHistogram::new());
    for value in [0, 1, 2, 3, 4, 7] {
        histogram.record(value);
    }

    assert_eq!(
        histogram.buckets().map(EvidenceCounter::total),
        [1, 1, 2, 2]
    );
    assert!(histogram.valid());
    assert!(!histogram.out_of_range());
}

#[test]
fn histogram_range_exhaustion_invalidates_the_evidence() {
    let mut histogram = EvidencePowerOfTwoHistogram::<2>::new();
    histogram.record(2);

    assert!(histogram.out_of_range());
    assert!(!histogram.valid());

    histogram.reset();

    assert_eq!(histogram, EvidencePowerOfTwoHistogram::new());
}