5 fn test_iterator_chain() {
6 let xs = [0, 1, 2, 3, 4, 5];
7 let ys = [30, 40, 50, 60];
8 let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
9 let it = xs.iter().chain(&ys);
12 assert_eq!(x, expected[i]);
15 assert_eq!(i, expected.len());
17 let ys = (30..).step_by(10).take(4);
18 let it = xs.iter().cloned().chain(ys);
21 assert_eq!(x, expected[i]);
24 assert_eq!(i, expected.len());
28 fn test_iterator_chain_advance_by() {
29 fn test_chain(xs: &[i32], ys: &[i32]) {
30 let len = xs.len() + ys.len();
32 for i in 0..xs.len() {
33 let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
34 iter.advance_by(i).unwrap();
35 assert_eq!(iter.next(), Some(&xs[i]));
36 assert_eq!(iter.advance_by(100), Err(len - i - 1));
39 for i in 0..ys.len() {
40 let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
41 iter.advance_by(xs.len() + i).unwrap();
42 assert_eq!(iter.next(), Some(&ys[i]));
43 assert_eq!(iter.advance_by(100), Err(ys.len() - i - 1));
46 let mut iter = xs.iter().chain(ys);
47 iter.advance_by(len).unwrap();
48 assert_eq!(iter.next(), None);
50 let mut iter = xs.iter().chain(ys);
51 assert_eq!(iter.advance_by(len + 1), Err(len));
55 test_chain(&[], &[0, 1, 2, 3, 4, 5]);
56 test_chain(&[0, 1, 2, 3, 4, 5], &[]);
57 test_chain(&[0, 1, 2, 3, 4, 5], &[30, 40, 50, 60]);
61 fn test_iterator_chain_advance_back_by() {
62 fn test_chain(xs: &[i32], ys: &[i32]) {
63 let len = xs.len() + ys.len();
65 for i in 0..ys.len() {
66 let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
67 iter.advance_back_by(i).unwrap();
68 assert_eq!(iter.next_back(), Some(&ys[ys.len() - i - 1]));
69 assert_eq!(iter.advance_back_by(100), Err(len - i - 1));
72 for i in 0..xs.len() {
73 let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
74 iter.advance_back_by(ys.len() + i).unwrap();
75 assert_eq!(iter.next_back(), Some(&xs[xs.len() - i - 1]));
76 assert_eq!(iter.advance_back_by(100), Err(xs.len() - i - 1));
79 let mut iter = xs.iter().chain(ys);
80 iter.advance_back_by(len).unwrap();
81 assert_eq!(iter.next_back(), None);
83 let mut iter = xs.iter().chain(ys);
84 assert_eq!(iter.advance_back_by(len + 1), Err(len));
88 test_chain(&[], &[0, 1, 2, 3, 4, 5]);
89 test_chain(&[0, 1, 2, 3, 4, 5], &[]);
90 test_chain(&[0, 1, 2, 3, 4, 5], &[30, 40, 50, 60]);
94 fn test_iterator_chain_nth() {
95 let xs = [0, 1, 2, 3, 4, 5];
96 let ys = [30, 40, 50, 60];
98 let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
99 for (i, x) in expected.iter().enumerate() {
100 assert_eq!(Some(x), xs.iter().chain(&ys).nth(i));
102 assert_eq!(zs.iter().chain(&xs).nth(0), Some(&0));
104 let mut it = xs.iter().chain(&zs);
105 assert_eq!(it.nth(5), Some(&5));
106 assert_eq!(it.next(), None);
110 fn test_iterator_chain_nth_back() {
111 let xs = [0, 1, 2, 3, 4, 5];
112 let ys = [30, 40, 50, 60];
114 let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
115 for (i, x) in expected.iter().rev().enumerate() {
116 assert_eq!(Some(x), xs.iter().chain(&ys).nth_back(i));
118 assert_eq!(zs.iter().chain(&xs).nth_back(0), Some(&5));
120 let mut it = xs.iter().chain(&zs);
121 assert_eq!(it.nth_back(5), Some(&0));
122 assert_eq!(it.next(), None);
126 fn test_iterator_chain_last() {
127 let xs = [0, 1, 2, 3, 4, 5];
128 let ys = [30, 40, 50, 60];
130 assert_eq!(xs.iter().chain(&ys).last(), Some(&60));
131 assert_eq!(zs.iter().chain(&ys).last(), Some(&60));
132 assert_eq!(ys.iter().chain(&zs).last(), Some(&60));
133 assert_eq!(zs.iter().chain(&zs).last(), None);
137 fn test_iterator_chain_count() {
138 let xs = [0, 1, 2, 3, 4, 5];
139 let ys = [30, 40, 50, 60];
141 assert_eq!(xs.iter().chain(&ys).count(), 10);
142 assert_eq!(zs.iter().chain(&ys).count(), 4);
146 fn test_iterator_chain_find() {
147 let xs = [0, 1, 2, 3, 4, 5];
148 let ys = [30, 40, 50, 60];
149 let mut iter = xs.iter().chain(&ys);
150 assert_eq!(iter.find(|&&i| i == 4), Some(&4));
151 assert_eq!(iter.next(), Some(&5));
152 assert_eq!(iter.find(|&&i| i == 40), Some(&40));
153 assert_eq!(iter.next(), Some(&50));
154 assert_eq!(iter.find(|&&i| i == 100), None);
155 assert_eq!(iter.next(), None);
159 fn test_iterator_chain_size_hint() {
160 // this chains an iterator of length 0 with an iterator of length 1,
161 // so after calling `.next()` once, the iterator is empty and the
162 // state is `ChainState::Back`. `.size_hint()` should now disregard
163 // the size hint of the left iterator
164 let mut iter = Toggle { is_empty: true }.chain(once(()));
165 assert_eq!(iter.next(), Some(()));
166 assert_eq!(iter.size_hint(), (0, Some(0)));
168 let mut iter = once(()).chain(Toggle { is_empty: true });
169 assert_eq!(iter.next_back(), Some(()));
170 assert_eq!(iter.size_hint(), (0, Some(0)));
174 fn test_iterator_chain_unfused() {
175 // Chain shouldn't be fused in its second iterator, depending on direction
176 let mut iter = NonFused::new(empty()).chain(Toggle { is_empty: true });
177 assert!(iter.next().is_none());
178 assert!(iter.next().is_some());
179 assert!(iter.next().is_none());
181 let mut iter = Toggle { is_empty: true }.chain(NonFused::new(empty()));
182 assert!(iter.next_back().is_none());
183 assert!(iter.next_back().is_some());
184 assert!(iter.next_back().is_none());
188 fn test_chain_fold() {
192 let mut iter = xs.iter().chain(&ys);
194 let mut result = Vec::new();
195 iter.fold((), |(), &elt| result.push(elt));
196 assert_eq!(&[2, 3, 1, 2, 0], &result[..]);
200 fn test_chain_try_folds() {
201 let c = || (0..10).chain(10..20);
203 let f = &|acc, x| i32::checked_add(2 * acc, x);
204 assert_eq!(c().try_fold(7, f), (0..20).try_fold(7, f));
205 assert_eq!(c().try_rfold(7, f), (0..20).rev().try_fold(7, f));
208 assert_eq!(iter.position(|x| x == 5), Some(5));
209 assert_eq!(iter.next(), Some(6), "stopped in front, state Both");
210 assert_eq!(iter.position(|x| x == 13), Some(6));
211 assert_eq!(iter.next(), Some(14), "stopped in back, state Back");
212 assert_eq!(iter.try_fold(0, |acc, x| Some(acc + x)), Some((15..20).sum()));
214 let mut iter = c().rev(); // use rev to access try_rfold
215 assert_eq!(iter.position(|x| x == 15), Some(4));
216 assert_eq!(iter.next(), Some(14), "stopped in back, state Both");
217 assert_eq!(iter.position(|x| x == 5), Some(8));
218 assert_eq!(iter.next(), Some(4), "stopped in front, state Front");
219 assert_eq!(iter.try_fold(0, |acc, x| Some(acc + x)), Some((0..4).sum()));
222 iter.by_ref().rev().nth(14); // skip the last 15, ending in state Front
223 assert_eq!(iter.try_fold(7, f), (0..5).try_fold(7, f));
226 iter.nth(14); // skip the first 15, ending in state Back
227 assert_eq!(iter.try_rfold(7, f), (15..20).try_rfold(7, f));
231 fn test_double_ended_chain() {
232 let xs = [1, 2, 3, 4, 5];
234 let mut it = xs.iter().chain(&ys).rev();
235 assert_eq!(it.next().unwrap(), &11);
236 assert_eq!(it.next().unwrap(), &9);
237 assert_eq!(it.next_back().unwrap(), &1);
238 assert_eq!(it.next_back().unwrap(), &2);
239 assert_eq!(it.next_back().unwrap(), &3);
240 assert_eq!(it.next_back().unwrap(), &4);
241 assert_eq!(it.next_back().unwrap(), &5);
242 assert_eq!(it.next_back().unwrap(), &7);
243 assert_eq!(it.next_back(), None);
245 // test that .chain() is well behaved with an unfused iterator
246 struct CrazyIterator(bool);
248 fn new() -> CrazyIterator {
252 impl Iterator for CrazyIterator {
254 fn next(&mut self) -> Option<i32> {
264 impl DoubleEndedIterator for CrazyIterator {
265 fn next_back(&mut self) -> Option<i32> {
270 assert_eq!(CrazyIterator::new().chain(0..10).rev().last(), Some(0));
271 assert!((0..10).chain(CrazyIterator::new()).rev().any(|i| i == 0));