scolapasta_fixable/
lib.rs

1#![warn(clippy::all, clippy::pedantic, clippy::undocumented_unsafe_blocks)]
2#![allow(
3    clippy::let_underscore_untyped,
4    reason = "https://github.com/rust-lang/rust-clippy/pull/10442#issuecomment-1516570154"
5)]
6#![allow(
7    clippy::question_mark,
8    reason = "https://github.com/rust-lang/rust-clippy/issues/8281"
9)]
10#![allow(clippy::manual_let_else, reason = "manual_let_else was very buggy on release")]
11#![allow(clippy::missing_errors_doc, reason = "A lot of existing code fails this lint")]
12#![allow(
13    clippy::unnecessary_lazy_evaluations,
14    reason = "https://github.com/rust-lang/rust-clippy/issues/8109"
15)]
16#![cfg_attr(
17    test,
18    allow(clippy::non_ascii_literal, reason = "tests sometimes require UTF-8 string content")
19)]
20#![allow(unknown_lints)]
21#![warn(
22    missing_copy_implementations,
23    missing_debug_implementations,
24    missing_docs,
25    rust_2024_compatibility,
26    trivial_casts,
27    trivial_numeric_casts,
28    unused_qualifications,
29    variant_size_differences
30)]
31#![forbid(unsafe_code)]
32// Enable feature callouts in generated documentation:
33// https://doc.rust-lang.org/beta/unstable-book/language-features/doc-cfg.html
34//
35// This approach is borrowed from tokio.
36#![cfg_attr(docsrs, feature(doc_cfg))]
37#![cfg_attr(docsrs, feature(doc_alias))]
38
39//! Functions for converting numeric immediates to integer or "fixnum"
40//! immediates.
41//!
42//! Fixnums have range of a 63-bit signed int and are returned as a native
43//! representation [`i64`].
44//!
45//! # Usage
46//!
47//! Check whether a numeric value is able to be converted to an in-range
48//! "fixnum":
49//!
50//! ```
51//! use scolapasta_fixable::RB_FIXABLE;
52//!
53//! assert!(RB_FIXABLE(23_u8));
54//! assert!(RB_FIXABLE(u16::MIN));
55//! assert!(RB_FIXABLE(i32::MAX));
56//! assert!(RB_FIXABLE(1024_u64));
57//! assert!(RB_FIXABLE(1024_i64));
58//! assert!(RB_FIXABLE(1.0_f32));
59//! assert!(RB_FIXABLE(-9000.27_f64));
60//! ```
61//!
62//! This crate also exports a [`Fixable`] trait which provides methods on
63//! numeric types to check if they are fixable and to do a fallible conversion
64//! to an [`i64`] fixnum.
65//!
66//! ```
67//! use scolapasta_fixable::Fixable;
68//!
69//! assert!(23_u8.is_fixable());
70//! assert_eq!(23_u8.to_fix(), Some(23_i64));
71//! assert!((-9000.27_f64).is_fixable());
72//! assert_eq!((-9000.27_f64).to_fix(), Some(-9000_i64));
73//! ```
74//!
75//! Some numeric types, such as [`u64`], [`i128`], and [`f64`] have values that
76//! exceed fixnum range. Conversions on values of these types which are outside
77//! the 63-bit int range will fail:
78//!
79//! ```rust
80//! use scolapasta_fixable::Fixable;
81//!
82//! assert_eq!(u64::MAX.to_fix(), None);
83//! assert_eq!(i128::MIN.to_fix(), None);
84//! assert_eq!(4_611_686_018_427_387_904.0_f64.to_fix(), None);
85//! assert_eq!(f64::INFINITY.to_fix(), None);
86//! assert_eq!(f64::NAN.to_fix(), None);
87//! ```
88//!
89//! For non-integer fixable types, the fractional part is discarded when converting
90//! to fixnum, i.e. converting to fixnum rounds to zero.
91//!
92//! # Panics
93//!
94//! All routines in this crate are implemented with checked operations and will
95//! never panic.
96
97#![no_std]
98
99// Ensure code blocks in `README.md` compile
100#[cfg(doctest)]
101#[doc = include_str!("../README.md")]
102mod readme {}
103
104use core::time::Duration;
105
106pub use range::{RUBY_FIXNUM_MAX, RUBY_FIXNUM_MIN};
107
108mod range {
109    /// The maximum possible value that a fixnum can represent, 63 bits of an
110    /// [`i64`].
111    ///
112    /// # C Declaration
113    ///
114    /// ```c
115    /// /** Maximum possible value that a fixnum can represent. */
116    /// #define RUBY_FIXNUM_MAX  (LONG_MAX / 2)
117    /// ```
118    pub const RUBY_FIXNUM_MAX: i64 = i64::MAX / 2;
119
120    /// The minimum possible value that a fixnum can represent, 63 bits of an
121    /// [`i64`].
122    ///
123    /// # C Declaration
124    ///
125    /// ```c
126    /// /** Minimum possible value that a fixnum can represent. */
127    /// #define RUBY_FIXNUM_MIN  (LONG_MIN / 2)
128    /// ```
129    pub const RUBY_FIXNUM_MIN: i64 = i64::MIN / 2;
130
131    pub(crate) mod u64 {
132        pub(crate) const RUBY_FIXNUM_MAX: u64 = super::RUBY_FIXNUM_MAX as u64;
133    }
134
135    pub(crate) mod u128 {
136        pub(crate) const RUBY_FIXNUM_MAX: u128 = super::RUBY_FIXNUM_MAX as u128;
137    }
138
139    #[cfg(test)]
140    mod tests {
141        use super::RUBY_FIXNUM_MAX;
142
143        #[test]
144        fn casts_in_const_context_are_safe() {
145            assert_eq!(super::u64::RUBY_FIXNUM_MAX, u64::try_from(RUBY_FIXNUM_MAX).unwrap());
146            assert_eq!(super::u128::RUBY_FIXNUM_MAX, u128::try_from(RUBY_FIXNUM_MAX).unwrap());
147        }
148    }
149}
150
151mod private {
152    pub trait Sealed {}
153
154    impl Sealed for i8 {}
155    impl Sealed for i16 {}
156    impl Sealed for i32 {}
157    impl Sealed for i64 {}
158    impl Sealed for i128 {}
159
160    impl Sealed for u8 {}
161    impl Sealed for u16 {}
162    impl Sealed for u32 {}
163    impl Sealed for u64 {}
164    impl Sealed for u128 {}
165
166    impl Sealed for f32 {}
167    impl Sealed for f64 {}
168}
169
170/// Marker trait for numeric values which can be converted to a "fixnum", or
171/// Integer, representation.
172///
173/// A numeric value is fixable if its integral portion can fit within 63 bits of
174/// an [`i64`].
175///
176/// See [`RUBY_FIXNUM_MIN`] and [`RUBY_FIXNUM_MAX`] for more details on the range
177/// of values yielded by implementers of this trait.
178///
179/// This trait is sealed and cannot be implemented outside of this crate.
180pub trait Fixable: private::Sealed + Sized {
181    /// Convert a fixable numeric value to its integral part.
182    ///
183    /// This method returns [`None`] if `self` is out of range.
184    #[must_use]
185    fn to_fix(self) -> Option<i64>;
186
187    /// Test whether a fixable numeric value is in range.
188    #[must_use]
189    #[expect(
190        clippy::wrong_self_convention,
191        reason = "implemented on numeric types which are smaller than a reference, to use value receivers for primitives like `f64::is_nan`"
192    )]
193    fn is_fixable(self) -> bool {
194        self.to_fix().is_some()
195    }
196}
197
198impl Fixable for i8 {
199    /// Convert an [`i8`] to a fixnum.
200    ///
201    /// This method on [`i8`] is infallible and will always return `Some(self)`
202    /// since `i8` is always in range of fixnum.
203    fn to_fix(self) -> Option<i64> {
204        Some(self.into())
205    }
206
207    /// Test whether an [`i8`] value is in range of fixnum.
208    ///
209    /// This method on [`i8`] will always return `true` since `i8` is always in
210    /// range of fixnum.
211    fn is_fixable(self) -> bool {
212        true
213    }
214}
215
216impl Fixable for i16 {
217    /// Convert an [`i16`] to a fixnum.
218    ///
219    /// This method on [`i16`] is infallible and will always return `Some(self)`
220    /// since `i16` is always in range of fixnum.
221    fn to_fix(self) -> Option<i64> {
222        Some(self.into())
223    }
224
225    /// Test whether an [`i16`] value is in range of fixnum.
226    ///
227    /// This method on [`i16`] will always return `true` since `i16` is always in
228    /// range of fixnum.
229    fn is_fixable(self) -> bool {
230        true
231    }
232}
233
234impl Fixable for i32 {
235    /// Convert an [`i32`] to a fixnum.
236    ///
237    /// This method on [`i32`] is infallible and will always return `Some(self)`
238    /// since `i32` is always in range of fixnum.
239    fn to_fix(self) -> Option<i64> {
240        Some(self.into())
241    }
242
243    /// Test whether an [`i32`] value is in range of fixnum.
244    ///
245    /// This method on [`i32`] will always return `true` since `i32` is always in
246    /// range of fixnum.
247    fn is_fixable(self) -> bool {
248        true
249    }
250}
251
252impl Fixable for i64 {
253    /// Convert an [`i64`] to a fixnum if it is less than or equal to
254    /// [`RUBY_FIXNUM_MAX`] and greater than or equal to [`RUBY_FIXNUM_MIN`] in
255    /// magnitude.
256    ///
257    /// This method returns [`None`] if the receiver is greater than
258    /// [`RUBY_FIXNUM_MAX`] or less than [`RUBY_FIXNUM_MIN`].
259    fn to_fix(self) -> Option<i64> {
260        if self > RUBY_FIXNUM_MAX {
261            return None;
262        }
263        if self < RUBY_FIXNUM_MIN {
264            return None;
265        }
266        Some(self)
267    }
268
269    /// Test whether an [`i64`] value is in range of fixnum.
270    ///
271    /// This method returns `false` if the receiver is greater than
272    /// [`RUBY_FIXNUM_MAX`] or less than [`RUBY_FIXNUM_MAX`].
273    fn is_fixable(self) -> bool {
274        (RUBY_FIXNUM_MIN..=RUBY_FIXNUM_MAX).contains(&self)
275    }
276}
277
278impl Fixable for i128 {
279    /// Convert an [`i128`] to a fixnum if it is less than or equal to
280    /// [`RUBY_FIXNUM_MAX`] and greater than or equal to [`RUBY_FIXNUM_MIN`] in
281    /// magnitude.
282    ///
283    /// This method returns [`None`] if the receiver is greater than
284    /// [`RUBY_FIXNUM_MAX`] or less than [`RUBY_FIXNUM_MIN`].
285    fn to_fix(self) -> Option<i64> {
286        let x = i64::try_from(self).ok()?;
287        x.to_fix()
288    }
289
290    /// Test whether an [`i128`] value is in range of fixnum.
291    ///
292    /// This method returns `false` if the receiver is greater than
293    /// [`RUBY_FIXNUM_MAX`] or less than [`RUBY_FIXNUM_MAX`].
294    fn is_fixable(self) -> bool {
295        (RUBY_FIXNUM_MIN.into()..=RUBY_FIXNUM_MAX.into()).contains(&self)
296    }
297}
298
299impl Fixable for u8 {
300    /// Convert a [`u8`] to a fixnum.
301    ///
302    /// This method on [`u8`] is infallible and will always return `Some(self)`
303    /// since `u8` is always in range of fixnum.
304    fn to_fix(self) -> Option<i64> {
305        Some(self.into())
306    }
307
308    /// Test whether a [`u8`] value is in range of fixnum.
309    ///
310    /// This method on [`u8`] will always return `true` since `u8` is always in
311    /// range of fixnum.
312    fn is_fixable(self) -> bool {
313        true
314    }
315}
316
317impl Fixable for u16 {
318    /// Convert a [`u16`] to a fixnum.
319    ///
320    /// This method on [`u16`] is infallible and will always return `Some(self)`
321    /// since `u16` is always in range of fixnum.
322    fn to_fix(self) -> Option<i64> {
323        Some(self.into())
324    }
325
326    /// Test whether a [`u16`] value is in range of fixnum.
327    ///
328    /// This method on [`u16`] will always return `true` since `u16` is always in
329    /// range of fixnum.
330    fn is_fixable(self) -> bool {
331        true
332    }
333}
334
335impl Fixable for u32 {
336    /// Convert a [`u32`] to a fixnum.
337    ///
338    /// This method on [`u32`] is infallible and will always return `Some(self)`
339    /// since `u32` is always in range of fixnum.
340    fn to_fix(self) -> Option<i64> {
341        Some(self.into())
342    }
343
344    /// Test whether a [`u32`] value is in range of fixnum.
345    ///
346    /// This method on [`u32`] will always return `true` since `u32` is always in
347    /// range of fixnum.
348    fn is_fixable(self) -> bool {
349        true
350    }
351}
352
353impl Fixable for u64 {
354    /// Convert a [`u64`] to a fixnum if it is less than or equal to
355    /// [`RUBY_FIXNUM_MAX`] in magnitude.
356    ///
357    /// This method returns [`None`] if the receiver is greater than
358    /// [`RUBY_FIXNUM_MAX`].
359    fn to_fix(self) -> Option<i64> {
360        let x = i64::try_from(self).ok()?;
361        if x > RUBY_FIXNUM_MAX {
362            return None;
363        }
364        // no need to check the min bound since `u64::MIN` is zero.
365        Some(x)
366    }
367
368    /// Test whether a [`u64`] value is in range of fixnum.
369    ///
370    /// This method returns `false` if the receiver is greater than
371    /// [`RUBY_FIXNUM_MAX`].
372    fn is_fixable(self) -> bool {
373        use crate::range::u64::RUBY_FIXNUM_MAX;
374
375        (..=RUBY_FIXNUM_MAX).contains(&self)
376    }
377}
378
379impl Fixable for u128 {
380    /// Convert a [`u128`] to a fixnum if it is less than or equal to
381    /// [`RUBY_FIXNUM_MAX`] in magnitude.
382    ///
383    /// This method returns [`None`] if the receiver is greater than
384    /// [`RUBY_FIXNUM_MAX`].
385    fn to_fix(self) -> Option<i64> {
386        let x = i64::try_from(self).ok()?;
387        if x > RUBY_FIXNUM_MAX {
388            return None;
389        }
390        // no need to check the min bound since `u128::MIN` is zero.
391        Some(x)
392    }
393
394    /// Test whether a [`u128`] value is in range of fixnum.
395    ///
396    /// This method returns `false` if the receiver is greater than
397    /// [`RUBY_FIXNUM_MAX`].
398    fn is_fixable(self) -> bool {
399        use crate::range::u128::RUBY_FIXNUM_MAX;
400
401        (..=RUBY_FIXNUM_MAX).contains(&self)
402    }
403}
404
405impl Fixable for f32 {
406    /// Convert an [`f32`] to a fixnum if it is less than or equal to
407    /// [`RUBY_FIXNUM_MAX`] and greater than or equal to [`RUBY_FIXNUM_MIN`] in
408    /// magnitude.
409    ///
410    /// This method returns [`None`] if the receiver is greater than
411    /// [`RUBY_FIXNUM_MAX`] or less than [`RUBY_FIXNUM_MIN`].
412    ///
413    /// This function discards the fractional part of the float, i.e. truncates.
414    ///
415    /// [`NaN`](f32::NAN) and infinities return [`None`].
416    ///
417    /// # Implementation Notes
418    ///
419    /// Conversion is implemented using checked operations and will never panic.
420    ///
421    /// This conversion is implemented using [`Duration::try_from_secs_f32`] and
422    /// extracting the the integral portion of the float via [`Duration::as_secs`].
423    fn to_fix(self) -> Option<i64> {
424        if let Ok(d) = Duration::try_from_secs_f32(self) {
425            let x = d.as_secs();
426            return x.to_fix();
427        }
428        if let Ok(d) = Duration::try_from_secs_f32(-self) {
429            let x = d.as_secs();
430            let x = i64::try_from(x).ok()?;
431            let x = x.checked_neg()?;
432            return x.to_fix();
433        }
434        None
435    }
436}
437
438impl Fixable for f64 {
439    /// Convert an [`f64`] to a fixnum if it is less than or equal to
440    /// [`RUBY_FIXNUM_MAX`] and greater than or equal to [`RUBY_FIXNUM_MIN`] in
441    /// magnitude.
442    ///
443    /// This method returns [`None`] if the receiver is greater than
444    /// [`RUBY_FIXNUM_MAX`] or less than [`RUBY_FIXNUM_MIN`].
445    ///
446    /// This function discards the fractional part of the float, i.e. truncates.
447    ///
448    /// [`NaN`](f64::NAN) and infinities return [`None`].
449    ///
450    /// # Implementation Notes
451    ///
452    /// Conversion is implemented using checked operations and will never panic.
453    ///
454    /// This conversion is implemented using [`Duration::try_from_secs_f64`] and
455    /// extracting the the integral portion of the float via [`Duration::as_secs`].
456    fn to_fix(self) -> Option<i64> {
457        if let Ok(d) = Duration::try_from_secs_f64(self) {
458            let x = d.as_secs();
459            return x.to_fix();
460        }
461        if let Ok(d) = Duration::try_from_secs_f64(-self) {
462            let x = d.as_secs();
463            let x = i64::try_from(x).ok()?;
464            let x = x.checked_neg()?;
465            return x.to_fix();
466        }
467        None
468    }
469}
470
471/// Check whether the given numeric is in the range of fixnum.
472///
473/// `RB_FIXABLE` can be applied to any numeric type. See the implementers of the
474/// [`Fixable`] trait for more details on which numeric types are fixable.
475///
476/// To convert the given numeric value to a fixnum instead, see
477/// [`Fixable::to_fix`].
478///
479/// # Examples
480///
481/// ```
482/// use scolapasta_fixable::RB_FIXABLE;
483///
484/// assert!(RB_FIXABLE(23_u8));
485/// assert!(RB_FIXABLE(u16::MIN));
486/// assert!(RB_FIXABLE(i32::MAX));
487/// assert!(RB_FIXABLE(1024_u64));
488/// assert!(RB_FIXABLE(1024_i64));
489/// assert!(RB_FIXABLE(1.0_f32));
490/// assert!(RB_FIXABLE(-9000.27_f64));
491/// ```
492///
493/// # C Declaration
494///
495/// ```c
496/// /**
497///  * Checks if the passed value is in  range of fixnum, assuming it is a positive
498///  * number.  Can sometimes be useful for C's unsigned integer types.
499///  *
500///  * @internal
501///  *
502///  * FIXABLE can be applied to anything, from double to intmax_t.  The problem is
503///  * double.   On a  64bit system  RUBY_FIXNUM_MAX is  4,611,686,018,427,387,903,
504///  * which is not representable by a double.  The nearest value that a double can
505///  * represent  is   4,611,686,018,427,387,904,  which   is  not   fixable.   The
506///  * seemingly-strange "< FIXNUM_MAX + 1" expression below is due to this.
507///  */
508/// #define RB_POSFIXABLE(_) ((_) <  RUBY_FIXNUM_MAX + 1)
509///
510/// /**
511///  * Checks if the passed value is in  range of fixnum, assuming it is a negative
512///  * number.  This is an implementation of #RB_FIXABLE.  Rarely used stand alone.
513///  */
514/// #define RB_NEGFIXABLE(_) ((_) >= RUBY_FIXNUM_MIN)
515///
516/// /** Checks if the passed value is in  range of fixnum */
517/// #define RB_FIXABLE(_)    (RB_POSFIXABLE(_) && RB_NEGFIXABLE(_))
518/// ```
519#[must_use]
520#[allow(non_snake_case)] // match MRI macro name
521pub fn RB_FIXABLE<T: Fixable>(x: T) -> bool {
522    x.is_fixable()
523}
524
525#[cfg(test)]
526mod tests {
527    use super::*;
528
529    #[test]
530    fn test_all_i8_are_fixable() {
531        for x in i8::MIN..=i8::MAX {
532            assert_eq!(x.to_fix(), Some(x.into()), "{x} should be its own fixnum");
533            assert!(x.is_fixable(), "{x} should be fixable");
534            assert!(RB_FIXABLE(x), "{x} should be fixable");
535        }
536    }
537
538    #[test]
539    fn test_all_i16_are_fixable() {
540        for x in i16::MIN..=i16::MAX {
541            assert_eq!(x.to_fix(), Some(x.into()), "{x} should be its own fixnum");
542            assert!(x.is_fixable(), "{x} should be fixable");
543            assert!(RB_FIXABLE(x), "{x} should be fixable");
544        }
545    }
546
547    #[test]
548    fn test_i32_are_fixable() {
549        let test_cases = [i32::MIN, -1, 0, i32::MAX];
550        for x in test_cases {
551            assert_eq!(x.to_fix(), Some(x.into()), "{x} did not fix correctly");
552            assert!(x.is_fixable(), "{x} did not is_fixable correctly");
553            assert!(RB_FIXABLE(x), "{x} did not RB_FIXABLE correctly");
554        }
555    }
556
557    #[test]
558    fn test_i64_are_fixable() {
559        let test_cases = [
560            (i64::MIN, None),
561            (RUBY_FIXNUM_MIN - 1, None),
562            (RUBY_FIXNUM_MIN, Some(RUBY_FIXNUM_MIN)),
563            (RUBY_FIXNUM_MIN + 1, Some(RUBY_FIXNUM_MIN + 1)),
564            // ```
565            // >>> (-(2 ** 63 - 1)) >> 1
566            // -4611686018427387904
567            // ``
568            (-4_611_686_018_427_387_904 - 1, None),
569            (-4_611_686_018_427_387_904, Some(-4_611_686_018_427_387_904)),
570            (-4_611_686_018_427_387_904 + 1, Some(-4_611_686_018_427_387_903)),
571            (-1024, Some(-1024)),
572            (-10, Some(-10)),
573            (-1, Some(-1)),
574            (0_i64, Some(0)),
575            (1, Some(1)),
576            (10, Some(10)),
577            (1024, Some(1024)),
578            // ```
579            // >>> (2 ** 63 - 1) >> 1
580            // 4611686018427387903
581            // ```
582            (4_611_686_018_427_387_903 - 1, Some(4_611_686_018_427_387_902)),
583            (4_611_686_018_427_387_903, Some(4_611_686_018_427_387_903)),
584            (4_611_686_018_427_387_903 + 1, None),
585            (RUBY_FIXNUM_MAX - 1, Some(RUBY_FIXNUM_MAX - 1)),
586            (RUBY_FIXNUM_MAX, Some(RUBY_FIXNUM_MAX)),
587            (RUBY_FIXNUM_MAX + 1, None),
588            (i64::MAX, None),
589        ];
590        for (x, fixed) in test_cases {
591            assert_eq!(x.to_fix(), fixed, "{x} did not fix correctly");
592            assert_eq!(x.is_fixable(), fixed.is_some(), "{x} did not is_fixable correctly");
593            assert_eq!(RB_FIXABLE(x), fixed.is_some(), "{x} did not RB_FIXABLE correctly");
594        }
595    }
596
597    #[test]
598    fn test_i128_are_fixable() {
599        let test_cases = [
600            (i128::MIN, None),
601            (i64::MIN.into(), None),
602            (i128::from(RUBY_FIXNUM_MIN) - 1, None),
603            (i128::from(RUBY_FIXNUM_MIN), Some(RUBY_FIXNUM_MIN)),
604            (i128::from(RUBY_FIXNUM_MIN) + 1, Some(RUBY_FIXNUM_MIN + 1)),
605            // ```
606            // >>> (-(2 ** 63 - 1)) >> 1
607            // -4611686018427387904
608            // ``
609            (-4_611_686_018_427_387_904 - 1, None),
610            (-4_611_686_018_427_387_904, Some(-4_611_686_018_427_387_904)),
611            (-4_611_686_018_427_387_904 + 1, Some(-4_611_686_018_427_387_903)),
612            (-1024, Some(-1024)),
613            (-10, Some(-10)),
614            (-1, Some(-1)),
615            (0_i128, Some(0)),
616            (1, Some(1)),
617            (10, Some(10)),
618            (1024, Some(1024)),
619            // ```
620            // >>> (2 ** 63 - 1) >> 1
621            // 4611686018427387903
622            // ```
623            (4_611_686_018_427_387_903 - 1, Some(4_611_686_018_427_387_902)),
624            (4_611_686_018_427_387_903, Some(4_611_686_018_427_387_903)),
625            (4_611_686_018_427_387_903 + 1, None),
626            (i128::from(RUBY_FIXNUM_MAX) - 1, Some(RUBY_FIXNUM_MAX - 1)),
627            (i128::from(RUBY_FIXNUM_MAX), Some(RUBY_FIXNUM_MAX)),
628            (i128::from(RUBY_FIXNUM_MAX) + 1, None),
629            (i64::MAX.into(), None),
630            (i128::MAX, None),
631        ];
632        for (x, fixed) in test_cases {
633            assert_eq!(x.to_fix(), fixed, "{x} did not fix correctly");
634            assert_eq!(x.is_fixable(), fixed.is_some(), "{x} did not is_fixable correctly");
635            assert_eq!(RB_FIXABLE(x), fixed.is_some(), "{x} did not RB_FIXABLE correctly");
636        }
637    }
638
639    #[test]
640    fn all_u8_are_fixable() {
641        for x in u8::MIN..=u8::MAX {
642            assert_eq!(x.to_fix(), Some(x.into()), "{x} should be its own fixnum");
643            assert!(x.is_fixable(), "{x} should be fixable");
644            assert!(RB_FIXABLE(x), "{x} should be fixable");
645        }
646    }
647
648    #[test]
649    fn all_u16_are_fixable() {
650        for x in u16::MIN..=u16::MAX {
651            assert_eq!(x.to_fix(), Some(x.into()), "{x} should be its own fixnum");
652            assert!(x.is_fixable(), "{x} should be fixable");
653            assert!(RB_FIXABLE(x), "{x} should be fixable");
654        }
655    }
656
657    #[test]
658    fn test_u32_are_fixable() {
659        let test_cases = [0, u32::MAX / 2, u32::MAX];
660        for x in test_cases {
661            assert_eq!(x.to_fix(), Some(x.into()), "{x} did not fix correctly");
662            assert!(x.is_fixable(), "{x} did not is_fixable correctly");
663            assert!(RB_FIXABLE(x), "{x} did not RB_FIXABLE correctly");
664        }
665    }
666
667    #[test]
668    fn test_u64_are_fixable() {
669        let test_cases = [
670            (0_u64, Some(0_i64)),                                             // Smallest fixable value: `0`
671            (1_u64, Some(1)),                                                 // Another fixable value: `1`
672            (4_611_686_018_427_387_903_u64, Some(4_611_686_018_427_387_903)), // Largest fixable value: `2^62 - 1`
673            (4_611_686_018_427_387_904_u64, None), // Value just above the fixable range: `2^62`
674            (4_611_686_018_427_387_905_u64, None), // Value further above the fixable range: `2^62 + 1`
675            (9_223_372_036_854_775_806_u64, None), // Value near the maximum `u64` value: `2^63 - 2`
676            (9_223_372_036_854_775_807_u64, None), // Maximum `u64` value: `2^63 - 1`
677            (18_446_744_073_709_551_614_u64, None), // Value just above the maximum `i64` value: `2^63`
678            (18_446_744_073_709_551_615_u64, None), // Value further above the maximum `i64` value: `2^63 + 1`
679            (9_223_372_036_854_775_809_u64, None), // Value near the maximum `u64`` value: `2^63 + 3`
680        ];
681        for (x, fixed) in test_cases {
682            assert_eq!(x.to_fix(), fixed, "{x} did not fix correctly");
683            assert_eq!(x.is_fixable(), fixed.is_some(), "{x} did not is_fixable correctly");
684            assert_eq!(RB_FIXABLE(x), fixed.is_some(), "{x} did not RB_FIXABLE correctly");
685        }
686    }
687
688    #[test]
689    fn test_u128_are_fixable() {
690        let test_cases = [
691            (u128::MIN, Some(0)),
692            (0_u128, Some(0)),
693            (1, Some(1)),
694            (10, Some(10)),
695            (1024, Some(1024)),
696            // ```
697            // >>> (2 ** 63 - 1) >> 1
698            // 4611686018427387903
699            // ```
700            (4_611_686_018_427_387_903 - 1, Some(4_611_686_018_427_387_902)),
701            (4_611_686_018_427_387_903, Some(4_611_686_018_427_387_903)),
702            (4_611_686_018_427_387_903 + 1, None),
703            (u128::try_from(RUBY_FIXNUM_MAX).unwrap() - 1, Some(RUBY_FIXNUM_MAX - 1)),
704            (u128::try_from(RUBY_FIXNUM_MAX).unwrap(), Some(RUBY_FIXNUM_MAX)),
705            (u128::try_from(RUBY_FIXNUM_MAX).unwrap() + 1, None),
706            (i64::MAX.try_into().unwrap(), None),
707            (u128::MAX, None),
708        ];
709        for (x, fixed) in test_cases {
710            assert_eq!(x.to_fix(), fixed, "{x} did not fix correctly");
711            assert_eq!(x.is_fixable(), fixed.is_some(), "{x} did not is_fixable correctly");
712            assert_eq!(RB_FIXABLE(x), fixed.is_some(), "{x} did not RB_FIXABLE correctly");
713        }
714    }
715
716    #[test]
717    #[expect(clippy::approx_constant, clippy::cast_precision_loss, reason = "test values")]
718    fn test_f32_are_fixable() {
719        let test_cases = [
720            // Value within fixable range
721            (0.0, Some(0)),
722            (123.45, Some(123)),
723            (-987.65, Some(-987)),
724            // Value outside fixable range
725            (1e38, None),         // Greater than `i64::MAX`
726            (-1e38, None),        // Less than `i64::MIN`
727            (1.234e-18, Some(0)), // Very small value
728            // Interesting float values
729            (-0.0, Some(0)),              // Negative zero
730            (f32::NAN, None),             // Not a Number
731            (f32::INFINITY, None),        // Positive infinity
732            (f32::EPSILON, Some(0)),      // Smallest positive value greater than 0
733            (f32::NEG_INFINITY, None),    // Negative infinity
734            (f32::MIN_POSITIVE, Some(0)), // Smallest positive normalized value
735            (f32::MAX, None),             // Maximum float value
736            (f32::MIN, None),             // Minimum float value
737            // Boundary conditions
738            (i64::MIN as _, None),                             // `i64::MIN` as float
739            (-4.611_686e18, Some(-4_611_686_018_427_387_904)), // closest float to `i64::MIN / 2`
740            (i64::MAX as _, None),                             // Largest finite positive value
741            (4.611_685_5e18, Some(4_611_685_468_671_574_016)), // closest float to `i64::MAX / 2`
742            // Varying fractional parts
743            (1.99, Some(1)),      // Truncated decimal part
744            (3.14159, Some(3)),   // Truncated decimal part
745            (-2.71828, Some(-2)), // Truncated decimal part
746        ];
747        for (x, fixed) in test_cases {
748            assert_eq!(x.to_fix(), fixed, "{x} did not fix correctly");
749            assert_eq!(x.is_fixable(), fixed.is_some(), "{x} did not is_fixable correctly");
750            assert_eq!(RB_FIXABLE(x), fixed.is_some(), "{x} did not RB_FIXABLE correctly");
751        }
752    }
753
754    #[test]
755    #[expect(clippy::approx_constant, clippy::cast_precision_loss, reason = "test values")]
756    fn test_f64_are_fixable() {
757        let test_cases = [
758            // Value within fixable range
759            (0.0, Some(0)),
760            (123.45, Some(123)),
761            (-987.65, Some(-987)),
762            // Value outside fixable range
763            (1e38, None),         // Greater than `i64::MAX`
764            (-1e38, None),        // Less than `i64::MIN`
765            (1.234e-18, Some(0)), // Very small value
766            // Interesting float values
767            (-0.0, Some(0)),              // Negative zero
768            (f64::NAN, None),             // Not a Number
769            (f64::INFINITY, None),        // Positive infinity
770            (f64::EPSILON, Some(0)),      // Smallest positive value greater than 0
771            (f64::NEG_INFINITY, None),    // Negative infinity
772            (f64::MIN_POSITIVE, Some(0)), // Smallest positive normalized value
773            (f64::MAX, None),             // Maximum float value
774            (f64::MIN, None),             // Minimum float value
775            // Boundary conditions
776            (i64::MIN as _, None),                                         // `i64::MIN` as float
777            (-4.611_686_018_427_387e18, Some(-4_611_686_018_427_386_880)), // closest float to `i64::MIN / 2`
778            (i64::MAX as _, None),                                         // Largest finite positive value
779            (4.611_686_018_427_387e18, Some(4_611_686_018_427_386_880)),   // closest float to `i64::MAX / 2`
780            // Varying fractional parts
781            (1.99, Some(1)),      // Truncated decimal part
782            (3.14159, Some(3)),   // Truncated decimal part
783            (-2.71828, Some(-2)), // Truncated decimal part
784        ];
785        for (x, fixed) in test_cases {
786            assert_eq!(x.to_fix(), fixed, "{x} did not fix correctly");
787            assert_eq!(x.is_fixable(), fixed.is_some(), "{x} did not is_fixable correctly");
788            assert_eq!(RB_FIXABLE(x), fixed.is_some(), "{x} did not RB_FIXABLE correctly");
789        }
790    }
791
792    #[test]
793    fn test_fixable_boundary_values_u8() {
794        assert!(0_u8.is_fixable());
795        assert!(255_u8.is_fixable());
796    }
797
798    #[test]
799    fn test_to_fix_boundary_values_u8() {
800        assert_eq!(0_u8.to_fix(), Some(0));
801        assert_eq!(255_u8.to_fix(), Some(255));
802    }
803
804    #[test]
805    fn test_fixable_boundary_values_i8() {
806        assert!(0_i8.is_fixable());
807        assert!(127_i8.is_fixable());
808        assert!((-128_i8).is_fixable());
809    }
810
811    #[test]
812    fn test_to_fix_boundary_values_i8() {
813        assert_eq!(0_i8.to_fix(), Some(0));
814        assert_eq!(127_i8.to_fix(), Some(127));
815        assert_eq!((-128_i8).to_fix(), Some(-128));
816    }
817
818    #[test]
819    fn test_fixable_boundary_values_u16() {
820        assert!(0_u16.is_fixable());
821        assert!(65_535_u16.is_fixable());
822    }
823
824    #[test]
825    fn test_to_fix_boundary_values_u16() {
826        assert_eq!(0_u16.to_fix(), Some(0));
827        assert_eq!(65_535_u16.to_fix(), Some(65_535));
828    }
829
830    #[test]
831    fn test_fixable_boundary_values_i16() {
832        assert!(0_i16.is_fixable());
833        assert!(32_767_i16.is_fixable());
834        assert!((-32_768_i16).is_fixable());
835    }
836
837    #[test]
838    fn test_to_fix_boundary_values_i16() {
839        assert_eq!(0_i16.to_fix(), Some(0));
840        assert_eq!(32_767_i16.to_fix(), Some(32_767));
841        assert_eq!((-32_768_i16).to_fix(), Some(-32_768));
842    }
843
844    #[test]
845    fn test_fixable_boundary_values_u32() {
846        assert!(0_u32.is_fixable());
847        assert!(4_294_967_295_u32.is_fixable());
848    }
849
850    #[test]
851    fn test_to_fix_boundary_values_u32() {
852        assert_eq!(0_u32.to_fix(), Some(0));
853        assert_eq!(4_294_967_295_u32.to_fix(), Some(4_294_967_295));
854    }
855
856    #[test]
857    fn test_fixable_boundary_values_i32() {
858        assert!(0_i32.is_fixable());
859        assert!(2_147_483_647_i32.is_fixable());
860        assert!((-2_147_483_648_i32).is_fixable());
861    }
862
863    #[test]
864    fn test_to_fix_boundary_values_i32() {
865        assert_eq!(0_i32.to_fix(), Some(0));
866        assert_eq!(2_147_483_647_i32.to_fix(), Some(2_147_483_647));
867        assert_eq!((-2_147_483_648_i32).to_fix(), Some(-2_147_483_648));
868    }
869
870    #[test]
871    fn test_fixable_boundary_values_u64() {
872        assert!(0_u64.is_fixable());
873        assert!((u64::MAX >> 2).is_fixable());
874        assert!(!(u64::MAX >> 1).is_fixable());
875        assert!(!u64::MAX.is_fixable());
876    }
877
878    #[test]
879    fn test_to_fix_boundary_values_u64() {
880        assert_eq!(0_u64.to_fix(), Some(0));
881        assert_eq!((u64::MAX >> 2).to_fix(), Some(i64::MAX / 2));
882        assert_eq!((u64::MAX >> 1).to_fix(), None);
883        assert_eq!(u64::MAX.to_fix(), None);
884    }
885
886    #[test]
887    fn test_fixable_boundary_values_i64() {
888        assert!(0_i64.is_fixable());
889        assert!((i64::MIN >> 1).is_fixable());
890        assert!((i64::MAX >> 1).is_fixable());
891        assert!(!i64::MIN.is_fixable());
892        assert!(!i64::MAX.is_fixable());
893    }
894
895    #[test]
896    fn test_to_fix_boundary_values_i64() {
897        assert_eq!(0_i64.to_fix(), Some(0));
898        assert_eq!((i64::MAX >> 1).to_fix(), Some(i64::MAX / 2));
899        assert_eq!((i64::MIN >> 1).to_fix(), Some(i64::MIN / 2));
900        assert_eq!(i64::MIN.to_fix(), None);
901        assert_eq!(i64::MAX.to_fix(), None);
902    }
903
904    #[test]
905    fn test_fixable_boundary_values_u128() {
906        assert!(0_u64.is_fixable());
907        assert!((u128::MAX >> 66).is_fixable());
908        assert!(!(u128::MAX >> 65).is_fixable());
909        assert!(!(u128::MAX >> 10).is_fixable());
910        assert!(!(u128::MAX >> 2).is_fixable());
911        assert!(!(u128::MAX >> 1).is_fixable());
912        assert!(!u128::MAX.is_fixable());
913    }
914
915    #[test]
916    fn test_to_fix_boundary_values_u128() {
917        assert_eq!(0_u64.to_fix(), Some(0));
918        assert_eq!((u128::MAX >> 66).to_fix(), Some(i64::MAX / 2));
919        assert_eq!((u128::MAX >> 65).to_fix(), None);
920        assert_eq!((u128::MAX >> 10).to_fix(), None);
921        assert_eq!((u128::MAX >> 2).to_fix(), None);
922        assert_eq!((u128::MAX >> 1).to_fix(), None);
923        assert_eq!(u128::MAX.to_fix(), None);
924    }
925
926    #[test]
927    fn test_fixable_boundary_values_i128() {
928        assert!(0_i128.is_fixable());
929        assert!((i128::MIN >> 65).is_fixable());
930        assert!((i128::MAX >> 65).is_fixable());
931        assert!(!(i128::MIN >> 1).is_fixable());
932        assert!(!(i128::MAX >> 1).is_fixable());
933        assert!(!i128::MIN.is_fixable());
934        assert!(!i128::MAX.is_fixable());
935    }
936
937    #[test]
938    fn test_to_fix_boundary_values_i128() {
939        assert_eq!(0_i128.to_fix(), Some(0));
940        assert_eq!((i128::MAX >> 65).to_fix(), Some(i64::MAX / 2));
941        assert_eq!((i128::MIN >> 65).to_fix(), Some(i64::MIN / 2));
942        assert_eq!((i128::MAX >> 1).to_fix(), None);
943        assert_eq!((i128::MIN >> 1).to_fix(), None);
944        assert_eq!(i128::MIN.to_fix(), None);
945        assert_eq!(i128::MAX.to_fix(), None);
946    }
947}
scolapasta_fixable/lib.rs

scolapasta_fixable/
lib.rs
