summaryrefslogtreecommitdiffstats
path: root/library/core/tests
diff options
context:
space:
mode:
Diffstat (limited to 'library/core/tests')
-rw-r--r--library/core/tests/array.rs19
-rw-r--r--library/core/tests/fmt/mod.rs8
-rw-r--r--library/core/tests/iter/adapters/chain.rs41
-rw-r--r--library/core/tests/iter/adapters/enumerate.rs15
-rw-r--r--library/core/tests/iter/adapters/flatten.rs46
-rw-r--r--library/core/tests/iter/adapters/skip.rs14
-rw-r--r--library/core/tests/iter/adapters/take.rs15
-rw-r--r--library/core/tests/iter/range.rs19
-rw-r--r--library/core/tests/iter/traits/iterator.rs18
-rw-r--r--library/core/tests/lib.rs3
-rw-r--r--library/core/tests/num/dec2flt/mod.rs11
-rw-r--r--library/core/tests/num/dec2flt/parse.rs2
-rw-r--r--library/core/tests/slice.rs21
13 files changed, 124 insertions, 108 deletions
diff --git a/library/core/tests/array.rs b/library/core/tests/array.rs
index 5327e4f81..0869644c0 100644
--- a/library/core/tests/array.rs
+++ b/library/core/tests/array.rs
@@ -1,5 +1,6 @@
-use core::array;
+use core::{array, assert_eq};
use core::convert::TryFrom;
+use core::num::NonZeroUsize;
use core::sync::atomic::{AtomicUsize, Ordering};
#[test]
@@ -557,7 +558,7 @@ fn array_intoiter_advance_by() {
assert_eq!(counter.get(), 13);
let r = it.advance_by(123456);
- assert_eq!(r, Err(87));
+ assert_eq!(r, Err(NonZeroUsize::new(123456 - 87).unwrap()));
assert_eq!(it.len(), 0);
assert_eq!(counter.get(), 100);
@@ -567,7 +568,7 @@ fn array_intoiter_advance_by() {
assert_eq!(counter.get(), 100);
let r = it.advance_by(10);
- assert_eq!(r, Err(0));
+ assert_eq!(r, Err(NonZeroUsize::new(10).unwrap()));
assert_eq!(it.len(), 0);
assert_eq!(counter.get(), 100);
}
@@ -610,7 +611,7 @@ fn array_intoiter_advance_back_by() {
assert_eq!(counter.get(), 13);
let r = it.advance_back_by(123456);
- assert_eq!(r, Err(87));
+ assert_eq!(r, Err(NonZeroUsize::new(123456 - 87).unwrap()));
assert_eq!(it.len(), 0);
assert_eq!(counter.get(), 100);
@@ -620,7 +621,7 @@ fn array_intoiter_advance_back_by() {
assert_eq!(counter.get(), 100);
let r = it.advance_back_by(10);
- assert_eq!(r, Err(0));
+ assert_eq!(r, Err(NonZeroUsize::new(10).unwrap()));
assert_eq!(it.len(), 0);
assert_eq!(counter.get(), 100);
}
@@ -679,8 +680,8 @@ fn array_into_iter_fold() {
let a = [1, 2, 3, 4, 5, 6];
let mut it = a.into_iter();
- it.advance_by(1).unwrap();
- it.advance_back_by(2).unwrap();
+ assert_eq!(it.advance_by(1), Ok(()));
+ assert_eq!(it.advance_back_by(2), Ok(()));
let s = it.fold(10, |a, b| 10 * a + b);
assert_eq!(s, 10234);
}
@@ -695,8 +696,8 @@ fn array_into_iter_rfold() {
let a = [1, 2, 3, 4, 5, 6];
let mut it = a.into_iter();
- it.advance_by(1).unwrap();
- it.advance_back_by(2).unwrap();
+ assert_eq!(it.advance_by(1), Ok(()));
+ assert_eq!(it.advance_back_by(2), Ok(()));
let s = it.rfold(10, |a, b| 10 * a + b);
assert_eq!(s, 10432);
}
diff --git a/library/core/tests/fmt/mod.rs b/library/core/tests/fmt/mod.rs
index 618076358..c1c80c46c 100644
--- a/library/core/tests/fmt/mod.rs
+++ b/library/core/tests/fmt/mod.rs
@@ -22,11 +22,11 @@ fn test_pointer_formats_data_pointer() {
#[test]
fn test_estimated_capacity() {
assert_eq!(format_args!("").estimated_capacity(), 0);
- assert_eq!(format_args!("{}", "").estimated_capacity(), 0);
+ assert_eq!(format_args!("{}", {""}).estimated_capacity(), 0);
assert_eq!(format_args!("Hello").estimated_capacity(), 5);
- assert_eq!(format_args!("Hello, {}!", "").estimated_capacity(), 16);
- assert_eq!(format_args!("{}, hello!", "World").estimated_capacity(), 0);
- assert_eq!(format_args!("{}. 16-bytes piece", "World").estimated_capacity(), 32);
+ assert_eq!(format_args!("Hello, {}!", {""}).estimated_capacity(), 16);
+ assert_eq!(format_args!("{}, hello!", {"World"}).estimated_capacity(), 0);
+ assert_eq!(format_args!("{}. 16-bytes piece", {"World"}).estimated_capacity(), 32);
}
#[test]
diff --git a/library/core/tests/iter/adapters/chain.rs b/library/core/tests/iter/adapters/chain.rs
index f419f9cec..175a1b638 100644
--- a/library/core/tests/iter/adapters/chain.rs
+++ b/library/core/tests/iter/adapters/chain.rs
@@ -1,5 +1,6 @@
use super::*;
use core::iter::*;
+use core::num::NonZeroUsize;
#[test]
fn test_iterator_chain() {
@@ -31,28 +32,28 @@ fn test_iterator_chain_advance_by() {
for i in 0..xs.len() {
let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
- iter.advance_by(i).unwrap();
+ assert_eq!(iter.advance_by(i), Ok(()));
assert_eq!(iter.next(), Some(&xs[i]));
- assert_eq!(iter.advance_by(100), Err(len - i - 1));
- iter.advance_by(0).unwrap();
+ assert_eq!(iter.advance_by(100), Err(NonZeroUsize::new(100 - (len - i - 1)).unwrap()));
+ assert_eq!(iter.advance_by(0), Ok(()));
}
for i in 0..ys.len() {
let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
- iter.advance_by(xs.len() + i).unwrap();
+ assert_eq!(iter.advance_by(xs.len() + i), Ok(()));
assert_eq!(iter.next(), Some(&ys[i]));
- assert_eq!(iter.advance_by(100), Err(ys.len() - i - 1));
- iter.advance_by(0).unwrap();
+ assert_eq!(iter.advance_by(100), Err(NonZeroUsize::new(100 - (ys.len() - i - 1)).unwrap()));
+ assert_eq!(iter.advance_by(0), Ok(()));
}
let mut iter = xs.iter().chain(ys);
- iter.advance_by(len).unwrap();
+ assert_eq!(iter.advance_by(len), Ok(()));
assert_eq!(iter.next(), None);
- iter.advance_by(0).unwrap();
+ assert_eq!(iter.advance_by(0), Ok(()));
let mut iter = xs.iter().chain(ys);
- assert_eq!(iter.advance_by(len + 1), Err(len));
- iter.advance_by(0).unwrap();
+ assert_eq!(iter.advance_by(len + 1), Err(NonZeroUsize::new(1).unwrap()));
+ assert_eq!(iter.advance_by(0), Ok(()));
}
test_chain(&[], &[]);
@@ -68,28 +69,28 @@ fn test_iterator_chain_advance_back_by() {
for i in 0..ys.len() {
let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
- iter.advance_back_by(i).unwrap();
+ assert_eq!(iter.advance_back_by(i), Ok(()));
assert_eq!(iter.next_back(), Some(&ys[ys.len() - i - 1]));
- assert_eq!(iter.advance_back_by(100), Err(len - i - 1));
- iter.advance_back_by(0).unwrap();
+ assert_eq!(iter.advance_back_by(100), Err(NonZeroUsize::new(100 - (len - i - 1)).unwrap()));
+ assert_eq!(iter.advance_back_by(0), Ok(()));
}
for i in 0..xs.len() {
let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
- iter.advance_back_by(ys.len() + i).unwrap();
+ assert_eq!(iter.advance_back_by(ys.len() + i), Ok(()));
assert_eq!(iter.next_back(), Some(&xs[xs.len() - i - 1]));
- assert_eq!(iter.advance_back_by(100), Err(xs.len() - i - 1));
- iter.advance_back_by(0).unwrap();
+ assert_eq!(iter.advance_back_by(100), Err(NonZeroUsize::new(100 - (xs.len() - i - 1)).unwrap()));
+ assert_eq!(iter.advance_back_by(0), Ok(()));
}
let mut iter = xs.iter().chain(ys);
- iter.advance_back_by(len).unwrap();
+ assert_eq!(iter.advance_back_by(len), Ok(()));
assert_eq!(iter.next_back(), None);
- iter.advance_back_by(0).unwrap();
+ assert_eq!(iter.advance_back_by(0), Ok(()));
let mut iter = xs.iter().chain(ys);
- assert_eq!(iter.advance_back_by(len + 1), Err(len));
- iter.advance_back_by(0).unwrap();
+ assert_eq!(iter.advance_back_by(len + 1), Err(NonZeroUsize::new(1).unwrap()));
+ assert_eq!(iter.advance_back_by(0), Ok(()));
}
test_chain(&[], &[]);
diff --git a/library/core/tests/iter/adapters/enumerate.rs b/library/core/tests/iter/adapters/enumerate.rs
index 0e6033878..ff57973a6 100644
--- a/library/core/tests/iter/adapters/enumerate.rs
+++ b/library/core/tests/iter/adapters/enumerate.rs
@@ -1,4 +1,5 @@
use core::iter::*;
+use core::num::NonZeroUsize;
#[test]
fn test_iterator_enumerate() {
@@ -56,6 +57,20 @@ fn test_iterator_enumerate_count() {
}
#[test]
+fn test_iterator_enumerate_advance_by() {
+ let xs = [0, 1, 2, 3, 4, 5];
+ let mut it = xs.iter().enumerate();
+ assert_eq!(it.advance_by(0), Ok(()));
+ assert_eq!(it.next(), Some((0, &0)));
+ assert_eq!(it.advance_by(1), Ok(()));
+ assert_eq!(it.next(), Some((2, &2)));
+ assert_eq!(it.advance_by(2), Ok(()));
+ assert_eq!(it.next(), Some((5, &5)));
+ assert_eq!(it.advance_by(1), Err(NonZeroUsize::new(1).unwrap()));
+ assert_eq!(it.next(), None);
+}
+
+#[test]
fn test_iterator_enumerate_fold() {
let xs = [0, 1, 2, 3, 4, 5];
let mut it = xs.iter().enumerate();
diff --git a/library/core/tests/iter/adapters/flatten.rs b/library/core/tests/iter/adapters/flatten.rs
index 690fd0c21..91809c9e5 100644
--- a/library/core/tests/iter/adapters/flatten.rs
+++ b/library/core/tests/iter/adapters/flatten.rs
@@ -1,5 +1,7 @@
+use core::assert_eq;
use super::*;
use core::iter::*;
+use core::num::NonZeroUsize;
#[test]
fn test_iterator_flatten() {
@@ -61,19 +63,19 @@ fn test_flatten_try_folds() {
fn test_flatten_advance_by() {
let mut it = once(0..10).chain(once(10..30)).chain(once(30..40)).flatten();
- it.advance_by(5).unwrap();
+ assert_eq!(it.advance_by(5), Ok(()));
assert_eq!(it.next(), Some(5));
- it.advance_by(9).unwrap();
+ assert_eq!(it.advance_by(9), Ok(()));
assert_eq!(it.next(), Some(15));
- it.advance_back_by(4).unwrap();
+ assert_eq!(it.advance_back_by(4), Ok(()));
assert_eq!(it.next_back(), Some(35));
- it.advance_back_by(9).unwrap();
+ assert_eq!(it.advance_back_by(9), Ok(()));
assert_eq!(it.next_back(), Some(25));
- assert_eq!(it.advance_by(usize::MAX), Err(9));
- assert_eq!(it.advance_back_by(usize::MAX), Err(0));
- it.advance_by(0).unwrap();
- it.advance_back_by(0).unwrap();
+ assert_eq!(it.advance_by(usize::MAX), Err(NonZeroUsize::new(usize::MAX - 9).unwrap()));
+ assert_eq!(it.advance_back_by(usize::MAX), Err(NonZeroUsize::new(usize::MAX).unwrap()));
+ assert_eq!(it.advance_by(0), Ok(()));
+ assert_eq!(it.advance_back_by(0), Ok(()));
assert_eq!(it.size_hint(), (0, Some(0)));
}
@@ -174,19 +176,19 @@ fn test_flatten_count() {
let mut it = once(0..10).chain(once(10..30)).chain(once(30..40)).flatten();
assert_eq!(it.clone().count(), 40);
- it.advance_by(5).unwrap();
+ assert_eq!(it.advance_by(5), Ok(()));
assert_eq!(it.clone().count(), 35);
- it.advance_back_by(5).unwrap();
+ assert_eq!(it.advance_back_by(5), Ok(()));
assert_eq!(it.clone().count(), 30);
- it.advance_by(10).unwrap();
+ assert_eq!(it.advance_by(10), Ok(()));
assert_eq!(it.clone().count(), 20);
- it.advance_back_by(8).unwrap();
+ assert_eq!(it.advance_back_by(8), Ok(()));
assert_eq!(it.clone().count(), 12);
- it.advance_by(4).unwrap();
+ assert_eq!(it.advance_by(4), Ok(()));
assert_eq!(it.clone().count(), 8);
- it.advance_back_by(5).unwrap();
+ assert_eq!(it.advance_back_by(5), Ok(()));
assert_eq!(it.clone().count(), 3);
- it.advance_by(3).unwrap();
+ assert_eq!(it.advance_by(3), Ok(()));
assert_eq!(it.clone().count(), 0);
}
@@ -195,18 +197,18 @@ fn test_flatten_last() {
let mut it = once(0..10).chain(once(10..30)).chain(once(30..40)).flatten();
assert_eq!(it.clone().last(), Some(39));
- it.advance_by(5).unwrap(); // 5..40
+ assert_eq!(it.advance_by(5), Ok(())); // 5..40
assert_eq!(it.clone().last(), Some(39));
- it.advance_back_by(5).unwrap(); // 5..35
+ assert_eq!(it.advance_back_by(5), Ok(())); // 5..35
assert_eq!(it.clone().last(), Some(34));
- it.advance_by(10).unwrap(); // 15..35
+ assert_eq!(it.advance_by(10), Ok(())); // 15..35
assert_eq!(it.clone().last(), Some(34));
- it.advance_back_by(8).unwrap(); // 15..27
+ assert_eq!(it.advance_back_by(8), Ok(())); // 15..27
assert_eq!(it.clone().last(), Some(26));
- it.advance_by(4).unwrap(); // 19..27
+ assert_eq!(it.advance_by(4), Ok(())); // 19..27
assert_eq!(it.clone().last(), Some(26));
- it.advance_back_by(5).unwrap(); // 19..22
+ assert_eq!(it.advance_back_by(5), Ok(())); // 19..22
assert_eq!(it.clone().last(), Some(21));
- it.advance_by(3).unwrap(); // 22..22
+ assert_eq!(it.advance_by(3), Ok(())); // 22..22
assert_eq!(it.clone().last(), None);
}
diff --git a/library/core/tests/iter/adapters/skip.rs b/library/core/tests/iter/adapters/skip.rs
index 754641834..e3e88a84f 100644
--- a/library/core/tests/iter/adapters/skip.rs
+++ b/library/core/tests/iter/adapters/skip.rs
@@ -1,4 +1,5 @@
use core::iter::*;
+use core::num::NonZeroUsize;
use super::Unfuse;
@@ -74,11 +75,14 @@ fn test_iterator_skip_nth() {
#[test]
fn test_skip_advance_by() {
assert_eq!((0..0).skip(10).advance_by(0), Ok(()));
- assert_eq!((0..0).skip(10).advance_by(1), Err(0));
- assert_eq!((0u128..(usize::MAX as u128) + 1).skip(usize::MAX).advance_by(usize::MAX), Err(1));
- assert_eq!((0u128..u128::MAX).skip(usize::MAX).advance_by(1), Ok(()));
-
- assert_eq!((0..2).skip(1).advance_back_by(10), Err(1));
+ assert_eq!((0..0).skip(10).advance_by(1), Err(NonZeroUsize::new(1).unwrap()));
+ assert_eq!(
+ (0u128..(usize::MAX as u128) + 1).skip(usize::MAX - 10).advance_by(usize::MAX - 5),
+ Err(NonZeroUsize::new(usize::MAX - 16).unwrap())
+ );
+ assert_eq!((0u128..u128::MAX).skip(usize::MAX - 10).advance_by(20), Ok(()));
+
+ assert_eq!((0..2).skip(1).advance_back_by(10), Err(NonZeroUsize::new(9).unwrap()));
assert_eq!((0..0).skip(1).advance_back_by(0), Ok(()));
}
diff --git a/library/core/tests/iter/adapters/take.rs b/library/core/tests/iter/adapters/take.rs
index 3e26b43a2..3cad47c06 100644
--- a/library/core/tests/iter/adapters/take.rs
+++ b/library/core/tests/iter/adapters/take.rs
@@ -1,4 +1,5 @@
use core::iter::*;
+use core::num::NonZeroUsize;
#[test]
fn test_iterator_take() {
@@ -78,21 +79,21 @@ fn test_take_advance_by() {
let mut take = (0..10).take(3);
assert_eq!(take.advance_by(2), Ok(()));
assert_eq!(take.next(), Some(2));
- assert_eq!(take.advance_by(1), Err(0));
+ assert_eq!(take.advance_by(1), Err(NonZeroUsize::new(1).unwrap()));
assert_eq!((0..0).take(10).advance_by(0), Ok(()));
- assert_eq!((0..0).take(10).advance_by(1), Err(0));
- assert_eq!((0..10).take(4).advance_by(5), Err(4));
+ assert_eq!((0..0).take(10).advance_by(1), Err(NonZeroUsize::new(1).unwrap()));
+ assert_eq!((0..10).take(4).advance_by(5), Err(NonZeroUsize::new(1).unwrap()));
let mut take = (0..10).take(3);
assert_eq!(take.advance_back_by(2), Ok(()));
assert_eq!(take.next(), Some(0));
- assert_eq!(take.advance_back_by(1), Err(0));
+ assert_eq!(take.advance_back_by(1), Err(NonZeroUsize::new(1).unwrap()));
- assert_eq!((0..2).take(1).advance_back_by(10), Err(1));
- assert_eq!((0..0).take(1).advance_back_by(1), Err(0));
+ assert_eq!((0..2).take(1).advance_back_by(10), Err(NonZeroUsize::new(9).unwrap()));
+ assert_eq!((0..0).take(1).advance_back_by(1), Err(NonZeroUsize::new(1).unwrap()));
assert_eq!((0..0).take(1).advance_back_by(0), Ok(()));
- assert_eq!((0..usize::MAX).take(100).advance_back_by(usize::MAX), Err(100));
+ assert_eq!((0..usize::MAX).take(100).advance_back_by(usize::MAX), Err(NonZeroUsize::new(usize::MAX - 100).unwrap()));
}
#[test]
diff --git a/library/core/tests/iter/range.rs b/library/core/tests/iter/range.rs
index 0f91ffe2d..0a77ecddb 100644
--- a/library/core/tests/iter/range.rs
+++ b/library/core/tests/iter/range.rs
@@ -1,3 +1,4 @@
+use core::num::NonZeroUsize;
use super::*;
#[test]
@@ -287,25 +288,25 @@ fn test_range_step() {
#[test]
fn test_range_advance_by() {
let mut r = 0..usize::MAX;
- r.advance_by(0).unwrap();
- r.advance_back_by(0).unwrap();
+ assert_eq!(Ok(()), r.advance_by(0));
+ assert_eq!(Ok(()), r.advance_back_by(0));
assert_eq!(r.len(), usize::MAX);
- r.advance_by(1).unwrap();
- r.advance_back_by(1).unwrap();
+ assert_eq!(Ok(()), r.advance_by(1));
+ assert_eq!(Ok(()), r.advance_back_by(1));
assert_eq!((r.start, r.end), (1, usize::MAX - 1));
- assert_eq!(r.advance_by(usize::MAX), Err(usize::MAX - 2));
+ assert_eq!(Err(NonZeroUsize::new(2).unwrap()), r.advance_by(usize::MAX));
- r.advance_by(0).unwrap();
- r.advance_back_by(0).unwrap();
+ assert_eq!(Ok(()), r.advance_by(0));
+ assert_eq!(Ok(()), r.advance_back_by(0));
let mut r = 0u128..u128::MAX;
- r.advance_by(usize::MAX).unwrap();
- r.advance_back_by(usize::MAX).unwrap();
+ assert_eq!(Ok(()), r.advance_by(usize::MAX));
+ assert_eq!(Ok(()), r.advance_back_by(usize::MAX));
assert_eq!((r.start, r.end), (0u128 + usize::MAX as u128, u128::MAX - usize::MAX as u128));
}
diff --git a/library/core/tests/iter/traits/iterator.rs b/library/core/tests/iter/traits/iterator.rs
index 62566a950..9eebfb1f1 100644
--- a/library/core/tests/iter/traits/iterator.rs
+++ b/library/core/tests/iter/traits/iterator.rs
@@ -1,3 +1,5 @@
+use core::num::NonZeroUsize;
+
/// A wrapper struct that implements `Eq` and `Ord` based on the wrapped
/// integer modulo 3. Used to test that `Iterator::max` and `Iterator::min`
/// return the correct element if some of them are equal.
@@ -150,11 +152,11 @@ fn test_iterator_advance_by() {
let mut iter = v.iter();
assert_eq!(iter.advance_by(i), Ok(()));
assert_eq!(iter.next().unwrap(), &v[i]);
- assert_eq!(iter.advance_by(100), Err(v.len() - 1 - i));
+ assert_eq!(iter.advance_by(100), Err(NonZeroUsize::new(100 - (v.len() - 1 - i)).unwrap()));
}
assert_eq!(v.iter().advance_by(v.len()), Ok(()));
- assert_eq!(v.iter().advance_by(100), Err(v.len()));
+ assert_eq!(v.iter().advance_by(100), Err(NonZeroUsize::new(100 - v.len()).unwrap()));
}
#[test]
@@ -165,11 +167,11 @@ fn test_iterator_advance_back_by() {
let mut iter = v.iter();
assert_eq!(iter.advance_back_by(i), Ok(()));
assert_eq!(iter.next_back().unwrap(), &v[v.len() - 1 - i]);
- assert_eq!(iter.advance_back_by(100), Err(v.len() - 1 - i));
+ assert_eq!(iter.advance_back_by(100), Err(NonZeroUsize::new(100 - (v.len() - 1 - i)).unwrap()));
}
assert_eq!(v.iter().advance_back_by(v.len()), Ok(()));
- assert_eq!(v.iter().advance_back_by(100), Err(v.len()));
+ assert_eq!(v.iter().advance_back_by(100), Err(NonZeroUsize::new(100 - v.len()).unwrap()));
}
#[test]
@@ -180,11 +182,11 @@ fn test_iterator_rev_advance_back_by() {
let mut iter = v.iter().rev();
assert_eq!(iter.advance_back_by(i), Ok(()));
assert_eq!(iter.next_back().unwrap(), &v[i]);
- assert_eq!(iter.advance_back_by(100), Err(v.len() - 1 - i));
+ assert_eq!(iter.advance_back_by(100), Err(NonZeroUsize::new(100 - (v.len() - 1 - i)).unwrap()));
}
assert_eq!(v.iter().rev().advance_back_by(v.len()), Ok(()));
- assert_eq!(v.iter().rev().advance_back_by(100), Err(v.len()));
+ assert_eq!(v.iter().rev().advance_back_by(100), Err(NonZeroUsize::new(100 - v.len()).unwrap()));
}
#[test]
@@ -424,11 +426,11 @@ fn test_iterator_rev_advance_by() {
let mut iter = v.iter().rev();
assert_eq!(iter.advance_by(i), Ok(()));
assert_eq!(iter.next().unwrap(), &v[v.len() - 1 - i]);
- assert_eq!(iter.advance_by(100), Err(v.len() - 1 - i));
+ assert_eq!(iter.advance_by(100), Err(NonZeroUsize::new(100 - (v.len() - 1 - i)).unwrap()));
}
assert_eq!(v.iter().rev().advance_by(v.len()), Ok(()));
- assert_eq!(v.iter().rev().advance_by(100), Err(v.len()));
+ assert_eq!(v.iter().rev().advance_by(100), Err(NonZeroUsize::new(100 - v.len()).unwrap()));
}
#[test]
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index ccb7be68e..6cdafa411 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -91,8 +91,7 @@
#![feature(pointer_is_aligned)]
#![feature(portable_simd)]
#![feature(ptr_metadata)]
-#![feature(once_cell)]
-#![feature(option_result_contains)]
+#![feature(lazy_cell)]
#![feature(unsized_tuple_coercion)]
#![feature(const_option)]
#![feature(const_option_ext)]
diff --git a/library/core/tests/num/dec2flt/mod.rs b/library/core/tests/num/dec2flt/mod.rs
index a2b9bb551..874e0ec70 100644
--- a/library/core/tests/num/dec2flt/mod.rs
+++ b/library/core/tests/num/dec2flt/mod.rs
@@ -127,14 +127,3 @@ fn massive_exponent() {
assert_eq!(format!("1e-{max}000").parse(), Ok(0.0));
assert_eq!(format!("1e{max}000").parse(), Ok(f64::INFINITY));
}
-
-#[test]
-fn borderline_overflow() {
- let mut s = "0.".to_string();
- for _ in 0..375 {
- s.push('3');
- }
- // At the time of this writing, this returns Err(..), but this is a bug that should be fixed.
- // It makes no sense to enshrine that in a test, the important part is that it doesn't panic.
- let _ = s.parse::<f64>();
-}
diff --git a/library/core/tests/num/dec2flt/parse.rs b/library/core/tests/num/dec2flt/parse.rs
index edc77377d..4a5d24ba7 100644
--- a/library/core/tests/num/dec2flt/parse.rs
+++ b/library/core/tests/num/dec2flt/parse.rs
@@ -32,7 +32,7 @@ fn invalid_chars() {
}
fn parse_positive(s: &[u8]) -> Option<Number> {
- parse_number(s, false)
+ parse_number(s)
}
#[test]
diff --git a/library/core/tests/slice.rs b/library/core/tests/slice.rs
index 39559cdbb..88f54591b 100644
--- a/library/core/tests/slice.rs
+++ b/library/core/tests/slice.rs
@@ -1,6 +1,7 @@
use core::cell::Cell;
use core::cmp::Ordering;
use core::mem::MaybeUninit;
+use core::num::NonZeroUsize;
use core::result::Result::{Err, Ok};
use core::slice;
@@ -142,20 +143,20 @@ fn test_iterator_advance_by() {
for i in 0..=v.len() {
let mut iter = v.iter();
- iter.advance_by(i).unwrap();
+ assert_eq!(iter.advance_by(i), Ok(()));
assert_eq!(iter.as_slice(), &v[i..]);
}
let mut iter = v.iter();
- assert_eq!(iter.advance_by(v.len() + 1), Err(v.len()));
+ assert_eq!(iter.advance_by(v.len() + 1), Err(NonZeroUsize::new(1).unwrap()));
assert_eq!(iter.as_slice(), &[]);
let mut iter = v.iter();
- iter.advance_by(3).unwrap();
+ assert_eq!(iter.advance_by(3), Ok(()));
assert_eq!(iter.as_slice(), &v[3..]);
- iter.advance_by(2).unwrap();
+ assert_eq!(iter.advance_by(2), Ok(()));
assert_eq!(iter.as_slice(), &[]);
- iter.advance_by(0).unwrap();
+ assert_eq!(iter.advance_by(0), Ok(()));
}
#[test]
@@ -164,20 +165,20 @@ fn test_iterator_advance_back_by() {
for i in 0..=v.len() {
let mut iter = v.iter();
- iter.advance_back_by(i).unwrap();
+ assert_eq!(iter.advance_back_by(i), Ok(()));
assert_eq!(iter.as_slice(), &v[..v.len() - i]);
}
let mut iter = v.iter();
- assert_eq!(iter.advance_back_by(v.len() + 1), Err(v.len()));
+ assert_eq!(iter.advance_back_by(v.len() + 1), Err(NonZeroUsize::new(1).unwrap()));
assert_eq!(iter.as_slice(), &[]);
let mut iter = v.iter();
- iter.advance_back_by(3).unwrap();
+ assert_eq!(iter.advance_back_by(3), Ok(()));
assert_eq!(iter.as_slice(), &v[..v.len() - 3]);
- iter.advance_back_by(2).unwrap();
+ assert_eq!(iter.advance_back_by(2), Ok(()));
assert_eq!(iter.as_slice(), &[]);
- iter.advance_back_by(0).unwrap();
+ assert_eq!(iter.advance_back_by(0), Ok(()));
}
#[test]
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-10 10:57:46 +0000