fluent-comparisons 1.0.4

Boost readability by writing multicomparison expressions like `if any_of!({a,b,c}>=5) {...}` while keeping the benefits of hand-written code.
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
129
130
131
132
133

#![allow(clippy::int_plus_one)]
#![allow(clippy::many_single_char_names)]
#![allow(clippy::assertions_on_constants)]

use crate::all_of;
use std::cell::Cell;

use rand::prelude::*;

// helper function to double a value
fn twice(val: usize) -> usize {
    2 * val
}

#[test]
// handcraft test cases to thest the logic of all_of for the case of operator ==
fn all_of_comparisons_give_correct_result_for_operator_equal() {
    // simple expressions of one or two literals
    assert!(all_of!({ 4 } == 4));
    assert_eq!(all_of!({ 2 } == 4), false);
    assert_eq!(all_of!( {4,2} == 4), false);
    assert_eq!(all_of!( {2,4} == 4), false);
    assert!(all_of!( {2,2} == 2));
    assert!(all_of!( {4,4} == 4));

    // expressions involving function calls and variable
    // make sure the non-matching expression changes position
    let v = [1, 2, 3];
    let two = 2;
    assert!(all_of!( {6,2*v.len(),twice(3)} == twice(2)+two));
    assert_eq!(all_of!( {6+2,2*v.len(),twice(3)} == 3+3), false);
    assert_eq!(all_of!( {6,200*v.len(),twice(3)} == 4+2), false);
    assert_eq!(all_of!( {6,2*v.len(),twice(3)/2} == 5+1), false);

    // some other expressions for good measure
    assert_eq!(all_of!( {4,4,4,1,-1,2,4} == 4), false);
    assert!(all_of!( {2_i32.pow(2)+2,2*v.len(),4+2,666-660} == 6));
    assert_eq!(
        all_of!( {6,6,6,6,6,2_i32.pow(2)+2,2*v.len(),1234} == 6),
        false
    );
}

#[test]
// due to the implementation of the macro it should not matter which comparison operator
// we actually put in there, but we'll test it anyway just to be sure
fn all_of_comparisons_give_correct_result_for_other_operators() {
    let v = ["hello", "there", "this", "is", "a", "test"];
    // !=
    assert!(all_of!( {1,2+v.len(),twice(3)-2} != 6));
    assert_eq!(all_of!( {2*2+1,v.len(),twice(3)} != 6), false);

    // <=
    assert!(all_of!( {1,v.len(),twice(2)} <= 6));
    assert_eq!(all_of!( {2*2+1,v.len(),twice(2),-10,7} <= 6), false);
    // >=
    assert!(all_of!({4,9,5,3,-1,2}>=-2));
    assert_eq!(all_of!({4,2*2*2,5,3,-1,2} >= 4), false);
    // <
    assert!(all_of!( {1,v.len()-1,twice(2)} < 6));
    assert_eq!(all_of!( {2*2+1,v.len(),twice(2),-10,7} < 6), false);
    // >
    assert!(all_of!({104,99,15,13,11,twice(4)} > v.len()));
    assert_eq!(all_of!({104,99,15,13,11,twice(4)} > v.len()*6), false);
}

#[test]
// use some randomness for asserting theories that should always be true. So I just calculate
// the expected result of the all of expression and then compare it to a known result that I
// calculate using standard library iterators.
// Inspired by the "Beautiful Testing" chapter in the book "Beautiful Code", O'Reilly
// https://www.oreilly.com/library/view/beautiful-code/9780596510046/
fn test_random_collection_of_values_behave_correctly() {
    let mut rng = thread_rng();

    for _ in 1..1000000 {
        let a = rng.gen_range(-5..5);
        let b = rng.gen_range(-5..5);
        let c = rng.gen_range(-5..5);
        let d = rng.gen_range(-5..5);
        let rhs = rng.gen_range(-5..5);

        assert_eq!(
            all_of!({a,b,c,d}==rhs),
            [a, b, c, d].iter().all(|v| v == &rhs)
        );
        assert_eq!(
            all_of!({a,b,c,d}<=rhs),
            [a, b, c, d].iter().all(|v| v <= &rhs)
        );
        assert_eq!(
            all_of!({a,b,c,d}>=rhs),
            [a, b, c, d].iter().all(|v| v >= &rhs)
        );
        assert_eq!(
            all_of!({a,b,c,d}>rhs),
            [a, b, c, d].iter().all(|v| v > &rhs)
        );
        assert_eq!(
            all_of!({a,b,c,d}<rhs),
            [a, b, c, d].iter().all(|v| v < &rhs)
        );
        assert_eq!(
            all_of!({a,b,c,d}!=rhs),
            [a, b, c, d].iter().all(|v| v != &rhs)
        );
    }
}

#[test]
fn expressions_are_short_circuited_and_evaluated_left_to_right() {
    // use this as a variable that indicates mutable state
    // and helps me count how often the twice function was invoked
    let counter: Cell<i32> = Cell::new(0);
    let twice = |i: i32| {
        counter.set(counter.get() + 1);
        2 * i
    };

    let eval = all_of!({1,2,3,4,5,twice(3)}==1);
    assert!(!eval);
    assert_eq!(counter.get(), 0);

    let eval = all_of!({1,twice(3),twice(3),3}==1);
    assert!(!eval);
    assert_eq!(counter.get(), 1);
    counter.set(0);

    // this proves that the array way of doing things requires an eager evaluation
    let eval = [1, twice(3), twice(3), 3].iter().all(|val| val == &1);
    assert!(!eval);
    assert_eq!(counter.get(), 2);
}