Improve comments and code formatting

Author: ChaiTRex

library/core/tests/num/int_sqrt.rs

@@ -7,24 +7,21 @@ macro_rules! tests {
                 // Check that the following produce the correct values from
                 // `isqrt`:
                 //
-                // * `<$T>::MIN` (for signed types, no nonnegative value can
-                //   negate to `<$T>::MIN)
                 // * the first and last 128 nonnegative values
                 // * powers of two, minus one
                 // * powers of two
                 //
-                // For signed types, check that `checked_isqrt` and
-                // `isqrt` either produce the same numeric value or
-                // respectively produce `None` and a panic.
+                // For signed types, check that `checked_isqrt` and `isqrt`
+                // either produce the same numeric value or respectively
+                // produce `None` and a panic. Make sure to do a consistency
+                // check for `<$T>::MIN` as well, as no nonnegative values
+                // negate to it.
                 //
                 // For unsigned types check that `isqrt` produces the same
                 // numeric value for `$T` and `NonZero<$T>`.
                 #[test]
                 fn isqrt() {
-                    // Check the minimum value because, for signed types,
-                    // there's no nonnegative value that can be negated into
-                    // the minimum value.
-                    isqrt_consistency_check($T::MIN);
+                    isqrt_consistency_check(<$T>::MIN);
 
                     for n in (0..=127)
                         .chain(<$T>::MAX - 127..=<$T>::MAX)
@@ -35,11 +32,17 @@ macro_rules! tests {
 
                         let isqrt_n = n.isqrt();
                         assert!(
-                            isqrt_n.checked_mul(isqrt_n).map(|isqrt_n_squared| isqrt_n_squared <= n).unwrap_or(false),
+                            isqrt_n
+                                .checked_mul(isqrt_n)
+                                .map(|isqrt_n_squared| isqrt_n_squared <= n)
+                                .unwrap_or(false),
                             "`{n}.isqrt()` should be lower than {isqrt_n}."
                         );
                         assert!(
-                            (isqrt_n + 1).checked_mul(isqrt_n + 1).map(|isqrt_n_plus_1_squared| n < isqrt_n_plus_1_squared).unwrap_or(true),
+                            (isqrt_n + 1)
+                                .checked_mul(isqrt_n + 1)
+                                .map(|isqrt_n_plus_1_squared| n < isqrt_n_plus_1_squared)
+                                .unwrap_or(true),
                             "`{n}.isqrt()` should be higher than {isqrt_n})."
                         );
                     }
@@ -173,8 +176,8 @@ macro_rules! signed_check {
     ($T:ident) => {
         /// This takes an input and, if it's nonnegative or
         #[doc = concat!("`", stringify!($T), "::MIN`,")]
-        /// checks that `isqrt` and `checked_isqrt` produce equivalent
-        /// results for that input and for the negative of that input.
+        /// checks that `isqrt` and `checked_isqrt` produce equivalent results
+        /// for that input and for the negative of that input.
         fn isqrt_consistency_check(n: $T) {
             // `<$T>::MIN` will be negative, so ignore it in this nonnegative
             // section.
@@ -186,8 +189,8 @@ macro_rules! signed_check {
                 );
             }
 
-            // `wrapping_neg` so that `<$T>::MIN` will negate to
-            // itself rather than panicking.
+            // `wrapping_neg` so that `<$T>::MIN` will negate to itself rather
+            // than panicking.
             let negative_n = n.wrapping_neg();
 
             // Zero negated will still be nonnegative, so ignore it in this
@@ -209,8 +212,8 @@ macro_rules! signed_check {
 
 macro_rules! unsigned_check {
     ($T:ident) => {
-        /// This takes an input and, if it's nonzero, checks that
-        /// `isqrt` produces the same numeric value for both
+        /// This takes an input and, if it's nonzero, checks that `isqrt`
+        /// produces the same numeric value for both
         #[doc = concat!("`", stringify!($T), "` and ")]
         #[doc = concat!("`NonZero<", stringify!($T), ">`.")]
         fn isqrt_consistency_check(n: $T) {
@@ -220,7 +223,9 @@ macro_rules! unsigned_check {
                 assert_eq!(
                     n.isqrt(),
                     ::core::num::NonZero::<$T>::new(n)
-                        .expect("Was not able to create a new `NonZero` value from a nonzero value")
+                        .expect(
+                            "Was not able to create a new `NonZero` value from a nonzero number."
+                        )
                         .isqrt()
                         .get(),
                     "`{n}.isqrt` should match `NonZero`'s `{n}.isqrt().get()`.",