bit_int/bit_uint/
consts.rs

1// SPDX-FileCopyrightText: 2024 Shun Sakai
2//
3// SPDX-License-Identifier: Apache-2.0 OR MIT
4
5//! Constants for [`BitUint`].
6
7use super::BitUint;
8
9macro_rules! impl_consts {
10    ($T:ty) => {
11        impl<const N: u32> BitUint<$T, N> {
12            /// The smallest value that can be represented by this `BitUint`.
13            ///
14            /// The value is always `0`.
15            ///
16            /// # Examples
17            ///
18            /// ```
19            /// # use bit_int::BitUint;
20            /// #
21            #[doc = concat!("assert_eq!(BitUint::<", stringify!($T), ", 7>::MIN.get(), 0);")]
22            /// ```
23            // SAFETY: because `MIN` must be the smallest value of a `N`-bit unsigned
24            // integer.
25            pub const MIN: Self = unsafe { Self::new_unchecked(<$T>::MIN) };
26
27            /// The largest value that can be represented by this `BitUint`.
28            ///
29            /// # Examples
30            ///
31            /// ```
32            /// # use bit_int::BitUint;
33            /// #
34            #[doc = concat!("assert_eq!(BitUint::<", stringify!($T), ", 7>::MAX.get(), 127);")]
35            /// ```
36            // SAFETY: because `MAX` must be the largest value of a `N`-bit unsigned
37            // integer.
38            pub const MAX: Self =
39                unsafe { Self::new_unchecked(<$T>::MAX >> (<$T>::BITS - Self::BITS)) };
40
41            /// The size of this `BitUint` in bits.
42            ///
43            /// # Examples
44            ///
45            /// ```
46            /// # use bit_int::BitUint;
47            /// #
48            #[doc = concat!("assert_eq!(BitUint::<", stringify!($T), ", 7>::BITS, 7);")]
49            /// ```
50            pub const BITS: u32 = N;
51        }
52    };
53}
54impl_consts!(u8);
55impl_consts!(u16);
56impl_consts!(u32);
57impl_consts!(u64);
58impl_consts!(u128);
59impl_consts!(usize);
60
61#[cfg(test)]
62mod tests {
63    use super::super::{BitU8, BitU16, BitU32, BitU64, BitU128, BitUsize};
64
65    #[test]
66    fn min() {
67        assert_eq!(BitU8::<7>::MIN.get(), u8::MIN);
68        assert_eq!(BitU16::<15>::MIN.get(), u16::MIN);
69        assert_eq!(BitU32::<31>::MIN.get(), u32::MIN);
70        assert_eq!(BitU64::<63>::MIN.get(), u64::MIN);
71        assert_eq!(BitU128::<127>::MIN.get(), u128::MIN);
72        assert_eq!(BitUsize::<{ usize::BITS - 1 }>::MIN.get(), usize::MIN);
73    }
74
75    #[test]
76    fn min_when_one_bit() {
77        assert_eq!(BitU8::<1>::MIN.get(), u8::MIN);
78        assert_eq!(BitU16::<1>::MIN.get(), u16::MIN);
79        assert_eq!(BitU32::<1>::MIN.get(), u32::MIN);
80        assert_eq!(BitU64::<1>::MIN.get(), u64::MIN);
81        assert_eq!(BitU128::<1>::MIN.get(), u128::MIN);
82        assert_eq!(BitUsize::<1>::MIN.get(), usize::MIN);
83    }
84
85    #[test]
86    fn min_when_max_bits() {
87        assert_eq!(BitU8::<{ u8::BITS }>::MIN.get(), u8::MIN);
88        assert_eq!(BitU16::<{ u16::BITS }>::MIN.get(), u16::MIN);
89        assert_eq!(BitU32::<{ u32::BITS }>::MIN.get(), u32::MIN);
90        assert_eq!(BitU64::<{ u64::BITS }>::MIN.get(), u64::MIN);
91        assert_eq!(BitU128::<{ u128::BITS }>::MIN.get(), u128::MIN);
92        assert_eq!(BitUsize::<{ usize::BITS }>::MIN.get(), usize::MIN);
93    }
94
95    #[test]
96    fn max() {
97        assert_eq!(BitU8::<7>::MAX.get(), u8::MAX >> 1);
98        assert_eq!(BitU16::<15>::MAX.get(), u16::MAX >> 1);
99        assert_eq!(BitU32::<31>::MAX.get(), u32::MAX >> 1);
100        assert_eq!(BitU64::<63>::MAX.get(), u64::MAX >> 1);
101        assert_eq!(BitU128::<127>::MAX.get(), u128::MAX >> 1);
102        assert_eq!(BitUsize::<{ usize::BITS - 1 }>::MAX.get(), usize::MAX >> 1);
103    }
104
105    #[test]
106    fn max_when_one_bit() {
107        assert_eq!(BitU8::<1>::MAX.get(), 1);
108        assert_eq!(BitU16::<1>::MAX.get(), 1);
109        assert_eq!(BitU32::<1>::MAX.get(), 1);
110        assert_eq!(BitU64::<1>::MAX.get(), 1);
111        assert_eq!(BitU128::<1>::MAX.get(), 1);
112        assert_eq!(BitUsize::<1>::MAX.get(), 1);
113    }
114
115    #[test]
116    fn max_when_max_bits() {
117        assert_eq!(BitU8::<{ u8::BITS }>::MAX.get(), u8::MAX);
118        assert_eq!(BitU16::<{ u16::BITS }>::MAX.get(), u16::MAX);
119        assert_eq!(BitU32::<{ u32::BITS }>::MAX.get(), u32::MAX);
120        assert_eq!(BitU64::<{ u64::BITS }>::MAX.get(), u64::MAX);
121        assert_eq!(BitU128::<{ u128::BITS }>::MAX.get(), u128::MAX);
122        assert_eq!(BitUsize::<{ usize::BITS }>::MAX.get(), usize::MAX);
123    }
124
125    #[test]
126    fn bits() {
127        assert_eq!(BitU8::<7>::BITS, 7);
128        assert_eq!(BitU16::<15>::BITS, 15);
129        assert_eq!(BitU32::<31>::BITS, 31);
130        assert_eq!(BitU64::<63>::BITS, 63);
131        assert_eq!(BitU128::<127>::BITS, 127);
132        assert_eq!(BitUsize::<{ usize::BITS - 1 }>::BITS, usize::BITS - 1);
133    }
134
135    #[test]
136    fn bits_when_one_bit() {
137        assert_eq!(BitU8::<1>::BITS, 1);
138        assert_eq!(BitU16::<1>::BITS, 1);
139        assert_eq!(BitU32::<1>::BITS, 1);
140        assert_eq!(BitU64::<1>::BITS, 1);
141        assert_eq!(BitU128::<1>::BITS, 1);
142        assert_eq!(BitUsize::<1>::BITS, 1);
143    }
144
145    #[test]
146    fn bits_when_max_bits() {
147        assert_eq!(BitU8::<{ u8::BITS }>::BITS, u8::BITS);
148        assert_eq!(BitU16::<{ u16::BITS }>::BITS, u16::BITS);
149        assert_eq!(BitU32::<{ u32::BITS }>::BITS, u32::BITS);
150        assert_eq!(BitU64::<{ u64::BITS }>::BITS, u64::BITS);
151        assert_eq!(BitU128::<{ u128::BITS }>::BITS, u128::BITS);
152        assert_eq!(BitUsize::<{ usize::BITS }>::BITS, usize::BITS);
153    }
154}
bit_int/bit_uint/consts.rs

bit_int/bit_uint/
consts.rs
