ps-uuid 0.1.0-4

An opinionated UUID implementation.
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

use crate::{Variant, UUID};

impl UUID {
    #[must_use]
    pub const fn with_variant(self, variant: Variant) -> Self {
        let mut uuid = self;

        uuid.bytes[8] &= variant.bitmask();
        uuid.bytes[8] |= variant.prefix();

        uuid
    }
}

#[cfg(test)]
mod tests {
    use super::{Variant, UUID};

    const fn make_uuid_with_byte_8(byte: u8) -> UUID {
        let mut bytes = [0u8; 16];
        bytes[8] = byte;
        UUID { bytes }
    }

    #[test]
    fn with_variant_ncs() {
        let uuid = make_uuid_with_byte_8(0xFF);
        let result = uuid.with_variant(Variant::NCS);
        assert_eq!(result.get_variant(), Variant::NCS);
        assert_eq!(result.bytes[8] & 0x80, 0x00);
    }

    #[test]
    fn with_variant_osf() {
        let uuid = make_uuid_with_byte_8(0x00);
        let result = uuid.with_variant(Variant::OSF);
        assert_eq!(result.get_variant(), Variant::OSF);
        assert_eq!(result.bytes[8] & 0xC0, 0x80);
    }

    #[test]
    fn with_variant_dcom() {
        let uuid = make_uuid_with_byte_8(0x3F);
        let result = uuid.with_variant(Variant::DCOM);
        assert_eq!(result.get_variant(), Variant::DCOM);
        assert_eq!(result.bytes[8] & 0xE0, 0xC0);
    }

    #[test]
    fn with_variant_reserved() {
        let uuid = make_uuid_with_byte_8(0x00);
        let result = uuid.with_variant(Variant::Reserved);
        assert_eq!(result.get_variant(), Variant::Reserved);
        assert_eq!(result.bytes[8] & 0xE0, 0xE0);
    }

    #[test]
    fn with_variant_preserves_other_bytes() {
        let original_bytes = [1, 2, 3, 4, 5, 6, 7, 8, 0xFF, 10, 11, 12, 13, 14, 15, 16];
        let uuid = UUID {
            bytes: original_bytes,
        };

        let result = uuid.with_variant(Variant::OSF);

        for (i, &byte) in result.bytes.iter().enumerate() {
            if i != 8 {
                assert_eq!(byte, original_bytes[i]);
            }
        }
    }

    #[test]
    fn with_variant_leaves_original_unchanged() {
        let original_bytes = [1, 2, 3, 4, 5, 6, 7, 8, 0xFF, 10, 11, 12, 13, 14, 15, 16];
        let uuid = UUID {
            bytes: original_bytes,
        };

        let _result = uuid.with_variant(Variant::OSF);

        assert_eq!(uuid.bytes, original_bytes);
    }

    #[test]
    fn with_variant_can_chain_variants() {
        let uuid = make_uuid_with_byte_8(0x00);

        let result = uuid
            .with_variant(Variant::NCS)
            .with_variant(Variant::OSF)
            .with_variant(Variant::DCOM)
            .with_variant(Variant::Reserved);

        assert_eq!(result.get_variant(), Variant::Reserved);
    }

    #[test]
    fn with_variant_idempotent() {
        let uuid = make_uuid_with_byte_8(0xA5);

        let first_result = uuid.with_variant(Variant::OSF);
        let second_result = first_result.with_variant(Variant::OSF);

        assert_eq!(first_result.bytes[8], second_result.bytes[8]);
    }
}