vendor/itertools/tests/test_std.rs

   1
   2 #[macro_use] extern crate itertools as it;
   3 extern crate permutohedron;
   4
   5 use it::Itertools;
   6 use it::multizip;
   7 use it::multipeek;
   8 use it::free::rciter;
   9 use it::free::put_back_n;
  10 use it::FoldWhile;
  11 use it::cloned;
  12
  13 #[test]
  14 fn product3() {
  15     let prod = iproduct!(0..3, 0..2, 0..2);
  16     assert_eq!(prod.size_hint(), (12, Some(12)));
  17     let v = prod.collect_vec();
  18     for i in 0..3 {
  19         for j in 0..2 {
  20             for k in 0..2 {
  21                 assert!((i, j, k) == v[(i * 2 * 2 + j * 2 + k) as usize]);
  22             }
  23         }
  24     }
  25     for (_, _, _, _) in iproduct!(0..3, 0..2, 0..2, 0..3) {
  26         /* test compiles */
  27     }
  28 }
  29
  30 #[test]
  31 fn interleave_shortest() {
  32     let v0: Vec<i32> = vec![0, 2, 4];
  33     let v1: Vec<i32> = vec![1, 3, 5, 7];
  34     let it = v0.into_iter().interleave_shortest(v1.into_iter());
  35     assert_eq!(it.size_hint(), (6, Some(6)));
  36     assert_eq!(it.collect_vec(), vec![0, 1, 2, 3, 4, 5]);
  37
  38     let v0: Vec<i32> = vec![0, 2, 4, 6, 8];
  39     let v1: Vec<i32> = vec![1, 3, 5];
  40     let it = v0.into_iter().interleave_shortest(v1.into_iter());
  41     assert_eq!(it.size_hint(), (7, Some(7)));
  42     assert_eq!(it.collect_vec(), vec![0, 1, 2, 3, 4, 5, 6]);
  43
  44     let i0 = ::std::iter::repeat(0);
  45     let v1: Vec<_> = vec![1, 3, 5];
  46     let it = i0.interleave_shortest(v1.into_iter());
  47     assert_eq!(it.size_hint(), (7, Some(7)));
  48
  49     let v0: Vec<_> = vec![0, 2, 4];
  50     let i1 = ::std::iter::repeat(1);
  51     let it = v0.into_iter().interleave_shortest(i1);
  52     assert_eq!(it.size_hint(), (6, Some(6)));
  53 }
  54
  55
  56 #[test]
  57 fn unique_by() {
  58     let xs = ["aaa", "bbbbb", "aa", "ccc", "bbbb", "aaaaa", "cccc"];
  59     let ys = ["aaa", "bbbbb", "ccc"];
  60     it::assert_equal(ys.iter(), xs.iter().unique_by(|x| x[..2].to_string()));
  61 }
  62
  63 #[test]
  64 fn unique() {
  65     let xs = [0, 1, 2, 3, 2, 1, 3];
  66     let ys = [0, 1, 2, 3];
  67     it::assert_equal(ys.iter(), xs.iter().unique());
  68     let xs = [0, 1];
  69     let ys = [0, 1];
  70     it::assert_equal(ys.iter(), xs.iter().unique());
  71 }
  72
  73 #[test]
  74 fn intersperse() {
  75     let xs = ["a", "", "b", "c"];
  76     let v: Vec<&str> = xs.iter().map(|x| x.clone()).intersperse(", ").collect();
  77     let text: String = v.concat();
  78     assert_eq!(text, "a, , b, c".to_string());
  79
  80     let ys = [0, 1, 2, 3];
  81     let mut it = ys[..0].iter().map(|x| *x).intersperse(1);
  82     assert!(it.next() == None);
  83 }
  84
  85 #[test]
  86 fn dedup() {
  87     let xs = [0, 1, 1, 1, 2, 1, 3, 3];
  88     let ys = [0, 1, 2, 1, 3];
  89     it::assert_equal(ys.iter(), xs.iter().dedup());
  90     let xs = [0, 0, 0, 0, 0];
  91     let ys = [0];
  92     it::assert_equal(ys.iter(), xs.iter().dedup());
  93
  94     let xs = [0, 1, 1, 1, 2, 1, 3, 3];
  95     let ys = [0, 1, 2, 1, 3];
  96     let mut xs_d = Vec::new();
  97     xs.iter().dedup().fold((), |(), &elt| xs_d.push(elt));
  98     assert_eq!(&xs_d, &ys);
  99 }
 100
 101 #[test]
 102 fn all_equal() {
 103     assert!(!"AABBCCC".chars().all_equal());
 104     assert!("AAAAAAA".chars().all_equal());
 105     for (_key, mut sub) in &"AABBCCC".chars().group_by(|&x| x) {
 106         assert!(sub.all_equal());
 107     }
 108 }
 109
 110 #[test]
 111 fn test_put_back_n() {
 112     let xs = [0, 1, 1, 1, 2, 1, 3, 3];
 113     let mut pb = put_back_n(xs.iter().cloned());
 114     pb.next();
 115     pb.next();
 116     pb.put_back(1);
 117     pb.put_back(0);
 118     it::assert_equal(pb, xs.iter().cloned());
 119 }
 120
 121 #[test]
 122 fn tee() {
 123     let xs  = [0, 1, 2, 3];
 124     let (mut t1, mut t2) = xs.iter().cloned().tee();
 125     assert_eq!(t1.next(), Some(0));
 126     assert_eq!(t2.next(), Some(0));
 127     assert_eq!(t1.next(), Some(1));
 128     assert_eq!(t1.next(), Some(2));
 129     assert_eq!(t1.next(), Some(3));
 130     assert_eq!(t1.next(), None);
 131     assert_eq!(t2.next(), Some(1));
 132     assert_eq!(t2.next(), Some(2));
 133     assert_eq!(t1.next(), None);
 134     assert_eq!(t2.next(), Some(3));
 135     assert_eq!(t2.next(), None);
 136     assert_eq!(t1.next(), None);
 137     assert_eq!(t2.next(), None);
 138
 139     let (t1, t2) = xs.iter().cloned().tee();
 140     it::assert_equal(t1, xs.iter().cloned());
 141     it::assert_equal(t2, xs.iter().cloned());
 142
 143     let (t1, t2) = xs.iter().cloned().tee();
 144     it::assert_equal(t1.zip(t2), xs.iter().cloned().zip(xs.iter().cloned()));
 145 }
 146
 147
 148 #[test]
 149 fn test_rciter() {
 150     let xs = [0, 1, 1, 1, 2, 1, 3, 5, 6];
 151
 152     let mut r1 = rciter(xs.iter().cloned());
 153     let mut r2 = r1.clone();
 154     assert_eq!(r1.next(), Some(0));
 155     assert_eq!(r2.next(), Some(1));
 156     let mut z = r1.zip(r2);
 157     assert_eq!(z.next(), Some((1, 1)));
 158     assert_eq!(z.next(), Some((2, 1)));
 159     assert_eq!(z.next(), Some((3, 5)));
 160     assert_eq!(z.next(), None);
 161
 162     // test intoiterator
 163     let r1 = rciter(0..5);
 164     let mut z = izip!(&r1, r1);
 165     assert_eq!(z.next(), Some((0, 1)));
 166 }
 167
 168 #[allow(deprecated)]
 169 #[test]
 170 fn trait_pointers() {
 171     struct ByRef<'r, I: ?Sized>(&'r mut I) where I: 'r;
 172
 173     impl<'r, X, I: ?Sized> Iterator for ByRef<'r, I> where
 174         I: 'r + Iterator<Item=X>
 175     {
 176         type Item = X;
 177         fn next(&mut self) -> Option<X>
 178         {
 179             self.0.next()
 180         }
 181     }
 182
 183     let mut it = Box::new(0..10) as Box<Iterator<Item=i32>>;
 184     assert_eq!(it.next(), Some(0));
 185
 186     {
 187         /* make sure foreach works on non-Sized */
 188         let jt: &mut Iterator<Item = i32> = &mut *it;
 189         assert_eq!(jt.next(), Some(1));
 190
 191         {
 192             let mut r = ByRef(jt);
 193             assert_eq!(r.next(), Some(2));
 194         }
 195
 196         assert_eq!(jt.find_position(|x| *x == 4), Some((1, 4)));
 197         jt.foreach(|_| ());
 198     }
 199 }
 200
 201 #[test]
 202 fn merge_by() {
 203     let odd : Vec<(u32, &str)> = vec![(1, "hello"), (3, "world"), (5, "!")];
 204     let even = vec![(2, "foo"), (4, "bar"), (6, "baz")];
 205     let expected = vec![(1, "hello"), (2, "foo"), (3, "world"), (4, "bar"), (5, "!"), (6, "baz")];
 206     let results = odd.iter().merge_by(even.iter(), |a, b| a.0 <= b.0);
 207     it::assert_equal(results, expected.iter());
 208 }
 209
 210 #[test]
 211 fn merge_by_btree() {
 212     use std::collections::BTreeMap;
 213     let mut bt1 = BTreeMap::new();
 214     bt1.insert("hello", 1);
 215     bt1.insert("world", 3);
 216     let mut bt2 = BTreeMap::new();
 217     bt2.insert("foo", 2);
 218     bt2.insert("bar", 4);
 219     let results = bt1.into_iter().merge_by(bt2.into_iter(), |a, b| a.0 <= b.0 );
 220     let expected = vec![("bar", 4), ("foo", 2), ("hello", 1), ("world", 3)];
 221     it::assert_equal(results, expected.into_iter());
 222 }
 223
 224 #[allow(deprecated)]
 225 #[test]
 226 fn kmerge() {
 227     let its = (0..4).map(|s| (s..10).step(4));
 228
 229     it::assert_equal(its.kmerge(), 0..10);
 230 }
 231
 232 #[allow(deprecated)]
 233 #[test]
 234 fn kmerge_2() {
 235     let its = vec![3, 2, 1, 0].into_iter().map(|s| (s..10).step(4));
 236
 237     it::assert_equal(its.kmerge(), 0..10);
 238 }
 239
 240 #[test]
 241 fn kmerge_empty() {
 242     let its = (0..4).map(|_| 0..0);
 243     assert_eq!(its.kmerge().next(), None);
 244 }
 245
 246 #[test]
 247 fn kmerge_size_hint() {
 248     let its = (0..5).map(|_| (0..10));
 249     assert_eq!(its.kmerge().size_hint(), (50, Some(50)));
 250 }
 251
 252 #[test]
 253 fn kmerge_empty_size_hint() {
 254     let its = (0..5).map(|_| (0..0));
 255     assert_eq!(its.kmerge().size_hint(), (0, Some(0)));
 256 }
 257
 258 #[test]
 259 fn join() {
 260     let many = [1, 2, 3];
 261     let one  = [1];
 262     let none: Vec<i32> = vec![];
 263
 264     assert_eq!(many.iter().join(", "), "1, 2, 3");
 265     assert_eq!( one.iter().join(", "), "1");
 266     assert_eq!(none.iter().join(", "), "");
 267 }
 268
 269 #[test]
 270 fn sorted_by() {
 271     let sc = [3, 4, 1, 2].iter().cloned().sorted_by(|&a, &b| {
 272         a.cmp(&b)
 273     });
 274     it::assert_equal(sc, vec![1, 2, 3, 4]);
 275
 276     let v = (0..5).sorted_by(|&a, &b| a.cmp(&b).reverse());
 277     it::assert_equal(v, vec![4, 3, 2, 1, 0]);
 278 }
 279
 280 #[test]
 281 fn sorted_by_key() {
 282     let sc = [3, 4, 1, 2].iter().cloned().sorted_by_key(|&x| x);
 283     it::assert_equal(sc, vec![1, 2, 3, 4]);
 284
 285     let v = (0..5).sorted_by_key(|&x| -x);
 286     it::assert_equal(v, vec![4, 3, 2, 1, 0]);
 287 }
 288
 289 #[test]
 290 fn test_multipeek() {
 291     let nums = vec![1u8,2,3,4,5];
 292
 293     let mp = multipeek(nums.iter().map(|&x| x));
 294     assert_eq!(nums, mp.collect::<Vec<_>>());
 295
 296     let mut mp = multipeek(nums.iter().map(|&x| x));
 297     assert_eq!(mp.peek(), Some(&1));
 298     assert_eq!(mp.next(), Some(1));
 299     assert_eq!(mp.peek(), Some(&2));
 300     assert_eq!(mp.peek(), Some(&3));
 301     assert_eq!(mp.next(), Some(2));
 302     assert_eq!(mp.peek(), Some(&3));
 303     assert_eq!(mp.peek(), Some(&4));
 304     assert_eq!(mp.peek(), Some(&5));
 305     assert_eq!(mp.peek(), None);
 306     assert_eq!(mp.next(), Some(3));
 307     assert_eq!(mp.next(), Some(4));
 308     assert_eq!(mp.peek(), Some(&5));
 309     assert_eq!(mp.peek(), None);
 310     assert_eq!(mp.next(), Some(5));
 311     assert_eq!(mp.next(), None);
 312     assert_eq!(mp.peek(), None);
 313
 314 }
 315
 316 #[test]
 317 fn test_multipeek_reset() {
 318     let data = [1, 2, 3, 4];
 319
 320     let mut mp = multipeek(cloned(&data));
 321     assert_eq!(mp.peek(), Some(&1));
 322     assert_eq!(mp.next(), Some(1));
 323     assert_eq!(mp.peek(), Some(&2));
 324     assert_eq!(mp.peek(), Some(&3));
 325     mp.reset_peek();
 326     assert_eq!(mp.peek(), Some(&2));
 327     assert_eq!(mp.next(), Some(2));
 328 }
 329
 330 #[test]
 331 fn test_multipeek_peeking_next() {
 332     use it::PeekingNext;
 333     let nums = vec![1u8,2,3,4,5,6,7];
 334
 335     let mut mp = multipeek(nums.iter().map(|&x| x));
 336     assert_eq!(mp.peeking_next(|&x| x != 0), Some(1));
 337     assert_eq!(mp.next(), Some(2));
 338     assert_eq!(mp.peek(), Some(&3));
 339     assert_eq!(mp.peek(), Some(&4));
 340     assert_eq!(mp.peeking_next(|&x| x == 3), Some(3));
 341     assert_eq!(mp.peek(), Some(&4));
 342     assert_eq!(mp.peeking_next(|&x| x != 4), None);
 343     assert_eq!(mp.peeking_next(|&x| x == 4), Some(4));
 344     assert_eq!(mp.peek(), Some(&5));
 345     assert_eq!(mp.peek(), Some(&6));
 346     assert_eq!(mp.peeking_next(|&x| x != 5), None);
 347     assert_eq!(mp.peek(), Some(&7));
 348     assert_eq!(mp.peeking_next(|&x| x == 5), Some(5));
 349     assert_eq!(mp.peeking_next(|&x| x == 6), Some(6));
 350     assert_eq!(mp.peek(), Some(&7));
 351     assert_eq!(mp.peek(), None);
 352     assert_eq!(mp.next(), Some(7));
 353     assert_eq!(mp.peek(), None);
 354 }
 355
 356 #[test]
 357 fn pad_using() {
 358     it::assert_equal((0..0).pad_using(1, |_| 1), 1..2);
 359
 360     let v: Vec<usize> = vec![0, 1, 2];
 361     let r = v.into_iter().pad_using(5, |n| n);
 362     it::assert_equal(r, vec![0, 1, 2, 3, 4]);
 363
 364     let v: Vec<usize> = vec![0, 1, 2];
 365     let r = v.into_iter().pad_using(1, |_| panic!());
 366     it::assert_equal(r, vec![0, 1, 2]);
 367 }
 368
 369 #[test]
 370 fn group_by() {
 371     for (ch1, sub) in &"AABBCCC".chars().group_by(|&x| x) {
 372         for ch2 in sub {
 373             assert_eq!(ch1, ch2);
 374         }
 375     }
 376
 377     for (ch1, sub) in &"AAABBBCCCCDDDD".chars().group_by(|&x| x) {
 378         for ch2 in sub {
 379             assert_eq!(ch1, ch2);
 380             if ch1 == 'C' {
 381                 break;
 382             }
 383         }
 384     }
 385
 386     let toupper = |ch: &char| ch.to_uppercase().nth(0).unwrap();
 387
 388     // try all possible orderings
 389     for indices in permutohedron::Heap::new(&mut [0, 1, 2, 3]) {
 390         let groups = "AaaBbbccCcDDDD".chars().group_by(&toupper);
 391         let mut subs = groups.into_iter().collect_vec();
 392
 393         for &idx in &indices[..] {
 394             let (key, text) = match idx {
 395                  0 => ('A', "Aaa".chars()),
 396                  1 => ('B', "Bbb".chars()),
 397                  2 => ('C', "ccCc".chars()),
 398                  3 => ('D', "DDDD".chars()),
 399                  _ => unreachable!(),
 400             };
 401             assert_eq!(key, subs[idx].0);
 402             it::assert_equal(&mut subs[idx].1, text);
 403         }
 404     }
 405
 406     let groups = "AAABBBCCCCDDDD".chars().group_by(|&x| x);
 407     let mut subs = groups.into_iter().map(|(_, g)| g).collect_vec();
 408
 409     let sd = subs.pop().unwrap();
 410     let sc = subs.pop().unwrap();
 411     let sb = subs.pop().unwrap();
 412     let sa = subs.pop().unwrap();
 413     for (a, b, c, d) in multizip((sa, sb, sc, sd)) {
 414         assert_eq!(a, 'A');
 415         assert_eq!(b, 'B');
 416         assert_eq!(c, 'C');
 417         assert_eq!(d, 'D');
 418     }
 419
 420     // check that the key closure is called exactly n times
 421     {
 422         let mut ntimes = 0;
 423         let text = "AABCCC";
 424         for (_, sub) in &text.chars().group_by(|&x| { ntimes += 1; x}) {
 425             for _ in sub {
 426             }
 427         }
 428         assert_eq!(ntimes, text.len());
 429     }
 430
 431     {
 432         let mut ntimes = 0;
 433         let text = "AABCCC";
 434         for _ in &text.chars().group_by(|&x| { ntimes += 1; x}) {
 435         }
 436         assert_eq!(ntimes, text.len());
 437     }
 438
 439     {
 440         let text = "ABCCCDEEFGHIJJKK";
 441         let gr = text.chars().group_by(|&x| x);
 442         it::assert_equal(gr.into_iter().flat_map(|(_, sub)| sub), text.chars());
 443     }
 444 }
 445
 446 #[test]
 447 fn group_by_lazy_2() {
 448     let data = vec![0, 1];
 449     let groups = data.iter().group_by(|k| *k);
 450     let gs = groups.into_iter().collect_vec();
 451     it::assert_equal(data.iter(), gs.into_iter().flat_map(|(_k, g)| g));
 452
 453     let data = vec![0, 1, 1, 0, 0];
 454     let groups = data.iter().group_by(|k| *k);
 455     let mut gs = groups.into_iter().collect_vec();
 456     gs[1..].reverse();
 457     it::assert_equal(&[0, 0, 0, 1, 1], gs.into_iter().flat_map(|(_, g)| g));
 458
 459     let grouper = data.iter().group_by(|k| *k);
 460     let mut groups = Vec::new();
 461     for (k, group) in &grouper {
 462         if *k == 1 {
 463             groups.push(group);
 464         }
 465     }
 466     it::assert_equal(&mut groups[0], &[1, 1]);
 467
 468     let data = vec![0, 0, 0, 1, 1, 0, 0, 2, 2, 3, 3];
 469     let grouper = data.iter().group_by(|k| *k);
 470     let mut groups = Vec::new();
 471     for (i, (_, group)) in grouper.into_iter().enumerate() {
 472         if i < 2 {
 473             groups.push(group);
 474         } else if i < 4 {
 475             for _ in group {
 476             }
 477         } else {
 478             groups.push(group);
 479         }
 480     }
 481     it::assert_equal(&mut groups[0], &[0, 0, 0]);
 482     it::assert_equal(&mut groups[1], &[1, 1]);
 483     it::assert_equal(&mut groups[2], &[3, 3]);
 484
 485     // use groups as chunks
 486     let data = vec![0, 0, 0, 1, 1, 0, 0, 2, 2, 3, 3];
 487     let mut i = 0;
 488     let grouper = data.iter().group_by(move |_| { let k = i / 3; i += 1; k });
 489     for (i, group) in &grouper {
 490         match i {
 491             0 => it::assert_equal(group, &[0, 0, 0]),
 492             1 => it::assert_equal(group, &[1, 1, 0]),
 493             2 => it::assert_equal(group, &[0, 2, 2]),
 494             3 => it::assert_equal(group, &[3, 3]),
 495             _ => unreachable!(),
 496         }
 497     }
 498 }
 499
 500 #[test]
 501 fn group_by_lazy_3() {
 502     // test consuming each group on the lap after it was produced
 503     let data = vec![0, 0, 0, 1, 1, 0, 0, 1, 1, 2, 2];
 504     let grouper = data.iter().group_by(|elt| *elt);
 505     let mut last = None;
 506     for (key, group) in &grouper {
 507         if let Some(gr) = last.take() {
 508             for elt in gr {
 509                 assert!(elt != key && i32::abs(elt - key) == 1);
 510             }
 511         }
 512         last = Some(group);
 513     }
 514 }
 515
 516 #[test]
 517 fn chunks() {
 518     let data = vec![0, 0, 0, 1, 1, 0, 0, 2, 2, 3, 3];
 519     let grouper = data.iter().chunks(3);
 520     for (i, chunk) in grouper.into_iter().enumerate() {
 521         match i {
 522             0 => it::assert_equal(chunk, &[0, 0, 0]),
 523             1 => it::assert_equal(chunk, &[1, 1, 0]),
 524             2 => it::assert_equal(chunk, &[0, 2, 2]),
 525             3 => it::assert_equal(chunk, &[3, 3]),
 526             _ => unreachable!(),
 527         }
 528     }
 529 }
 530
 531 #[test]
 532 fn concat_empty() {
 533     let data: Vec<Vec<()>> = Vec::new();
 534     assert_eq!(data.into_iter().concat(), Vec::new())
 535 }
 536
 537 #[test]
 538 fn concat_non_empty() {
 539     let data = vec![vec![1,2,3], vec![4,5,6], vec![7,8,9]];
 540     assert_eq!(data.into_iter().concat(), vec![1,2,3,4,5,6,7,8,9])
 541 }
 542
 543 #[test]
 544 fn combinations() {
 545     assert!((1..3).combinations(5).next().is_none());
 546
 547     let it = (1..3).combinations(2);
 548     it::assert_equal(it, vec![
 549         vec![1, 2],
 550         ]);
 551
 552     let it = (1..5).combinations(2);
 553     it::assert_equal(it, vec![
 554         vec![1, 2],
 555         vec![1, 3],
 556         vec![1, 4],
 557         vec![2, 3],
 558         vec![2, 4],
 559         vec![3, 4],
 560         ]);
 561
 562     it::assert_equal((0..0).tuple_combinations::<(_, _)>(), <Vec<_>>::new());
 563     it::assert_equal((0..1).tuple_combinations::<(_, _)>(), <Vec<_>>::new());
 564     it::assert_equal((0..2).tuple_combinations::<(_, _)>(), vec![(0, 1)]);
 565
 566     it::assert_equal((0..0).combinations(2), <Vec<Vec<_>>>::new());
 567     it::assert_equal((0..1).combinations(1), vec![vec![0]]);
 568     it::assert_equal((0..2).combinations(1), vec![vec![0], vec![1]]);
 569     it::assert_equal((0..2).combinations(2), vec![vec![0, 1]]);
 570 }
 571
 572 #[test]
 573 fn combinations_of_too_short() {
 574     for i in 1..10 {
 575         assert!((0..0).combinations(i).next().is_none());
 576         assert!((0..i - 1).combinations(i).next().is_none());
 577     }
 578 }
 579
 580
 581 #[test]
 582 fn combinations_zero() {
 583     it::assert_equal((1..3).combinations(0), vec![vec![]]);
 584 }
 585
 586 #[test]
 587 fn diff_mismatch() {
 588     let a = vec![1, 2, 3, 4];
 589     let b = vec![1.0, 5.0, 3.0, 4.0];
 590     let b_map = b.into_iter().map(|f| f as i32);
 591     let diff = it::diff_with(a.iter(), b_map, |a, b| *a == b);
 592
 593     assert!(match diff {
 594         Some(it::Diff::FirstMismatch(1, _, from_diff)) =>
 595             from_diff.collect::<Vec<_>>() == vec![5, 3, 4],
 596         _ => false,
 597     });
 598 }
 599
 600 #[test]
 601 fn diff_longer() {
 602     let a = vec![1, 2, 3, 4];
 603     let b = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
 604     let b_map = b.into_iter().map(|f| f as i32);
 605     let diff = it::diff_with(a.iter(), b_map, |a, b| *a == b);
 606
 607     assert!(match diff {
 608         Some(it::Diff::Longer(_, remaining)) =>
 609             remaining.collect::<Vec<_>>() == vec![5, 6],
 610         _ => false,
 611     });
 612 }
 613
 614 #[test]
 615 fn diff_shorter() {
 616     let a = vec![1, 2, 3, 4];
 617     let b = vec![1.0, 2.0];
 618     let b_map = b.into_iter().map(|f| f as i32);
 619     let diff = it::diff_with(a.iter(), b_map, |a, b| *a == b);
 620
 621     assert!(match diff {
 622         Some(it::Diff::Shorter(len, _)) => len == 2,
 623         _ => false,
 624     });
 625 }
 626
 627 #[test]
 628 fn minmax() {
 629     use std::cmp::Ordering;
 630     use it::MinMaxResult;
 631
 632     // A peculiar type: Equality compares both tuple items, but ordering only the
 633     // first item.  This is so we can check the stability property easily.
 634     #[derive(Clone, Debug, PartialEq, Eq)]
 635     struct Val(u32, u32);
 636
 637     impl PartialOrd<Val> for Val {
 638         fn partial_cmp(&self, other: &Val) -> Option<Ordering> {
 639             self.0.partial_cmp(&other.0)
 640         }
 641     }
 642
 643     impl Ord for Val {
 644         fn cmp(&self, other: &Val) -> Ordering {
 645             self.0.cmp(&other.0)
 646         }
 647     }
 648
 649     assert_eq!(None::<Option<u32>>.iter().minmax(), MinMaxResult::NoElements);
 650
 651     assert_eq!(Some(1u32).iter().minmax(), MinMaxResult::OneElement(&1));
 652
 653     let data = vec![Val(0, 1), Val(2, 0), Val(0, 2), Val(1, 0), Val(2, 1)];
 654
 655     let minmax = data.iter().minmax();
 656     assert_eq!(minmax, MinMaxResult::MinMax(&Val(0, 1), &Val(2, 1)));
 657
 658     let (min, max) = data.iter().minmax_by_key(|v| v.1).into_option().unwrap();
 659     assert_eq!(min, &Val(2, 0));
 660     assert_eq!(max, &Val(0, 2));
 661
 662     let (min, max) = data.iter().minmax_by(|x, y| x.1.cmp(&y.1)).into_option().unwrap();
 663     assert_eq!(min, &Val(2, 0));
 664     assert_eq!(max, &Val(0, 2));
 665 }
 666
 667 #[test]
 668 fn format() {
 669     let data = [0, 1, 2, 3];
 670     let ans1 = "0, 1, 2, 3";
 671     let ans2 = "0--1--2--3";
 672
 673     let t1 = format!("{}", data.iter().format(", "));
 674     assert_eq!(t1, ans1);
 675     let t2 = format!("{:?}", data.iter().format("--"));
 676     assert_eq!(t2, ans2);
 677
 678     let dataf = [1.1, 2.71828, -22.];
 679     let t3 = format!("{:.2e}", dataf.iter().format(", "));
 680     assert_eq!(t3, "1.10e0, 2.72e0, -2.20e1");
 681 }
 682
 683 #[test]
 684 fn while_some() {
 685     let ns = (1..10).map(|x| if x % 5 != 0 { Some(x) } else { None })
 686                     .while_some();
 687     it::assert_equal(ns, vec![1, 2, 3, 4]);
 688 }
 689
 690 #[allow(deprecated)]
 691 #[test]
 692 fn fold_while() {
 693     let mut iterations = 0;
 694     let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 695     let sum = vec.into_iter().fold_while(0, |acc, item| {
 696         iterations += 1;
 697         let new_sum = acc.clone() + item;
 698         if new_sum <= 20 {
 699             FoldWhile::Continue(new_sum)
 700         } else {
 701             FoldWhile::Done(acc)
 702         }
 703     }).into_inner();
 704     assert_eq!(iterations, 6);
 705     assert_eq!(sum, 15);
 706 }
 707
 708 #[test]
 709 fn tree_fold1() {
 710     let x = [
 711         "",
 712         "0",
 713         "0 1 x",
 714         "0 1 x 2 x",
 715         "0 1 x 2 3 x x",
 716         "0 1 x 2 3 x x 4 x",
 717         "0 1 x 2 3 x x 4 5 x x",
 718         "0 1 x 2 3 x x 4 5 x 6 x x",
 719         "0 1 x 2 3 x x 4 5 x 6 7 x x x",
 720         "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 x",
 721         "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x x",
 722         "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x 10 x x",
 723         "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x 10 11 x x x",
 724         "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x 10 11 x x 12 x x",
 725         "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x 10 11 x x 12 13 x x x",
 726         "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x 10 11 x x 12 13 x 14 x x x",
 727         "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x 10 11 x x 12 13 x 14 15 x x x x",
 728     ];
 729     for (i, &s) in x.iter().enumerate() {
 730         let expected = if s == "" { None } else { Some(s.to_string()) };
 731         let num_strings = (0..i).map(|x| x.to_string());
 732         let actual = num_strings.tree_fold1(|a, b| format!("{} {} x", a, b));
 733         assert_eq!(actual, expected);
 734     }
 735 }