header-slice 0.1.3

Definitions for slices with headers, and a vec-like type with a header allocated inline.
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

use crate::{header_vec, HeaderVec};
use core::ops::Deref;

#[test]
fn eq() {
    let foo_empty: HeaderVec<_, i32> = header_vec!["foo";];
    assert_eq!(header_vec!["foo"; 1, 2, 3], header_vec!["foo"; 1, 2, 3]);
    assert_eq!(foo_empty, foo_empty);
    assert_eq!(header_vec!["foo"; 1, 2], *header_vec!["foo"; 1, 2].deref());
    assert_eq!(*header_vec!["foo"; 1, 2].deref(), header_vec!["foo"; 1, 2]);
    assert_eq!(
        header_vec!["foo"; 1, 2].deref(),
        header_vec!["foo"; 1, 2].deref()
    );
}

#[test]
fn ne() {
    let foo_empty: HeaderVec<_, i32> = header_vec!["foo";];
    let bar_empty: HeaderVec<_, i32> = header_vec!["bar";];
    assert_ne!(header_vec!["foo"; 1, 2, 3], header_vec!["foo"; 2, 2, 3]);
    assert_ne!(header_vec!["foo"; 1, 2], header_vec!["foo"; 1, 2, 3]);
    assert_ne!(foo_empty, header_vec!["foo"; 1]);
    assert_ne!(header_vec!["foo"; 1, 2], header_vec!["foo";]);
    assert_ne!(
        header_vec!["foo"; 1, 2, 3],
        *header_vec!["foo"; 2, 3].deref()
    );
    assert_ne!(
        *header_vec!["foo"; 1, 2, 3].deref(),
        header_vec!["foo"; 2, 3]
    );
    assert_ne!(
        header_vec!["foo"; 1, 2, 3].deref(),
        header_vec!["foo"; 2, 3].deref()
    );

    assert_ne!(header_vec!["foo"; 1, 2, 3], header_vec!["bar"; 1, 2, 3]);
    assert_ne!(foo_empty, bar_empty);
}

macro_rules! assert_ord {
    ($a:expr, $b:expr, $cmp:ident) => {
        assert_eq!($a.cmp(&$b), core::cmp::Ordering::$cmp);
        assert_ord!(?$a, $b, $cmp);
    };
    (? $a:expr, $b:expr, $cmp:ident) => {
        assert_eq!($a.partial_cmp(&$b), Some(core::cmp::Ordering::$cmp));
    };
    ({ $a:expr } ?< { $b:expr }) => {
        assert_ord!(?$a, $b, Less);
        assert_ord!(?$b, $a, Greater);
    };
    ({ $a:expr } < { $b:expr }) => {
        assert_ord!($a, $b, Less);
        assert_ord!($b, $a, Greater);
    };
    ({ $a:expr } ?== { $b:expr }) => {
        assert_ord!(?$a, $b, Equal);
        assert_ord!(?$b, $a, Equal);
    };
    ({ $a:expr } == { $b:expr }) => {
        assert_ord!($a, $b, Equal);
        assert_ord!($b, $a, Equal);
    };
    ({ $a:expr } ?> { $b:expr }) => {
        assert_ord!(?$a, $b, Greater);
        assert_ord!(?$b, $a, Less);
    };
    ({ $a:expr } > { $b:expr }) => {
        assert_ord!($a, $b, Greater);
        assert_ord!($b, $a, Less);
    };
    ({ $a:expr } ? { $b:expr }) => {
        assert_eq!($a.partial_cmp(&$b), None);
        assert_eq!($b.partial_cmp(&$a), None);
    };
}

#[test]
fn ord() {
    let a_empty: HeaderVec<_, i32> = header_vec!["a";];
    let b_empty: HeaderVec<_, i32> = header_vec!["b";];
    assert_ord!({ a_empty } == { a_empty });
    assert_ord!({ a_empty } < { b_empty });

    assert_ord!({ header_vec!["a"; 1, 2] } == { header_vec!["a"; 1, 2] });
    assert_ord!({ header_vec!["a"; 1, 2] } < { header_vec!["b"; 1, 2] });
    assert_ord!({ header_vec!["a"; 1, 2] } < { header_vec!["b"; 1, 2, 3] });
    assert_ord!({ header_vec!["a"; 1, 2] } < { header_vec!["a"; 1, 3] });
    assert_ord!({ header_vec!["a"; 1, 2] } < { header_vec!["a"; 1, 2, 3] });

    assert_ord!({ header_vec![1.0; 1, 2] }? == { header_vec![1.0; 1, 2] });
    assert_ord!({ header_vec![1.0; 1, 2] }? < { header_vec![1.0; 1, 3] });
    assert_ord!({ header_vec![1.0; 1, 2] }? < { header_vec![2.0; 1, 2] });

    assert_ord!({ header_vec![f32::NAN; 1, 2] } ? { header_vec![f32::NAN; 1, 2] });
    assert_ord!({ header_vec![1.0; 1, 2] } ? { header_vec![f32::NAN; 1, 2] });
    assert_ord!({ header_vec!["foo"; 1.0, 2.0] }? == { header_vec!["foo"; 1.0, 2.0] });
    assert_ord!({ header_vec!["foo"; 1.0, 2.0] }? < { header_vec!["foo"; 1.0, 3.0] });
    assert_ord!({ header_vec!["foo"; 1.0, 2.0] }? < { header_vec!["foo"; 1.0, 2.0, 3.0] });
}