ps-hash-core 0.1.0-25

Core hashing primitives for ps-hash.
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

use super::super::Hash;

impl PartialEq for Hash {
    fn eq(&self, other: &Self) -> bool {
        self.inner == other.inner
    }
}

impl Eq for Hash {}

#[cfg(test)]
#[allow(clippy::expect_used)]
mod tests {
    use crate::Hash;

    #[test]
    fn eq_same_data() {
        let h1 = Hash::hash(b"same").expect("hashing should succeed");
        let h2 = Hash::hash(b"same").expect("hashing should succeed");
        assert_eq!(h1, h2);
    }

    #[test]
    fn eq_different_data() {
        let h1 = Hash::hash(b"data1").expect("hashing should succeed");
        let h2 = Hash::hash(b"data2").expect("hashing should succeed");
        assert_ne!(h1, h2);
    }

    #[test]
    fn eq_reflexive() {
        let h = Hash::hash(b"reflexive").expect("hashing should succeed");
        assert_eq!(h, h);
    }

    #[test]
    fn eq_symmetric() {
        let h1 = Hash::hash(b"symmetric").expect("hashing should succeed");
        let h2 = Hash::hash(b"symmetric").expect("hashing should succeed");
        assert_eq!(h1, h2);
        assert_eq!(h2, h1);
    }

    #[test]
    fn eq_transitive() {
        let h1 = Hash::hash(b"transitive").expect("hashing should succeed");
        let h2 = Hash::hash(b"transitive").expect("hashing should succeed");
        let h3 = Hash::hash(b"transitive").expect("hashing should succeed");
        assert_eq!(h1, h2);
        assert_eq!(h2, h3);
        assert_eq!(h1, h3);
    }

    #[test]
    fn eq_after_validation() {
        let original = Hash::hash(b"validation").expect("hashing should succeed");
        let validated = Hash::validate(original.to_string())
            .expect("validation of an uncorrupted hash should succeed");
        assert_eq!(original, validated);
    }

    #[test]
    fn eq_after_corruption_recovery() {
        let original = Hash::hash(b"recovery").expect("hashing should succeed");
        let mut corrupted = original.to_string().into_bytes();
        // Replace with a character that is valid in both alphabets, so that
        // the corruption stays inside the encoded character set.
        corrupted[5] = if corrupted[5] == b'A' { b'B' } else { b'A' };
        let recovered = Hash::validate(
            String::from_utf8(corrupted).expect("corrupted bytes should be valid UTF-8"),
        )
        .expect("single-character corruption should be recovered");
        assert_eq!(original, recovered);
    }

    #[test]
    fn ne_single_bit_difference_unrecovered() {
        let h1 = Hash::hash(b"bit1").expect("hashing should succeed");
        let h2 = Hash::hash(b"bit2").expect("hashing should succeed");
        assert_ne!(h1, h2);
    }

    #[test]
    fn eq_copy_semantics() {
        let h1 = Hash::hash(b"copy").expect("hashing should succeed");
        let h2 = h1;
        assert_eq!(h1, h2);
    }

    #[test]
    #[allow(clippy::clone_on_copy)]
    fn eq_clone_semantics() {
        let h1 = Hash::hash(b"clone").expect("hashing should succeed");
        let h2 = Clone::clone(&h1);
        assert_eq!(h1, h2);
    }

    #[test]
    fn eq_trait_bound() {
        fn assert_eq<T: Eq>() {}
        assert_eq::<Hash>();
    }

    #[test]
    fn partial_eq_trait_bound() {
        fn assert_partial_eq<T: PartialEq>() {}
        assert_partial_eq::<Hash>();
    }

    #[test]
    fn eq_after_corruption_recovery_multiple_positions() {
        let original = Hash::hash(b"multi-position recovery").expect("hashing should succeed");

        for pos in [0, 10, 20, 30, 40, 50, 60, 70, 76] {
            let mut corrupted = original.to_string().into_bytes();

            // Flip between '0' and '1' to stay within the Crockford alphabet.
            corrupted[pos] = if corrupted[pos] == b'0' { b'1' } else { b'0' };
            let recovered = Hash::validate(
                String::from_utf8(corrupted).expect("corrupted bytes should be valid UTF-8"),
            )
            .expect("single-character corruption should be recovered");

            assert_eq!(original, recovered, "recovery failed at position {pos}");
        }
    }
}