Adding upstream version 1.66.0+dfsg1.upstream/1.66.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 157 insertions, 81 deletions

diff --git a/library/core/tests/num/int_log.rs b/library/core/tests/num/int_log.rs
index dc3092e14..a1edb1a51 100644
--- a/library/core/tests/num/int_log.rs
+++ b/library/core/tests/num/int_log.rs
@@ -1,166 +1,196 @@
-//! This tests the `Integer::{log,log2,log10}` methods. These tests are in a
+//! This tests the `Integer::{ilog,log2,log10}` methods. These tests are in a
 //! separate file because there's both a large number of them, and not all tests
-//! can be run on Android. This is because in Android `log2` uses an imprecise
+//! can be run on Android. This is because in Android `ilog2` uses an imprecise
 //! approximation:https://github.com/rust-lang/rust/blob/4825e12fc9c79954aa0fe18f5521efa6c19c7539/src/libstd/sys/unix/android.rs#L27-L53
 
 #[test]
-fn checked_log() {
-    assert_eq!(999u32.checked_log(10), Some(2));
-    assert_eq!(1000u32.checked_log(10), Some(3));
-    assert_eq!(555u32.checked_log(13), Some(2));
-    assert_eq!(63u32.checked_log(4), Some(2));
-    assert_eq!(64u32.checked_log(4), Some(3));
-    assert_eq!(10460353203u64.checked_log(3), Some(21));
-    assert_eq!(10460353202u64.checked_log(3), Some(20));
-    assert_eq!(147808829414345923316083210206383297601u128.checked_log(3), Some(80));
-    assert_eq!(147808829414345923316083210206383297600u128.checked_log(3), Some(79));
-    assert_eq!(22528399544939174411840147874772641u128.checked_log(19683), Some(8));
-    assert_eq!(22528399544939174411840147874772631i128.checked_log(19683), Some(7));
-
-    assert_eq!(0u8.checked_log(4), None);
-    assert_eq!(0u16.checked_log(4), None);
-    assert_eq!(0i8.checked_log(4), None);
-    assert_eq!(0i16.checked_log(4), None);
+fn checked_ilog() {
+    assert_eq!(999u32.checked_ilog(10), Some(2));
+    assert_eq!(1000u32.checked_ilog(10), Some(3));
+    assert_eq!(555u32.checked_ilog(13), Some(2));
+    assert_eq!(63u32.checked_ilog(4), Some(2));
+    assert_eq!(64u32.checked_ilog(4), Some(3));
+    assert_eq!(10460353203u64.checked_ilog(3), Some(21));
+    assert_eq!(10460353202u64.checked_ilog(3), Some(20));
+    assert_eq!(147808829414345923316083210206383297601u128.checked_ilog(3), Some(80));
+    assert_eq!(147808829414345923316083210206383297600u128.checked_ilog(3), Some(79));
+    assert_eq!(22528399544939174411840147874772641u128.checked_ilog(19683), Some(8));
+    assert_eq!(22528399544939174411840147874772631i128.checked_ilog(19683), Some(7));
+
+    assert_eq!(0u8.checked_ilog(4), None);
+    assert_eq!(0u16.checked_ilog(4), None);
+    assert_eq!(0i8.checked_ilog(4), None);
+    assert_eq!(0i16.checked_ilog(4), None);
 
     #[cfg(not(miri))] // Miri is too slow
     for i in i16::MIN..=0 {
-        assert_eq!(i.checked_log(4), None);
+        assert_eq!(i.checked_ilog(4), None);
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=i16::MAX {
-        assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as u32));
+        assert_eq!(i.checked_ilog(13), Some((i as f32).log(13.0) as u32));
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=u16::MAX {
-        assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as u32));
+        assert_eq!(i.checked_ilog(13), Some((i as f32).log(13.0) as u32));
     }
 }
 
 #[test]
-fn checked_log2() {
-    assert_eq!(5u32.checked_log2(), Some(2));
-    assert_eq!(0u64.checked_log2(), None);
-    assert_eq!(128i32.checked_log2(), Some(7));
-    assert_eq!((-55i16).checked_log2(), None);
+fn checked_ilog2() {
+    assert_eq!(5u32.checked_ilog2(), Some(2));
+    assert_eq!(0u64.checked_ilog2(), None);
+    assert_eq!(128i32.checked_ilog2(), Some(7));
+    assert_eq!((-55i16).checked_ilog2(), None);
 
-    assert_eq!(0u8.checked_log2(), None);
-    assert_eq!(0u16.checked_log2(), None);
-    assert_eq!(0i8.checked_log2(), None);
-    assert_eq!(0i16.checked_log2(), None);
+    assert_eq!(0u8.checked_ilog2(), None);
+    assert_eq!(0u16.checked_ilog2(), None);
+    assert_eq!(0i8.checked_ilog2(), None);
+    assert_eq!(0i16.checked_ilog2(), None);
 
     for i in 1..=u8::MAX {
-        assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));
+        assert_eq!(i.checked_ilog2(), Some((i as f32).log2() as u32));
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=u16::MAX {
-        // Guard against Android's imprecise f32::log2 implementation.
+        // Guard against Android's imprecise f32::ilog2 implementation.
         if i != 8192 && i != 32768 {
-            assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));
+            assert_eq!(i.checked_ilog2(), Some((i as f32).log2() as u32));
         }
     }
     for i in i8::MIN..=0 {
-        assert_eq!(i.checked_log2(), None);
+        assert_eq!(i.checked_ilog2(), None);
     }
     for i in 1..=i8::MAX {
-        assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));
+        assert_eq!(i.checked_ilog2(), Some((i as f32).log2() as u32));
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in i16::MIN..=0 {
-        assert_eq!(i.checked_log2(), None);
+        assert_eq!(i.checked_ilog2(), None);
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=i16::MAX {
-        // Guard against Android's imprecise f32::log2 implementation.
+        // Guard against Android's imprecise f32::ilog2 implementation.
         if i != 8192 {
-            assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));
+            assert_eq!(i.checked_ilog2(), Some((i as f32).log2() as u32));
         }
     }
 }
 
-// Validate cases that fail on Android's imprecise float log2 implementation.
+// Validate cases that fail on Android's imprecise float ilog2 implementation.
 #[test]
 #[cfg(not(target_os = "android"))]
-fn checked_log2_not_android() {
-    assert_eq!(8192u16.checked_log2(), Some((8192f32).log2() as u32));
-    assert_eq!(32768u16.checked_log2(), Some((32768f32).log2() as u32));
-    assert_eq!(8192i16.checked_log2(), Some((8192f32).log2() as u32));
+fn checked_ilog2_not_android() {
+    assert_eq!(8192u16.checked_ilog2(), Some((8192f32).log2() as u32));
+    assert_eq!(32768u16.checked_ilog2(), Some((32768f32).log2() as u32));
+    assert_eq!(8192i16.checked_ilog2(), Some((8192f32).log2() as u32));
 }
 
 #[test]
-fn checked_log10() {
-    assert_eq!(0u8.checked_log10(), None);
-    assert_eq!(0u16.checked_log10(), None);
-    assert_eq!(0i8.checked_log10(), None);
-    assert_eq!(0i16.checked_log10(), None);
+fn checked_ilog10() {
+    assert_eq!(0u8.checked_ilog10(), None);
+    assert_eq!(0u16.checked_ilog10(), None);
+    assert_eq!(0i8.checked_ilog10(), None);
+    assert_eq!(0i16.checked_ilog10(), None);
 
     #[cfg(not(miri))] // Miri is too slow
     for i in i16::MIN..=0 {
-        assert_eq!(i.checked_log10(), None);
+        assert_eq!(i.checked_ilog10(), None);
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=i16::MAX {
-        assert_eq!(i.checked_log10(), Some((i as f32).log10() as u32));
+        assert_eq!(i.checked_ilog10(), Some((i as f32).log10() as u32));
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=u16::MAX {
-        assert_eq!(i.checked_log10(), Some((i as f32).log10() as u32));
+        assert_eq!(i.checked_ilog10(), Some((i as f32).log10() as u32));
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=100_000u32 {
-        assert_eq!(i.checked_log10(), Some((i as f32).log10() as u32));
+        assert_eq!(i.checked_ilog10(), Some((i as f32).log10() as u32));
     }
 }
 
-macro_rules! log10_loop {
-    ($T:ty, $log10_max:expr) => {
-        assert_eq!(<$T>::MAX.log10(), $log10_max);
-        for i in 0..=$log10_max {
+macro_rules! ilog10_loop {
+    ($T:ty, $ilog10_max:expr) => {
+        assert_eq!(<$T>::MAX.ilog10(), $ilog10_max);
+        for i in 0..=$ilog10_max {
             let p = (10 as $T).pow(i as u32);
             if p >= 10 {
-                assert_eq!((p - 9).log10(), i - 1);
-                assert_eq!((p - 1).log10(), i - 1);
+                assert_eq!((p - 9).ilog10(), i - 1);
+                assert_eq!((p - 1).ilog10(), i - 1);
             }
-            assert_eq!(p.log10(), i);
-            assert_eq!((p + 1).log10(), i);
+            assert_eq!(p.ilog10(), i);
+            assert_eq!((p + 1).ilog10(), i);
             if p >= 10 {
-                assert_eq!((p + 9).log10(), i);
+                assert_eq!((p + 9).ilog10(), i);
             }
 
-            // also check `x.log(10)`
+            // also check `x.ilog(10)`
             if p >= 10 {
-                assert_eq!((p - 9).log(10), i - 1);
-                assert_eq!((p - 1).log(10), i - 1);
+                assert_eq!((p - 9).ilog(10), i - 1);
+                assert_eq!((p - 1).ilog(10), i - 1);
             }
-            assert_eq!(p.log(10), i);
-            assert_eq!((p + 1).log(10), i);
+            assert_eq!(p.ilog(10), i);
+            assert_eq!((p + 1).ilog(10), i);
             if p >= 10 {
-                assert_eq!((p + 9).log(10), i);
+                assert_eq!((p + 9).ilog(10), i);
             }
         }
     };
 }
 
 #[test]
-fn log10_u8() {
-    log10_loop! { u8, 2 }
+fn ilog10_u8() {
+    ilog10_loop! { u8, 2 }
 }
 
 #[test]
-fn log10_u16() {
-    log10_loop! { u16, 4 }
+fn ilog10_u16() {
+    ilog10_loop! { u16, 4 }
 }
 
 #[test]
-fn log10_u32() {
-    log10_loop! { u32, 9 }
+fn ilog10_u32() {
+    ilog10_loop! { u32, 9 }
 }
 
 #[test]
-fn log10_u64() {
-    log10_loop! { u64, 19 }
+fn ilog10_u64() {
+    ilog10_loop! { u64, 19 }
 }
 
 #[test]
-fn log10_u128() {
-    log10_loop! { u128, 38 }
+fn ilog10_u128() {
+    ilog10_loop! { u128, 38 }
+}
+
+#[test]
+#[should_panic(expected = "argument of integer logarithm must be positive")]
+fn ilog2_of_0_panic() {
+    let _ = 0u32.ilog2();
+}
+
+#[test]
+#[should_panic(expected = "argument of integer logarithm must be positive")]
+fn ilog10_of_0_panic() {
+    let _ = 0u32.ilog10();
+}
+
+#[test]
+#[should_panic(expected = "argument of integer logarithm must be positive")]
+fn ilog3_of_0_panic() {
+    let _ = 0u32.ilog(3);
+}
+
+#[test]
+#[should_panic(expected = "base of integer logarithm must be at least 2")]
+fn ilog0_of_1_panic() {
+    let _ = 1u32.ilog(0);
+}
+
+#[test]
+#[should_panic(expected = "base of integer logarithm must be at least 2")]
+fn ilog1_of_1_panic() {
+    let _ = 1u32.ilog(1);
 }
diff --git a/library/core/tests/num/int_macros.rs b/library/core/tests/num/int_macros.rs
index 8b84a78e6..18c55e43a 100644
--- a/library/core/tests/num/int_macros.rs
+++ b/library/core/tests/num/int_macros.rs
@@ -338,6 +338,32 @@ macro_rules! int_module {
                 assert_eq!(MIN.checked_next_multiple_of(-3), None);
                 assert_eq!(MIN.checked_next_multiple_of(-1), Some(MIN));
             }
+
+            #[test]
+            fn test_carrying_add() {
+                assert_eq!($T::MAX.carrying_add(1, false), ($T::MIN, true));
+                assert_eq!($T::MAX.carrying_add(0, true), ($T::MIN, true));
+                assert_eq!($T::MAX.carrying_add(1, true), ($T::MIN + 1, true));
+                assert_eq!($T::MAX.carrying_add(-1, false), ($T::MAX - 1, false));
+                assert_eq!($T::MAX.carrying_add(-1, true), ($T::MAX, false)); // no intermediate overflow
+                assert_eq!($T::MIN.carrying_add(-1, false), ($T::MAX, true));
+                assert_eq!($T::MIN.carrying_add(-1, true), ($T::MIN, false)); // no intermediate overflow
+                assert_eq!((0 as $T).carrying_add($T::MAX, true), ($T::MIN, true));
+                assert_eq!((0 as $T).carrying_add($T::MIN, true), ($T::MIN + 1, false));
+            }
+
+            #[test]
+            fn test_borrowing_sub() {
+                assert_eq!($T::MIN.borrowing_sub(1, false), ($T::MAX, true));
+                assert_eq!($T::MIN.borrowing_sub(0, true), ($T::MAX, true));
+                assert_eq!($T::MIN.borrowing_sub(1, true), ($T::MAX - 1, true));
+                assert_eq!($T::MIN.borrowing_sub(-1, false), ($T::MIN + 1, false));
+                assert_eq!($T::MIN.borrowing_sub(-1, true), ($T::MIN, false)); // no intermediate overflow
+                assert_eq!($T::MAX.borrowing_sub(-1, false), ($T::MIN, true));
+                assert_eq!($T::MAX.borrowing_sub(-1, true), ($T::MAX, false)); // no intermediate overflow
+                assert_eq!((0 as $T).borrowing_sub($T::MIN, false), ($T::MIN, true));
+                assert_eq!((0 as $T).borrowing_sub($T::MIN, true), ($T::MAX, false));
+            }
         }
     };
 }
diff --git a/library/core/tests/num/mod.rs b/library/core/tests/num/mod.rs
index 49580cdcc..c79e909e4 100644
--- a/library/core/tests/num/mod.rs
+++ b/library/core/tests/num/mod.rs
@@ -172,7 +172,7 @@ fn test_can_not_overflow() {
 
            // Calcutate the string length for the smallest overflowing number:
            let max_len_string = format_radix(num, base as u128);
-           // Ensure that that string length is deemed to potentially overflow:
+           // Ensure that string length is deemed to potentially overflow:
            assert!(can_overflow::<$t>(base, &max_len_string));
         }
         )*)
diff --git a/library/core/tests/num/uint_macros.rs b/library/core/tests/num/uint_macros.rs
index 93ae620c2..15ae9f232 100644
--- a/library/core/tests/num/uint_macros.rs
+++ b/library/core/tests/num/uint_macros.rs
@@ -230,6 +230,28 @@ macro_rules! uint_module {
                 assert_eq!((1 as $T).checked_next_multiple_of(0), None);
                 assert_eq!(MAX.checked_next_multiple_of(2), None);
             }
+
+            #[test]
+            fn test_carrying_add() {
+                assert_eq!($T::MAX.carrying_add(1, false), (0, true));
+                assert_eq!($T::MAX.carrying_add(0, true), (0, true));
+                assert_eq!($T::MAX.carrying_add(1, true), (1, true));
+
+                assert_eq!($T::MIN.carrying_add($T::MAX, false), ($T::MAX, false));
+                assert_eq!($T::MIN.carrying_add(0, true), (1, false));
+                assert_eq!($T::MIN.carrying_add($T::MAX, true), (0, true));
+            }
+
+            #[test]
+            fn test_borrowing_sub() {
+                assert_eq!($T::MIN.borrowing_sub(1, false), ($T::MAX, true));
+                assert_eq!($T::MIN.borrowing_sub(0, true), ($T::MAX, true));
+                assert_eq!($T::MIN.borrowing_sub(1, true), ($T::MAX - 1, true));
+
+                assert_eq!($T::MAX.borrowing_sub($T::MAX, false), (0, false));
+                assert_eq!($T::MAX.borrowing_sub(0, true), ($T::MAX - 1, false));
+                assert_eq!($T::MAX.borrowing_sub($T::MAX, true), ($T::MAX, true));
+            }
         }
     };
 }
diff --git a/library/core/tests/num/wrapping.rs b/library/core/tests/num/wrapping.rs
index 8ded139a1..c5a719883 100644
--- a/library/core/tests/num/wrapping.rs
+++ b/library/core/tests/num/wrapping.rs
@@ -75,8 +75,6 @@ wrapping_test!(test_wrapping_u64, u64, u64::MIN, u64::MAX);
 wrapping_test!(test_wrapping_u128, u128, u128::MIN, u128::MAX);
 wrapping_test!(test_wrapping_usize, usize, usize::MIN, usize::MAX);
 
-// Don't warn about overflowing ops on 32-bit platforms
-#[cfg_attr(target_pointer_width = "32", allow(const_err))]
 #[test]
 fn wrapping_int_api() {
     assert_eq!(i8::MAX.wrapping_add(1), i8::MIN);