1 files changed, 37 insertions, 15 deletions

diff --git a/vendor/fallible-iterator/src/test.rs b/vendor/fallible-iterator/src/test.rs
index f7627c4a3..218c6929f 100644
--- a/vendor/fallible-iterator/src/test.rs
+++ b/vendor/fallible-iterator/src/test.rs
@@ -1,7 +1,7 @@
-use core::iter;
-use core::ops::Range;
+use alloc::{vec, vec::Vec};
+use core::{iter, ops::Range};
 
-use super::{convert, FallibleIterator, Vec};
+use super::{convert, FallibleIterator, IntoFallible};
 
 #[test]
 fn all() {
@@ -190,6 +190,8 @@ fn last() {
 #[test]
 fn map() {
     let it = convert(vec![0, 1, 2, 3, 4].into_iter().map(Ok::<u32, ()>)).map(|n| Ok(n * 2));
+    fn assert_debug(_: &impl core::fmt::Debug) {}
+    assert_debug(&it);
     assert_eq!(it.clone().collect::<Vec<_>>().unwrap(), [0, 2, 4, 6, 8]);
     assert_eq!(it.rev().collect::<Vec<_>>().unwrap(), [8, 6, 4, 2, 0]);
 
@@ -241,8 +243,7 @@ fn max_by_key() {
     // Exercise failure both on the first item, and later.
     assert_eq!(it.clone().max_by_key(|&i| Err::<i32, _>(i)), Err(0));
     assert_eq!(
-        it.clone()
-            .max_by_key(|&i| if i > 0 { Err(i) } else { Ok(-i) }),
+        it.max_by_key(|&i| if i > 0 { Err(i) } else { Ok(-i) }),
         Err(3)
     );
 }
@@ -266,8 +267,7 @@ fn min_by_key() {
     // Exercise failure both on the first item, and later.
     assert_eq!(it.clone().min_by_key(|&i| Err::<i32, _>(i)), Err(0));
     assert_eq!(
-        it.clone()
-            .min_by_key(|&i| if i > 0 { Err(i) } else { Ok(-i) }),
+        it.min_by_key(|&i| if i > 0 { Err(i) } else { Ok(-i) }),
         Err(3)
     );
 }
@@ -304,15 +304,14 @@ fn position() {
     assert_eq!(it.position(|n| Ok(n == 3)).unwrap(), Some(0));
     assert_eq!(it.position(|n| Ok(n == 5)).unwrap(), None);
 
-    let it = convert(vec![1, 2, 3, 4].into_iter().map(Ok::<i32, i32>));
+    let mut it = convert(vec![1, 2, 3, 4].into_iter().map(Ok::<i32, i32>));
     assert_eq!(
         it.clone()
             .position(|n| if n == 3 { Err(42) } else { Ok(n == 2) }),
         Ok(Some(1))
     );
     assert_eq!(
-        it.clone()
-            .position(|n| if n == 3 { Err(42) } else { Ok(n == 4) }),
+        it.position(|n| if n == 3 { Err(42) } else { Ok(n == 4) }),
         Err(42)
     );
 }
@@ -335,7 +334,7 @@ fn skip() {
     let it = convert(vec![1, 2, 3, 4].into_iter().map(Ok::<i32, ()>));
     assert_eq!(it.clone().skip(0).collect::<Vec<_>>(), Ok(vec![1, 2, 3, 4]));
     assert_eq!(it.clone().skip(2).collect::<Vec<_>>(), Ok(vec![3, 4]));
-    assert_eq!(it.clone().skip(4).collect::<Vec<_>>(), Ok(vec![]));
+    assert_eq!(it.skip(4).collect::<Vec<_>>(), Ok(vec![]));
 }
 
 #[test]
@@ -350,7 +349,7 @@ fn skip_while() {
         Ok(vec![3, 4, 1])
     );
     assert_eq!(
-        it.clone().skip_while(|x| Ok(*x < 5)).collect::<Vec<_>>(),
+        it.skip_while(|x| Ok(*x < 5)).collect::<Vec<_>>(),
         Ok(vec![])
     );
 }
@@ -384,7 +383,7 @@ fn take_while() {
         Ok(vec![0, 1])
     );
     assert_eq!(
-        it.clone().take_while(|x| Ok(*x < 4)).collect::<Vec<_>>(),
+        it.take_while(|x| Ok(*x < 4)).collect::<Vec<_>>(),
         Ok(vec![0, 1, 2, 3, 0])
     );
 }
@@ -411,7 +410,10 @@ fn flatten() {
 #[test]
 fn inspect() {
     let mut buf = vec![];
-    let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).inspect(|v| Ok(buf.push(*v)));
+    let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).inspect(|&v| {
+        buf.push(v);
+        Ok(())
+    });
     it.count().unwrap();
     assert_eq!(buf, vec![0, 1, 2, 3]);
 }
@@ -451,5 +453,25 @@ fn unzip() {
 #[test]
 fn cycle() {
     let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).cycle();
-    assert_eq!(it.take(6).clone().collect::<Vec<_>>(), Ok(vec![0, 1, 2, 3, 0, 1]));
+    assert_eq!(it.take(6).collect::<Vec<_>>(), Ok(vec![0, 1, 2, 3, 0, 1]));
+}
+
+#[test]
+fn unwrap() {
+    let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).unwrap();
+    assert_eq!(it.collect::<Vec<_>>(), vec![0, 1, 2, 3]);
+}
+
+#[test]
+#[should_panic]
+fn unwrap_panic() {
+    let _ = convert(vec![Ok(0), Err(())].into_iter())
+        .unwrap()
+        .collect::<Vec<_>>();
+}
+
+#[test]
+fn wrap_std_iter_into_fallible() {
+    let it = IntoFallible::from(vec![0, 1, 2, 3].into_iter());
+    assert_eq!(it.collect::<Vec<_>>().unwrap(), vec![0, 1, 2, 3]);
 }