mithril-common 0.7.14

Common types, interfaces, and utilities for Mithril nodes.
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

/// Compare two iterators ignoring the order
pub fn equivalent_to<T, I1, I2>(a: I1, b: I2) -> bool
where
    T: PartialEq + Ord,
    I1: IntoIterator<Item = T> + Clone,
    I2: IntoIterator<Item = T> + Clone,
{
    let a = as_sorted_vec(a);
    let b = as_sorted_vec(b);
    a == b
}

/// Assert that two iterators are equivalent
#[macro_export]
macro_rules! assert_equivalent {
    ($expected:expr, $actual:expr $(,)?) => {{
        let expected = $expected;
        let actual = $actual;
        assert_eq!(
            $crate::test::as_sorted_vec(expected),
            $crate::test::as_sorted_vec(actual)
        );
    }};
}
pub use assert_equivalent;

/// Create a sorted clone of an iterable.
pub fn as_sorted_vec<T: Ord, I: IntoIterator<Item = T> + Clone>(iter: I) -> Vec<T> {
    let mut list: Vec<T> = iter.clone().into_iter().collect();
    list.sort();
    list
}

#[cfg(test)]
mod tests {
    use std::collections::HashSet;

    use super::*;

    #[test]
    fn test_equivalent_to() {
        assert!(equivalent_to(vec![1, 2, 3], vec![3, 2, 1]));
        assert!(equivalent_to(vec![1, 2, 3], vec![2, 1, 3]));
        assert!(!equivalent_to(vec![1, 2, 3], vec![3, 2, 1, 4]));
        assert!(!equivalent_to(vec![1, 2, 3], vec![3, 2]));

        assert!(equivalent_to([1, 2, 3], vec![3, 2, 1]));
        assert!(equivalent_to(&[1, 2, 3], &vec![3, 2, 1]));
        assert!(equivalent_to([1, 2, 3], HashSet::from([3, 2, 1])));
        assert!(equivalent_to(vec![1, 2, 3], HashSet::from([3, 2, 1])));
        assert!(equivalent_to(&vec![1, 2, 3], &HashSet::from([3, 2, 1])));

        assert_equivalent!(vec![1, 2, 3], vec![3, 2, 1]);
        assert_equivalent!(vec![1, 2, 3], vec![2, 1, 3]);

        assert_equivalent!([1, 2, 3], vec![3, 2, 1]);
        assert_equivalent!(&[1, 2, 3], &vec![3, 2, 1]);
        assert_equivalent!([1, 2, 3], HashSet::from([3, 2, 1]));
        assert_equivalent!(vec![1, 2, 3], HashSet::from([3, 2, 1]));
        assert_equivalent!(&vec![1, 2, 3], &HashSet::from([3, 2, 1]));
    }
}