Skip to main content

ps_uuid/methods/
get_version.rs

1use crate::{Variant, UUID};
2
3impl UUID {
4    #[must_use]
5    pub const fn get_version(&self) -> Option<u8> {
6        match self.get_variant() {
7            Variant::OSF => Some(self.bytes[6] >> 4),
8            _ => None,
9        }
10    }
11}
12
13#[cfg(test)]
14mod tests {
15    use super::UUID;
16
17    #[test]
18    fn test_version_osf() {
19        // Test for Version 0 (OSF variant)
20        let uuid_v0 = UUID {
21            bytes: [
22                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x00, 0x80, 0x86, 0x07, 0x08, 0x09, 0x0A, 0x0B,
23                0x0C, 0x0D,
24            ],
25        };
26        assert_eq!(uuid_v0.get_version(), Some(0));
27
28        // Test for Version 1 (OSF variant)
29        let uuid_v1 = UUID {
30            bytes: [
31                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x10, 0x80, 0x86, 0x07, 0x08, 0x09, 0x0A, 0x0B,
32                0x0C, 0x0D,
33            ],
34        };
35        assert_eq!(uuid_v1.get_version(), Some(1));
36
37        // Test for Version 2 (OSF variant)
38        let uuid_v2 = UUID {
39            bytes: [
40                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x20, 0x80, 0x86, 0x07, 0x08, 0x09, 0x0A, 0x0B,
41                0x0C, 0x0D,
42            ],
43        };
44        assert_eq!(uuid_v2.get_version(), Some(2));
45
46        // Test for Version 3 (OSF variant)
47        let uuid_v3 = UUID {
48            bytes: [
49                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x30, 0x80, 0x86, 0x07, 0x08, 0x09, 0x0A, 0x0B,
50                0x0C, 0x0D,
51            ],
52        };
53        assert_eq!(uuid_v3.get_version(), Some(3));
54
55        // Test for Version 4 (OSF variant)
56        let uuid_v4 = UUID {
57            bytes: [
58                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x40, 0x80, 0x86, 0x07, 0x08, 0x09, 0x0A, 0x0B,
59                0x0C, 0x0D,
60            ],
61        };
62        assert_eq!(uuid_v4.get_version(), Some(4));
63
64        // Test for Version 5 (OSF variant)
65        let uuid_v5 = UUID {
66            bytes: [
67                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x50, 0x80, 0x86, 0x07, 0x08, 0x09, 0x0A, 0x0B,
68                0x0C, 0x0D,
69            ],
70        };
71        assert_eq!(uuid_v5.get_version(), Some(5));
72
73        // Test for Version 6 (OSF variant)
74        let uuid_v6 = UUID {
75            bytes: [
76                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x60, 0x80, 0x86, 0x07, 0x08, 0x09, 0x0A, 0x0B,
77                0x0C, 0x0D,
78            ],
79        };
80        assert_eq!(uuid_v6.get_version(), Some(6));
81
82        // Test for Version 7 (OSF variant)
83        let uuid_v7 = UUID {
84            bytes: [
85                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x70, 0x80, 0x86, 0x07, 0x08, 0x09, 0x0A, 0x0B,
86                0x0C, 0x0D,
87            ],
88        };
89        assert_eq!(uuid_v7.get_version(), Some(7));
90
91        // Test for Version 8 (OSF variant)
92        let uuid_v8 = UUID {
93            bytes: [
94                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x80, 0x80, 0x86, 0x07, 0x08, 0x09, 0x0A, 0x0B,
95                0x0C, 0x0D,
96            ],
97        };
98        assert_eq!(uuid_v8.get_version(), Some(8));
99    }
100
101    #[test]
102    fn test_version_non_osf() {
103        // Test for non-OSF variant (e.g., NCS variant, byte 8 set to 0x00)
104        let uuid_non_osf = UUID {
105            bytes: [
106                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x40, 0x06, 0x00, 0x07, 0x08, 0x09, 0x0A, 0x0B,
107                0x0C, 0x0D,
108            ],
109        };
110        assert_eq!(uuid_non_osf.get_version(), None);
111
112        // Additional test for another non-OSF variant (e.g., Microsoft variant)
113        let uuid_non_osf_ms = UUID {
114            bytes: [
115                0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x40, 0x06, 0x60, 0x07, 0x08, 0x09, 0x0A, 0x0B,
116                0x0C, 0x0D,
117            ],
118        };
119        assert_eq!(uuid_non_osf_ms.get_version(), None);
120    }
121}