library/core/test/iter add newlines between tests

Author: danii

library/core/tests/iter/adapters/chain.rs

@@ -23,6 +23,7 @@ fn test_iterator_chain() {
     }
     assert_eq!(i, expected.len());
 }
+
 #[test]
 fn test_iterator_chain_advance_by() {
     fn test_chain(xs: &[i32], ys: &[i32]) {
@@ -55,6 +56,7 @@ fn test_iterator_chain_advance_by() {
     test_chain(&[0, 1, 2, 3, 4, 5], &[]);
     test_chain(&[0, 1, 2, 3, 4, 5], &[30, 40, 50, 60]);
 }
+
 #[test]
 fn test_iterator_chain_advance_back_by() {
     fn test_chain(xs: &[i32], ys: &[i32]) {
@@ -87,6 +89,7 @@ fn test_iterator_chain_advance_back_by() {
     test_chain(&[0, 1, 2, 3, 4, 5], &[]);
     test_chain(&[0, 1, 2, 3, 4, 5], &[30, 40, 50, 60]);
 }
+
 #[test]
 fn test_iterator_chain_nth() {
     let xs = [0, 1, 2, 3, 4, 5];
@@ -102,6 +105,7 @@ fn test_iterator_chain_nth() {
     assert_eq!(it.nth(5), Some(&5));
     assert_eq!(it.next(), None);
 }
+
 #[test]
 fn test_iterator_chain_nth_back() {
     let xs = [0, 1, 2, 3, 4, 5];
@@ -117,6 +121,7 @@ fn test_iterator_chain_nth_back() {
     assert_eq!(it.nth_back(5), Some(&0));
     assert_eq!(it.next(), None);
 }
+
 #[test]
 fn test_iterator_chain_last() {
     let xs = [0, 1, 2, 3, 4, 5];
@@ -127,6 +132,7 @@ fn test_iterator_chain_last() {
     assert_eq!(ys.iter().chain(&zs).last(), Some(&60));
     assert_eq!(zs.iter().chain(&zs).last(), None);
 }
+
 #[test]
 fn test_iterator_chain_count() {
     let xs = [0, 1, 2, 3, 4, 5];
@@ -135,6 +141,7 @@ fn test_iterator_chain_count() {
     assert_eq!(xs.iter().chain(&ys).count(), 10);
     assert_eq!(zs.iter().chain(&ys).count(), 4);
 }
+
 #[test]
 fn test_iterator_chain_find() {
     let xs = [0, 1, 2, 3, 4, 5];
@@ -147,6 +154,7 @@ fn test_iterator_chain_find() {
     assert_eq!(iter.find(|&&i| i == 100), None);
     assert_eq!(iter.next(), None);
 }
+
 #[test]
 fn test_iterator_chain_size_hint() {
     // this chains an iterator of length 0 with an iterator of length 1,
@@ -161,6 +169,7 @@ fn test_iterator_chain_size_hint() {
     assert_eq!(iter.next_back(), Some(()));
     assert_eq!(iter.size_hint(), (0, Some(0)));
 }
+
 #[test]
 fn test_iterator_chain_unfused() {
     // Chain shouldn't be fused in its second iterator, depending on direction
@@ -174,6 +183,7 @@ fn test_iterator_chain_unfused() {
     iter.next_back().unwrap();
     iter.next_back().unwrap_none();
 }
+
 #[test]
 fn test_chain_fold() {
     let xs = [1, 2, 3];
@@ -185,6 +195,7 @@ fn test_chain_fold() {
     iter.fold((), |(), &elt| result.push(elt));
     assert_eq!(&[2, 3, 1, 2, 0], &result[..]);
 }
+
 #[test]
 fn test_chain_try_folds() {
     let c = || (0..10).chain(10..20);

library/core/tests/iter/adapters/cloned.rs

@@ -16,6 +16,7 @@ fn test_cloned() {
     assert_eq!(it.len(), 0);
     assert_eq!(it.next_back(), None);
 }
+
 #[test]
 fn test_cloned_side_effects() {
     let mut count = 0;
@@ -32,6 +33,7 @@ fn test_cloned_side_effects() {
     }
     assert_eq!(count, 2);
 }
+
 #[test]
 fn test_cloned_try_folds() {
     let a = [1, 2, 3, 4, 5, 6, 7, 8, 9];

library/core/tests/iter/adapters/enumerate.rs

@@ -8,6 +8,7 @@ fn test_iterator_enumerate() {
         assert_eq!(i, x);
     }
 }
+
 #[test]
 fn test_iterator_enumerate_nth() {
     let xs = [0, 1, 2, 3, 4, 5];
@@ -29,6 +30,7 @@ fn test_iterator_enumerate_nth() {
     assert_eq!(i, x);
     assert_eq!(i, 3);
 }
+
 #[test]
 fn test_iterator_enumerate_nth_back() {
     let xs = [0, 1, 2, 3, 4, 5];
@@ -46,11 +48,13 @@ fn test_iterator_enumerate_nth_back() {
     assert_eq!(i, x);
     assert_eq!(i, 2);
 }
+
 #[test]
 fn test_iterator_enumerate_count() {
     let xs = [0, 1, 2, 3, 4, 5];
     assert_eq!(xs.iter().enumerate().count(), 6);
 }
+
 #[test]
 fn test_iterator_enumerate_fold() {
     let xs = [0, 1, 2, 3, 4, 5];
@@ -74,6 +78,7 @@ fn test_iterator_enumerate_fold() {
     });
     assert_eq!(i, 0);
 }
+
 #[test]
 fn test_enumerate_try_folds() {
     let f = &|acc, (i, x)| usize::checked_add(2 * acc, x / (i + 1) + i);

library/core/tests/iter/adapters/filter.rs

@@ -5,6 +5,7 @@ fn test_iterator_filter_count() {
     let xs = [0, 1, 2, 3, 4, 5, 6, 7, 8];
     assert_eq!(xs.iter().filter(|&&x| x % 2 == 0).count(), 5);
 }
+
 #[test]
 fn test_iterator_filter_fold() {
     let xs = [0, 1, 2, 3, 4, 5, 6, 7, 8];
@@ -23,6 +24,7 @@ fn test_iterator_filter_fold() {
     });
     assert_eq!(i, 0);
 }
+
 #[test]
 fn test_filter_try_folds() {
     fn p(&x: &i32) -> bool {

library/core/tests/iter/adapters/filter_map.rs

@@ -5,6 +5,7 @@ fn test_filter_map() {
     let it = (0..).step_by(1).take(10).filter_map(|x| if x % 2 == 0 { Some(x * x) } else { None });
     assert_eq!(it.collect::<Vec<usize>>(), [0 * 0, 2 * 2, 4 * 4, 6 * 6, 8 * 8]);
 }
+
 #[test]
 fn test_filter_map_fold() {
     let xs = [0, 1, 2, 3, 4, 5, 6, 7, 8];

library/core/tests/iter/adapters/flat_map.rs

@@ -12,6 +12,7 @@ fn test_iterator_flat_map() {
     }
     assert_eq!(i, ys.len());
 }
+
 #[test]
 fn test_iterator_flat_map_fold() {
     let xs = [0, 3, 6];
@@ -34,6 +35,7 @@ fn test_iterator_flat_map_fold() {
     });
     assert_eq!(i, 0);
 }
+
 #[test]
 fn test_flat_map_try_folds() {
     let f = &|acc, x| i32::checked_add(acc * 2 / 3, x);

library/core/tests/iter/adapters/flatten.rs

@@ -13,6 +13,7 @@ fn test_iterator_flatten() {
     }
     assert_eq!(i, ys.len());
 }
+
 #[test]
 fn test_iterator_flatten_fold() {
     let xs = [0, 3, 6];
@@ -35,6 +36,7 @@ fn test_iterator_flatten_fold() {
     });
     assert_eq!(i, 0);
 }
+
 #[test]
 fn test_flatten_try_folds() {
     let f = &|acc, x| i32::checked_add(acc * 2 / 3, x);
@@ -52,6 +54,7 @@ fn test_flatten_try_folds() {
     assert_eq!(iter.try_rfold(0, i8::checked_add), None);
     assert_eq!(iter.next_back(), Some(35));
 }
+
 #[test]
 fn test_flatten_non_fused_outer() {
     let mut iter = NonFused::new(once(0..2)).flatten();
@@ -60,6 +63,7 @@ fn test_flatten_non_fused_outer() {
     assert_eq!(iter.next(), Some(0));
     assert_eq!(iter.next(), None);
 }
+
 #[test]
 fn test_flatten_non_fused_inner() {
     let mut iter = once(0..1).chain(once(1..3)).flat_map(NonFused::new);

library/core/tests/iter/adapters/fuse.rs

@@ -11,6 +11,7 @@ fn test_fuse_nth() {
     assert_eq!(it.nth(2), None);
     assert_eq!(it.len(), 0);
 }
+
 #[test]
 fn test_fuse_last() {
     let xs = [0, 1, 2];
@@ -19,6 +20,7 @@ fn test_fuse_last() {
     assert_eq!(it.len(), 3);
     assert_eq!(it.last(), Some(&2));
 }
+
 #[test]
 fn test_fuse_count() {
     let xs = [0, 1, 2];
@@ -28,6 +30,7 @@ fn test_fuse_count() {
     assert_eq!(it.count(), 3);
     // Can't check len now because count consumes.
 }
+
 #[test]
 fn test_fuse_fold() {
     let xs = [0, 1, 2];

library/core/tests/iter/adapters/inspect.rs

@@ -10,6 +10,7 @@ fn test_inspect() {
     assert_eq!(n, xs.len());
     assert_eq!(&xs[..], &ys[..]);
 }
+
 #[test]
 fn test_inspect_fold() {
     let xs = [1, 2, 3, 4];

library/core/tests/iter/adapters/intersperse.rs

@@ -17,6 +17,7 @@ fn test_intersperse() {
     let mut it = ys[..0].iter().map(|x| *x).intersperse(1);
     assert!(it.next() == None);
 }
+
 #[test]
 fn test_intersperse_size_hint() {
     let iter = std::iter::empty::<i32>().intersperse(0);
@@ -33,6 +34,7 @@ fn test_intersperse_size_hint() {
 
     assert_eq!([].iter().intersperse(&()).size_hint(), (0, Some(0)));
 }
+
 #[test]
 fn test_fold_specialization_intersperse() {
     let mut iter = (1..2).intersperse(0);
@@ -44,6 +46,7 @@ fn test_fold_specialization_intersperse() {
     let mut iter = (1..4).intersperse(0);
     iter.clone().for_each(|x| assert_eq!(Some(x), iter.next()));
 }
+
 #[test]
 fn test_try_fold_specialization_intersperse_ok() {
     let mut iter = (1..2).intersperse(0);
@@ -64,6 +67,7 @@ fn test_try_fold_specialization_intersperse_ok() {
         Some(())
     });
 }
+
 #[test]
 fn test_intersperse_with() {
     #[derive(PartialEq, Debug)]
@@ -84,6 +88,7 @@ fn test_intersperse_with() {
     let r = (0..3).intersperse_with(separator).collect::<Vec<_>>();
     assert_eq!(r, vec![0, 200, 1, 400, 2]);
 }
+
 #[test]
 fn test_intersperse_fold() {
     let v = (1..4).intersperse(9).fold(Vec::new(), |mut acc, x| {
@@ -112,6 +117,7 @@ fn test_intersperse_fold() {
     let v = NoneAtStart(0).intersperse(1000).fold(0, |a, b| a + b);
     assert_eq!(v, 0);
 }
+
 #[test]
 fn test_intersperse_collect_string() {
     let contents = vec![1, 2, 3];