test_std.rs 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122
  1. use paste;
  2. use permutohedron;
  3. use quickcheck as qc;
  4. use rand::{distributions::{Distribution, Standard}, Rng, SeedableRng, rngs::StdRng};
  5. use rand::{seq::SliceRandom, thread_rng};
  6. use std::{cmp::min, fmt::Debug, marker::PhantomData};
  7. use itertools as it;
  8. use crate::it::Itertools;
  9. use crate::it::ExactlyOneError;
  10. use crate::it::multizip;
  11. use crate::it::multipeek;
  12. use crate::it::peek_nth;
  13. use crate::it::free::rciter;
  14. use crate::it::free::put_back_n;
  15. use crate::it::FoldWhile;
  16. use crate::it::cloned;
  17. use crate::it::iproduct;
  18. use crate::it::izip;
  19. #[test]
  20. fn product3() {
  21. let prod = iproduct!(0..3, 0..2, 0..2);
  22. assert_eq!(prod.size_hint(), (12, Some(12)));
  23. let v = prod.collect_vec();
  24. for i in 0..3 {
  25. for j in 0..2 {
  26. for k in 0..2 {
  27. assert!((i, j, k) == v[(i * 2 * 2 + j * 2 + k) as usize]);
  28. }
  29. }
  30. }
  31. for (_, _, _, _) in iproduct!(0..3, 0..2, 0..2, 0..3) {
  32. /* test compiles */
  33. }
  34. }
  35. #[test]
  36. fn interleave_shortest() {
  37. let v0: Vec<i32> = vec![0, 2, 4];
  38. let v1: Vec<i32> = vec![1, 3, 5, 7];
  39. let it = v0.into_iter().interleave_shortest(v1.into_iter());
  40. assert_eq!(it.size_hint(), (6, Some(6)));
  41. assert_eq!(it.collect_vec(), vec![0, 1, 2, 3, 4, 5]);
  42. let v0: Vec<i32> = vec![0, 2, 4, 6, 8];
  43. let v1: Vec<i32> = vec![1, 3, 5];
  44. let it = v0.into_iter().interleave_shortest(v1.into_iter());
  45. assert_eq!(it.size_hint(), (7, Some(7)));
  46. assert_eq!(it.collect_vec(), vec![0, 1, 2, 3, 4, 5, 6]);
  47. let i0 = ::std::iter::repeat(0);
  48. let v1: Vec<_> = vec![1, 3, 5];
  49. let it = i0.interleave_shortest(v1.into_iter());
  50. assert_eq!(it.size_hint(), (7, Some(7)));
  51. let v0: Vec<_> = vec![0, 2, 4];
  52. let i1 = ::std::iter::repeat(1);
  53. let it = v0.into_iter().interleave_shortest(i1);
  54. assert_eq!(it.size_hint(), (6, Some(6)));
  55. }
  56. #[test]
  57. fn duplicates_by() {
  58. let xs = ["aaa", "bbbbb", "aa", "ccc", "bbbb", "aaaaa", "cccc"];
  59. let ys = ["aa", "bbbb", "cccc"];
  60. it::assert_equal(ys.iter(), xs.iter().duplicates_by(|x| x[..2].to_string()));
  61. it::assert_equal(ys.iter(), xs.iter().rev().duplicates_by(|x| x[..2].to_string()).rev());
  62. let ys_rev = ["ccc", "aa", "bbbbb"];
  63. it::assert_equal(ys_rev.iter(), xs.iter().duplicates_by(|x| x[..2].to_string()).rev());
  64. }
  65. #[test]
  66. fn duplicates() {
  67. let xs = [0, 1, 2, 3, 2, 1, 3];
  68. let ys = [2, 1, 3];
  69. it::assert_equal(ys.iter(), xs.iter().duplicates());
  70. it::assert_equal(ys.iter(), xs.iter().rev().duplicates().rev());
  71. let ys_rev = [3, 2, 1];
  72. it::assert_equal(ys_rev.iter(), xs.iter().duplicates().rev());
  73. let xs = [0, 1, 0, 1];
  74. let ys = [0, 1];
  75. it::assert_equal(ys.iter(), xs.iter().duplicates());
  76. it::assert_equal(ys.iter(), xs.iter().rev().duplicates().rev());
  77. let ys_rev = [1, 0];
  78. it::assert_equal(ys_rev.iter(), xs.iter().duplicates().rev());
  79. let xs = vec![0, 1, 2, 1, 2];
  80. let ys = vec![1, 2];
  81. assert_eq!(ys, xs.iter().duplicates().cloned().collect_vec());
  82. assert_eq!(ys, xs.iter().rev().duplicates().rev().cloned().collect_vec());
  83. let ys_rev = vec![2, 1];
  84. assert_eq!(ys_rev, xs.iter().duplicates().rev().cloned().collect_vec());
  85. }
  86. #[test]
  87. fn unique_by() {
  88. let xs = ["aaa", "bbbbb", "aa", "ccc", "bbbb", "aaaaa", "cccc"];
  89. let ys = ["aaa", "bbbbb", "ccc"];
  90. it::assert_equal(ys.iter(), xs.iter().unique_by(|x| x[..2].to_string()));
  91. it::assert_equal(ys.iter(), xs.iter().rev().unique_by(|x| x[..2].to_string()).rev());
  92. let ys_rev = ["cccc", "aaaaa", "bbbb"];
  93. it::assert_equal(ys_rev.iter(), xs.iter().unique_by(|x| x[..2].to_string()).rev());
  94. }
  95. #[test]
  96. fn unique() {
  97. let xs = [0, 1, 2, 3, 2, 1, 3];
  98. let ys = [0, 1, 2, 3];
  99. it::assert_equal(ys.iter(), xs.iter().unique());
  100. it::assert_equal(ys.iter(), xs.iter().rev().unique().rev());
  101. let ys_rev = [3, 1, 2, 0];
  102. it::assert_equal(ys_rev.iter(), xs.iter().unique().rev());
  103. let xs = [0, 1];
  104. let ys = [0, 1];
  105. it::assert_equal(ys.iter(), xs.iter().unique());
  106. it::assert_equal(ys.iter(), xs.iter().rev().unique().rev());
  107. let ys_rev = [1, 0];
  108. it::assert_equal(ys_rev.iter(), xs.iter().unique().rev());
  109. }
  110. #[test]
  111. fn intersperse() {
  112. let xs = ["a", "", "b", "c"];
  113. let v: Vec<&str> = xs.iter().map(|x| x.clone()).intersperse(", ").collect();
  114. let text: String = v.concat();
  115. assert_eq!(text, "a, , b, c".to_string());
  116. let ys = [0, 1, 2, 3];
  117. let mut it = ys[..0].iter().map(|x| *x).intersperse(1);
  118. assert!(it.next() == None);
  119. }
  120. #[test]
  121. fn dedup() {
  122. let xs = [0, 1, 1, 1, 2, 1, 3, 3];
  123. let ys = [0, 1, 2, 1, 3];
  124. it::assert_equal(ys.iter(), xs.iter().dedup());
  125. let xs = [0, 0, 0, 0, 0];
  126. let ys = [0];
  127. it::assert_equal(ys.iter(), xs.iter().dedup());
  128. let xs = [0, 1, 1, 1, 2, 1, 3, 3];
  129. let ys = [0, 1, 2, 1, 3];
  130. let mut xs_d = Vec::new();
  131. xs.iter().dedup().fold((), |(), &elt| xs_d.push(elt));
  132. assert_eq!(&xs_d, &ys);
  133. }
  134. #[test]
  135. fn coalesce() {
  136. let data = vec![-1., -2., -3., 3., 1., 0., -1.];
  137. let it = data.iter().cloned().coalesce(|x, y|
  138. if (x >= 0.) == (y >= 0.) {
  139. Ok(x + y)
  140. } else {
  141. Err((x, y))
  142. }
  143. );
  144. itertools::assert_equal(it.clone(), vec![-6., 4., -1.]);
  145. assert_eq!(
  146. it.fold(vec![], |mut v, n| {
  147. v.push(n);
  148. v
  149. }),
  150. vec![-6., 4., -1.]
  151. );
  152. }
  153. #[test]
  154. fn dedup_by() {
  155. let xs = [(0, 0), (0, 1), (1, 1), (2, 1), (0, 2), (3, 1), (0, 3), (1, 3)];
  156. let ys = [(0, 0), (0, 1), (0, 2), (3, 1), (0, 3)];
  157. it::assert_equal(ys.iter(), xs.iter().dedup_by(|x, y| x.1==y.1));
  158. let xs = [(0, 1), (0, 2), (0, 3), (0, 4), (0, 5)];
  159. let ys = [(0, 1)];
  160. it::assert_equal(ys.iter(), xs.iter().dedup_by(|x, y| x.0==y.0));
  161. let xs = [(0, 0), (0, 1), (1, 1), (2, 1), (0, 2), (3, 1), (0, 3), (1, 3)];
  162. let ys = [(0, 0), (0, 1), (0, 2), (3, 1), (0, 3)];
  163. let mut xs_d = Vec::new();
  164. xs.iter().dedup_by(|x, y| x.1==y.1).fold((), |(), &elt| xs_d.push(elt));
  165. assert_eq!(&xs_d, &ys);
  166. }
  167. #[test]
  168. fn dedup_with_count() {
  169. let xs: [i32; 8] = [0, 1, 1, 1, 2, 1, 3, 3];
  170. let ys: [(usize, &i32); 5] = [(1, &0), (3, &1), (1, &2), (1, &1), (2, &3)];
  171. it::assert_equal(ys.iter().cloned(), xs.iter().dedup_with_count());
  172. let xs: [i32; 5] = [0, 0, 0, 0, 0];
  173. let ys: [(usize, &i32); 1] = [(5, &0)];
  174. it::assert_equal(ys.iter().cloned(), xs.iter().dedup_with_count());
  175. }
  176. #[test]
  177. fn dedup_by_with_count() {
  178. let xs = [(0, 0), (0, 1), (1, 1), (2, 1), (0, 2), (3, 1), (0, 3), (1, 3)];
  179. let ys = [(1, &(0, 0)), (3, &(0, 1)), (1, &(0, 2)), (1, &(3, 1)), (2, &(0, 3))];
  180. it::assert_equal(ys.iter().cloned(), xs.iter().dedup_by_with_count(|x, y| x.1==y.1));
  181. let xs = [(0, 1), (0, 2), (0, 3), (0, 4), (0, 5)];
  182. let ys = [( 5, &(0, 1))];
  183. it::assert_equal(ys.iter().cloned(), xs.iter().dedup_by_with_count(|x, y| x.0==y.0));
  184. }
  185. #[test]
  186. fn all_equal() {
  187. assert!("".chars().all_equal());
  188. assert!("A".chars().all_equal());
  189. assert!(!"AABBCCC".chars().all_equal());
  190. assert!("AAAAAAA".chars().all_equal());
  191. for (_key, mut sub) in &"AABBCCC".chars().group_by(|&x| x) {
  192. assert!(sub.all_equal());
  193. }
  194. }
  195. #[test]
  196. fn all_unique() {
  197. assert!("ABCDEFGH".chars().all_unique());
  198. assert!(!"ABCDEFGA".chars().all_unique());
  199. assert!(::std::iter::empty::<usize>().all_unique());
  200. }
  201. #[test]
  202. fn test_put_back_n() {
  203. let xs = [0, 1, 1, 1, 2, 1, 3, 3];
  204. let mut pb = put_back_n(xs.iter().cloned());
  205. pb.next();
  206. pb.next();
  207. pb.put_back(1);
  208. pb.put_back(0);
  209. it::assert_equal(pb, xs.iter().cloned());
  210. }
  211. #[test]
  212. fn tee() {
  213. let xs = [0, 1, 2, 3];
  214. let (mut t1, mut t2) = xs.iter().cloned().tee();
  215. assert_eq!(t1.next(), Some(0));
  216. assert_eq!(t2.next(), Some(0));
  217. assert_eq!(t1.next(), Some(1));
  218. assert_eq!(t1.next(), Some(2));
  219. assert_eq!(t1.next(), Some(3));
  220. assert_eq!(t1.next(), None);
  221. assert_eq!(t2.next(), Some(1));
  222. assert_eq!(t2.next(), Some(2));
  223. assert_eq!(t1.next(), None);
  224. assert_eq!(t2.next(), Some(3));
  225. assert_eq!(t2.next(), None);
  226. assert_eq!(t1.next(), None);
  227. assert_eq!(t2.next(), None);
  228. let (t1, t2) = xs.iter().cloned().tee();
  229. it::assert_equal(t1, xs.iter().cloned());
  230. it::assert_equal(t2, xs.iter().cloned());
  231. let (t1, t2) = xs.iter().cloned().tee();
  232. it::assert_equal(t1.zip(t2), xs.iter().cloned().zip(xs.iter().cloned()));
  233. }
  234. #[test]
  235. fn test_rciter() {
  236. let xs = [0, 1, 1, 1, 2, 1, 3, 5, 6];
  237. let mut r1 = rciter(xs.iter().cloned());
  238. let mut r2 = r1.clone();
  239. assert_eq!(r1.next(), Some(0));
  240. assert_eq!(r2.next(), Some(1));
  241. let mut z = r1.zip(r2);
  242. assert_eq!(z.next(), Some((1, 1)));
  243. assert_eq!(z.next(), Some((2, 1)));
  244. assert_eq!(z.next(), Some((3, 5)));
  245. assert_eq!(z.next(), None);
  246. // test intoiterator
  247. let r1 = rciter(0..5);
  248. let mut z = izip!(&r1, r1);
  249. assert_eq!(z.next(), Some((0, 1)));
  250. }
  251. #[allow(deprecated)]
  252. #[test]
  253. fn trait_pointers() {
  254. struct ByRef<'r, I: ?Sized>(&'r mut I) ;
  255. impl<'r, X, I: ?Sized> Iterator for ByRef<'r, I> where
  256. I: 'r + Iterator<Item=X>
  257. {
  258. type Item = X;
  259. fn next(&mut self) -> Option<Self::Item>
  260. {
  261. self.0.next()
  262. }
  263. }
  264. let mut it = Box::new(0..10) as Box<dyn Iterator<Item=i32>>;
  265. assert_eq!(it.next(), Some(0));
  266. {
  267. /* make sure foreach works on non-Sized */
  268. let jt: &mut dyn Iterator<Item = i32> = &mut *it;
  269. assert_eq!(jt.next(), Some(1));
  270. {
  271. let mut r = ByRef(jt);
  272. assert_eq!(r.next(), Some(2));
  273. }
  274. assert_eq!(jt.find_position(|x| *x == 4), Some((1, 4)));
  275. jt.foreach(|_| ());
  276. }
  277. }
  278. #[test]
  279. fn merge_by() {
  280. let odd : Vec<(u32, &str)> = vec![(1, "hello"), (3, "world"), (5, "!")];
  281. let even = vec![(2, "foo"), (4, "bar"), (6, "baz")];
  282. let expected = vec![(1, "hello"), (2, "foo"), (3, "world"), (4, "bar"), (5, "!"), (6, "baz")];
  283. let results = odd.iter().merge_by(even.iter(), |a, b| a.0 <= b.0);
  284. it::assert_equal(results, expected.iter());
  285. }
  286. #[test]
  287. fn merge_by_btree() {
  288. use std::collections::BTreeMap;
  289. let mut bt1 = BTreeMap::new();
  290. bt1.insert("hello", 1);
  291. bt1.insert("world", 3);
  292. let mut bt2 = BTreeMap::new();
  293. bt2.insert("foo", 2);
  294. bt2.insert("bar", 4);
  295. let results = bt1.into_iter().merge_by(bt2.into_iter(), |a, b| a.0 <= b.0 );
  296. let expected = vec![("bar", 4), ("foo", 2), ("hello", 1), ("world", 3)];
  297. it::assert_equal(results, expected.into_iter());
  298. }
  299. #[allow(deprecated)]
  300. #[test]
  301. fn kmerge() {
  302. let its = (0..4).map(|s| (s..10).step(4));
  303. it::assert_equal(its.kmerge(), 0..10);
  304. }
  305. #[allow(deprecated)]
  306. #[test]
  307. fn kmerge_2() {
  308. let its = vec![3, 2, 1, 0].into_iter().map(|s| (s..10).step(4));
  309. it::assert_equal(its.kmerge(), 0..10);
  310. }
  311. #[test]
  312. fn kmerge_empty() {
  313. let its = (0..4).map(|_| 0..0);
  314. assert_eq!(its.kmerge().next(), None);
  315. }
  316. #[test]
  317. fn kmerge_size_hint() {
  318. let its = (0..5).map(|_| (0..10));
  319. assert_eq!(its.kmerge().size_hint(), (50, Some(50)));
  320. }
  321. #[test]
  322. fn kmerge_empty_size_hint() {
  323. let its = (0..5).map(|_| (0..0));
  324. assert_eq!(its.kmerge().size_hint(), (0, Some(0)));
  325. }
  326. #[test]
  327. fn join() {
  328. let many = [1, 2, 3];
  329. let one = [1];
  330. let none: Vec<i32> = vec![];
  331. assert_eq!(many.iter().join(", "), "1, 2, 3");
  332. assert_eq!( one.iter().join(", "), "1");
  333. assert_eq!(none.iter().join(", "), "");
  334. }
  335. #[test]
  336. fn sorted_unstable_by() {
  337. let sc = [3, 4, 1, 2].iter().cloned().sorted_by(|&a, &b| {
  338. a.cmp(&b)
  339. });
  340. it::assert_equal(sc, vec![1, 2, 3, 4]);
  341. let v = (0..5).sorted_unstable_by(|&a, &b| a.cmp(&b).reverse());
  342. it::assert_equal(v, vec![4, 3, 2, 1, 0]);
  343. }
  344. #[test]
  345. fn sorted_unstable_by_key() {
  346. let sc = [3, 4, 1, 2].iter().cloned().sorted_unstable_by_key(|&x| x);
  347. it::assert_equal(sc, vec![1, 2, 3, 4]);
  348. let v = (0..5).sorted_unstable_by_key(|&x| -x);
  349. it::assert_equal(v, vec![4, 3, 2, 1, 0]);
  350. }
  351. #[test]
  352. fn sorted_by() {
  353. let sc = [3, 4, 1, 2].iter().cloned().sorted_by(|&a, &b| {
  354. a.cmp(&b)
  355. });
  356. it::assert_equal(sc, vec![1, 2, 3, 4]);
  357. let v = (0..5).sorted_by(|&a, &b| a.cmp(&b).reverse());
  358. it::assert_equal(v, vec![4, 3, 2, 1, 0]);
  359. }
  360. qc::quickcheck! {
  361. fn k_smallest_range(n: u64, m: u16, k: u16) -> () {
  362. // u16 is used to constrain k and m to 0..2¹⁶,
  363. // otherwise the test could use too much memory.
  364. let (k, m) = (k as u64, m as u64);
  365. // Generate a random permutation of n..n+m
  366. let i = {
  367. let mut v: Vec<u64> = (n..n.saturating_add(m)).collect();
  368. v.shuffle(&mut thread_rng());
  369. v.into_iter()
  370. };
  371. // Check that taking the k smallest elements yields n..n+min(k, m)
  372. it::assert_equal(
  373. i.k_smallest(k as usize),
  374. n..n.saturating_add(min(k, m))
  375. );
  376. }
  377. }
  378. #[derive(Clone, Debug)]
  379. struct RandIter<T: 'static + Clone + Send, R: 'static + Clone + Rng + SeedableRng + Send = StdRng> {
  380. idx: usize,
  381. len: usize,
  382. rng: R,
  383. _t: PhantomData<T>
  384. }
  385. impl<T: Clone + Send, R: Clone + Rng + SeedableRng + Send> Iterator for RandIter<T, R>
  386. where Standard: Distribution<T> {
  387. type Item = T;
  388. fn next(&mut self) -> Option<T> {
  389. if self.idx == self.len {
  390. None
  391. } else {
  392. self.idx += 1;
  393. Some(self.rng.gen())
  394. }
  395. }
  396. }
  397. impl<T: Clone + Send, R: Clone + Rng + SeedableRng + Send> qc::Arbitrary for RandIter<T, R> {
  398. fn arbitrary<G: qc::Gen>(g: &mut G) -> Self {
  399. RandIter {
  400. idx: 0,
  401. len: g.size(),
  402. rng: R::seed_from_u64(g.next_u64()),
  403. _t : PhantomData{},
  404. }
  405. }
  406. }
  407. // Check that taking the k smallest is the same as
  408. // sorting then taking the k first elements
  409. fn k_smallest_sort<I>(i: I, k: u16) -> ()
  410. where
  411. I: Iterator + Clone,
  412. I::Item: Ord + Debug,
  413. {
  414. let j = i.clone();
  415. let k = k as usize;
  416. it::assert_equal(
  417. i.k_smallest(k),
  418. j.sorted().take(k)
  419. )
  420. }
  421. macro_rules! generic_test {
  422. ($f:ident, $($t:ty),+) => {
  423. $(paste::item! {
  424. qc::quickcheck! {
  425. fn [< $f _ $t >](i: RandIter<$t>, k: u16) -> () {
  426. $f(i, k)
  427. }
  428. }
  429. })+
  430. };
  431. }
  432. generic_test!(k_smallest_sort, u8, u16, u32, u64, i8, i16, i32, i64);
  433. #[test]
  434. fn sorted_by_key() {
  435. let sc = [3, 4, 1, 2].iter().cloned().sorted_by_key(|&x| x);
  436. it::assert_equal(sc, vec![1, 2, 3, 4]);
  437. let v = (0..5).sorted_by_key(|&x| -x);
  438. it::assert_equal(v, vec![4, 3, 2, 1, 0]);
  439. }
  440. #[test]
  441. fn sorted_by_cached_key() {
  442. // Track calls to key function
  443. let mut ncalls = 0;
  444. let sorted = [3, 4, 1, 2].iter().cloned().sorted_by_cached_key(|&x| {
  445. ncalls += 1;
  446. x.to_string()
  447. });
  448. it::assert_equal(sorted, vec![1, 2, 3, 4]);
  449. // Check key function called once per element
  450. assert_eq!(ncalls, 4);
  451. let mut ncalls = 0;
  452. let sorted = (0..5).sorted_by_cached_key(|&x| {
  453. ncalls += 1;
  454. -x
  455. });
  456. it::assert_equal(sorted, vec![4, 3, 2, 1, 0]);
  457. // Check key function called once per element
  458. assert_eq!(ncalls, 5);
  459. }
  460. #[test]
  461. fn test_multipeek() {
  462. let nums = vec![1u8,2,3,4,5];
  463. let mp = multipeek(nums.iter().map(|&x| x));
  464. assert_eq!(nums, mp.collect::<Vec<_>>());
  465. let mut mp = multipeek(nums.iter().map(|&x| x));
  466. assert_eq!(mp.peek(), Some(&1));
  467. assert_eq!(mp.next(), Some(1));
  468. assert_eq!(mp.peek(), Some(&2));
  469. assert_eq!(mp.peek(), Some(&3));
  470. assert_eq!(mp.next(), Some(2));
  471. assert_eq!(mp.peek(), Some(&3));
  472. assert_eq!(mp.peek(), Some(&4));
  473. assert_eq!(mp.peek(), Some(&5));
  474. assert_eq!(mp.peek(), None);
  475. assert_eq!(mp.next(), Some(3));
  476. assert_eq!(mp.next(), Some(4));
  477. assert_eq!(mp.peek(), Some(&5));
  478. assert_eq!(mp.peek(), None);
  479. assert_eq!(mp.next(), Some(5));
  480. assert_eq!(mp.next(), None);
  481. assert_eq!(mp.peek(), None);
  482. }
  483. #[test]
  484. fn test_multipeek_reset() {
  485. let data = [1, 2, 3, 4];
  486. let mut mp = multipeek(cloned(&data));
  487. assert_eq!(mp.peek(), Some(&1));
  488. assert_eq!(mp.next(), Some(1));
  489. assert_eq!(mp.peek(), Some(&2));
  490. assert_eq!(mp.peek(), Some(&3));
  491. mp.reset_peek();
  492. assert_eq!(mp.peek(), Some(&2));
  493. assert_eq!(mp.next(), Some(2));
  494. }
  495. #[test]
  496. fn test_multipeek_peeking_next() {
  497. use crate::it::PeekingNext;
  498. let nums = vec![1u8,2,3,4,5,6,7];
  499. let mut mp = multipeek(nums.iter().map(|&x| x));
  500. assert_eq!(mp.peeking_next(|&x| x != 0), Some(1));
  501. assert_eq!(mp.next(), Some(2));
  502. assert_eq!(mp.peek(), Some(&3));
  503. assert_eq!(mp.peek(), Some(&4));
  504. assert_eq!(mp.peeking_next(|&x| x == 3), Some(3));
  505. assert_eq!(mp.peek(), Some(&4));
  506. assert_eq!(mp.peeking_next(|&x| x != 4), None);
  507. assert_eq!(mp.peeking_next(|&x| x == 4), Some(4));
  508. assert_eq!(mp.peek(), Some(&5));
  509. assert_eq!(mp.peek(), Some(&6));
  510. assert_eq!(mp.peeking_next(|&x| x != 5), None);
  511. assert_eq!(mp.peek(), Some(&7));
  512. assert_eq!(mp.peeking_next(|&x| x == 5), Some(5));
  513. assert_eq!(mp.peeking_next(|&x| x == 6), Some(6));
  514. assert_eq!(mp.peek(), Some(&7));
  515. assert_eq!(mp.peek(), None);
  516. assert_eq!(mp.next(), Some(7));
  517. assert_eq!(mp.peek(), None);
  518. }
  519. #[test]
  520. fn test_peek_nth() {
  521. let nums = vec![1u8,2,3,4,5];
  522. let iter = peek_nth(nums.iter().map(|&x| x));
  523. assert_eq!(nums, iter.collect::<Vec<_>>());
  524. let mut iter = peek_nth(nums.iter().map(|&x| x));
  525. assert_eq!(iter.peek_nth(0), Some(&1));
  526. assert_eq!(iter.peek_nth(0), Some(&1));
  527. assert_eq!(iter.next(), Some(1));
  528. assert_eq!(iter.peek_nth(0), Some(&2));
  529. assert_eq!(iter.peek_nth(1), Some(&3));
  530. assert_eq!(iter.next(), Some(2));
  531. assert_eq!(iter.peek_nth(0), Some(&3));
  532. assert_eq!(iter.peek_nth(1), Some(&4));
  533. assert_eq!(iter.peek_nth(2), Some(&5));
  534. assert_eq!(iter.peek_nth(3), None);
  535. assert_eq!(iter.next(), Some(3));
  536. assert_eq!(iter.next(), Some(4));
  537. assert_eq!(iter.peek_nth(0), Some(&5));
  538. assert_eq!(iter.peek_nth(1), None);
  539. assert_eq!(iter.next(), Some(5));
  540. assert_eq!(iter.next(), None);
  541. assert_eq!(iter.peek_nth(0), None);
  542. assert_eq!(iter.peek_nth(1), None);
  543. }
  544. #[test]
  545. fn test_peek_nth_peeking_next() {
  546. use it::PeekingNext;
  547. let nums = vec![1u8,2,3,4,5,6,7];
  548. let mut iter = peek_nth(nums.iter().map(|&x| x));
  549. assert_eq!(iter.peeking_next(|&x| x != 0), Some(1));
  550. assert_eq!(iter.next(), Some(2));
  551. assert_eq!(iter.peek_nth(0), Some(&3));
  552. assert_eq!(iter.peek_nth(1), Some(&4));
  553. assert_eq!(iter.peeking_next(|&x| x == 3), Some(3));
  554. assert_eq!(iter.peek(), Some(&4));
  555. assert_eq!(iter.peeking_next(|&x| x != 4), None);
  556. assert_eq!(iter.peeking_next(|&x| x == 4), Some(4));
  557. assert_eq!(iter.peek_nth(0), Some(&5));
  558. assert_eq!(iter.peek_nth(1), Some(&6));
  559. assert_eq!(iter.peeking_next(|&x| x != 5), None);
  560. assert_eq!(iter.peek(), Some(&5));
  561. assert_eq!(iter.peeking_next(|&x| x == 5), Some(5));
  562. assert_eq!(iter.peeking_next(|&x| x == 6), Some(6));
  563. assert_eq!(iter.peek_nth(0), Some(&7));
  564. assert_eq!(iter.peek_nth(1), None);
  565. assert_eq!(iter.next(), Some(7));
  566. assert_eq!(iter.peek(), None);
  567. }
  568. #[test]
  569. fn pad_using() {
  570. it::assert_equal((0..0).pad_using(1, |_| 1), 1..2);
  571. let v: Vec<usize> = vec![0, 1, 2];
  572. let r = v.into_iter().pad_using(5, |n| n);
  573. it::assert_equal(r, vec![0, 1, 2, 3, 4]);
  574. let v: Vec<usize> = vec![0, 1, 2];
  575. let r = v.into_iter().pad_using(1, |_| panic!());
  576. it::assert_equal(r, vec![0, 1, 2]);
  577. }
  578. #[test]
  579. fn group_by() {
  580. for (ch1, sub) in &"AABBCCC".chars().group_by(|&x| x) {
  581. for ch2 in sub {
  582. assert_eq!(ch1, ch2);
  583. }
  584. }
  585. for (ch1, sub) in &"AAABBBCCCCDDDD".chars().group_by(|&x| x) {
  586. for ch2 in sub {
  587. assert_eq!(ch1, ch2);
  588. if ch1 == 'C' {
  589. break;
  590. }
  591. }
  592. }
  593. let toupper = |ch: &char| ch.to_uppercase().nth(0).unwrap();
  594. // try all possible orderings
  595. for indices in permutohedron::Heap::new(&mut [0, 1, 2, 3]) {
  596. let groups = "AaaBbbccCcDDDD".chars().group_by(&toupper);
  597. let mut subs = groups.into_iter().collect_vec();
  598. for &idx in &indices[..] {
  599. let (key, text) = match idx {
  600. 0 => ('A', "Aaa".chars()),
  601. 1 => ('B', "Bbb".chars()),
  602. 2 => ('C', "ccCc".chars()),
  603. 3 => ('D', "DDDD".chars()),
  604. _ => unreachable!(),
  605. };
  606. assert_eq!(key, subs[idx].0);
  607. it::assert_equal(&mut subs[idx].1, text);
  608. }
  609. }
  610. let groups = "AAABBBCCCCDDDD".chars().group_by(|&x| x);
  611. let mut subs = groups.into_iter().map(|(_, g)| g).collect_vec();
  612. let sd = subs.pop().unwrap();
  613. let sc = subs.pop().unwrap();
  614. let sb = subs.pop().unwrap();
  615. let sa = subs.pop().unwrap();
  616. for (a, b, c, d) in multizip((sa, sb, sc, sd)) {
  617. assert_eq!(a, 'A');
  618. assert_eq!(b, 'B');
  619. assert_eq!(c, 'C');
  620. assert_eq!(d, 'D');
  621. }
  622. // check that the key closure is called exactly n times
  623. {
  624. let mut ntimes = 0;
  625. let text = "AABCCC";
  626. for (_, sub) in &text.chars().group_by(|&x| { ntimes += 1; x}) {
  627. for _ in sub {
  628. }
  629. }
  630. assert_eq!(ntimes, text.len());
  631. }
  632. {
  633. let mut ntimes = 0;
  634. let text = "AABCCC";
  635. for _ in &text.chars().group_by(|&x| { ntimes += 1; x}) {
  636. }
  637. assert_eq!(ntimes, text.len());
  638. }
  639. {
  640. let text = "ABCCCDEEFGHIJJKK";
  641. let gr = text.chars().group_by(|&x| x);
  642. it::assert_equal(gr.into_iter().flat_map(|(_, sub)| sub), text.chars());
  643. }
  644. }
  645. #[test]
  646. fn group_by_lazy_2() {
  647. let data = vec![0, 1];
  648. let groups = data.iter().group_by(|k| *k);
  649. let gs = groups.into_iter().collect_vec();
  650. it::assert_equal(data.iter(), gs.into_iter().flat_map(|(_k, g)| g));
  651. let data = vec![0, 1, 1, 0, 0];
  652. let groups = data.iter().group_by(|k| *k);
  653. let mut gs = groups.into_iter().collect_vec();
  654. gs[1..].reverse();
  655. it::assert_equal(&[0, 0, 0, 1, 1], gs.into_iter().flat_map(|(_, g)| g));
  656. let grouper = data.iter().group_by(|k| *k);
  657. let mut groups = Vec::new();
  658. for (k, group) in &grouper {
  659. if *k == 1 {
  660. groups.push(group);
  661. }
  662. }
  663. it::assert_equal(&mut groups[0], &[1, 1]);
  664. let data = vec![0, 0, 0, 1, 1, 0, 0, 2, 2, 3, 3];
  665. let grouper = data.iter().group_by(|k| *k);
  666. let mut groups = Vec::new();
  667. for (i, (_, group)) in grouper.into_iter().enumerate() {
  668. if i < 2 {
  669. groups.push(group);
  670. } else if i < 4 {
  671. for _ in group {
  672. }
  673. } else {
  674. groups.push(group);
  675. }
  676. }
  677. it::assert_equal(&mut groups[0], &[0, 0, 0]);
  678. it::assert_equal(&mut groups[1], &[1, 1]);
  679. it::assert_equal(&mut groups[2], &[3, 3]);
  680. // use groups as chunks
  681. let data = vec![0, 0, 0, 1, 1, 0, 0, 2, 2, 3, 3];
  682. let mut i = 0;
  683. let grouper = data.iter().group_by(move |_| { let k = i / 3; i += 1; k });
  684. for (i, group) in &grouper {
  685. match i {
  686. 0 => it::assert_equal(group, &[0, 0, 0]),
  687. 1 => it::assert_equal(group, &[1, 1, 0]),
  688. 2 => it::assert_equal(group, &[0, 2, 2]),
  689. 3 => it::assert_equal(group, &[3, 3]),
  690. _ => unreachable!(),
  691. }
  692. }
  693. }
  694. #[test]
  695. fn group_by_lazy_3() {
  696. // test consuming each group on the lap after it was produced
  697. let data = vec![0, 0, 0, 1, 1, 0, 0, 1, 1, 2, 2];
  698. let grouper = data.iter().group_by(|elt| *elt);
  699. let mut last = None;
  700. for (key, group) in &grouper {
  701. if let Some(gr) = last.take() {
  702. for elt in gr {
  703. assert!(elt != key && i32::abs(elt - key) == 1);
  704. }
  705. }
  706. last = Some(group);
  707. }
  708. }
  709. #[test]
  710. fn chunks() {
  711. let data = vec![0, 0, 0, 1, 1, 0, 0, 2, 2, 3, 3];
  712. let grouper = data.iter().chunks(3);
  713. for (i, chunk) in grouper.into_iter().enumerate() {
  714. match i {
  715. 0 => it::assert_equal(chunk, &[0, 0, 0]),
  716. 1 => it::assert_equal(chunk, &[1, 1, 0]),
  717. 2 => it::assert_equal(chunk, &[0, 2, 2]),
  718. 3 => it::assert_equal(chunk, &[3, 3]),
  719. _ => unreachable!(),
  720. }
  721. }
  722. }
  723. #[test]
  724. fn concat_empty() {
  725. let data: Vec<Vec<()>> = Vec::new();
  726. assert_eq!(data.into_iter().concat(), Vec::new())
  727. }
  728. #[test]
  729. fn concat_non_empty() {
  730. let data = vec![vec![1,2,3], vec![4,5,6], vec![7,8,9]];
  731. assert_eq!(data.into_iter().concat(), vec![1,2,3,4,5,6,7,8,9])
  732. }
  733. #[test]
  734. fn combinations() {
  735. assert!((1..3).combinations(5).next().is_none());
  736. let it = (1..3).combinations(2);
  737. it::assert_equal(it, vec![
  738. vec![1, 2],
  739. ]);
  740. let it = (1..5).combinations(2);
  741. it::assert_equal(it, vec![
  742. vec![1, 2],
  743. vec![1, 3],
  744. vec![1, 4],
  745. vec![2, 3],
  746. vec![2, 4],
  747. vec![3, 4],
  748. ]);
  749. it::assert_equal((0..0).tuple_combinations::<(_, _)>(), <Vec<_>>::new());
  750. it::assert_equal((0..1).tuple_combinations::<(_, _)>(), <Vec<_>>::new());
  751. it::assert_equal((0..2).tuple_combinations::<(_, _)>(), vec![(0, 1)]);
  752. it::assert_equal((0..0).combinations(2), <Vec<Vec<_>>>::new());
  753. it::assert_equal((0..1).combinations(1), vec![vec![0]]);
  754. it::assert_equal((0..2).combinations(1), vec![vec![0], vec![1]]);
  755. it::assert_equal((0..2).combinations(2), vec![vec![0, 1]]);
  756. }
  757. #[test]
  758. fn combinations_of_too_short() {
  759. for i in 1..10 {
  760. assert!((0..0).combinations(i).next().is_none());
  761. assert!((0..i - 1).combinations(i).next().is_none());
  762. }
  763. }
  764. #[test]
  765. fn combinations_zero() {
  766. it::assert_equal((1..3).combinations(0), vec![vec![]]);
  767. it::assert_equal((0..0).combinations(0), vec![vec![]]);
  768. }
  769. #[test]
  770. fn permutations_zero() {
  771. it::assert_equal((1..3).permutations(0), vec![vec![]]);
  772. it::assert_equal((0..0).permutations(0), vec![vec![]]);
  773. }
  774. #[test]
  775. fn combinations_with_replacement() {
  776. // Pool smaller than n
  777. it::assert_equal((0..1).combinations_with_replacement(2), vec![vec![0, 0]]);
  778. // Pool larger than n
  779. it::assert_equal(
  780. (0..3).combinations_with_replacement(2),
  781. vec![
  782. vec![0, 0],
  783. vec![0, 1],
  784. vec![0, 2],
  785. vec![1, 1],
  786. vec![1, 2],
  787. vec![2, 2],
  788. ],
  789. );
  790. // Zero size
  791. it::assert_equal(
  792. (0..3).combinations_with_replacement(0),
  793. vec![vec![]],
  794. );
  795. // Zero size on empty pool
  796. it::assert_equal(
  797. (0..0).combinations_with_replacement(0),
  798. vec![vec![]],
  799. );
  800. // Empty pool
  801. it::assert_equal(
  802. (0..0).combinations_with_replacement(2),
  803. <Vec<Vec<_>>>::new(),
  804. );
  805. }
  806. #[test]
  807. fn powerset() {
  808. it::assert_equal((0..0).powerset(), vec![vec![]]);
  809. it::assert_equal((0..1).powerset(), vec![vec![], vec![0]]);
  810. it::assert_equal((0..2).powerset(), vec![vec![], vec![0], vec![1], vec![0, 1]]);
  811. it::assert_equal((0..3).powerset(), vec![
  812. vec![],
  813. vec![0], vec![1], vec![2],
  814. vec![0, 1], vec![0, 2], vec![1, 2],
  815. vec![0, 1, 2]
  816. ]);
  817. assert_eq!((0..4).powerset().count(), 1 << 4);
  818. assert_eq!((0..8).powerset().count(), 1 << 8);
  819. assert_eq!((0..16).powerset().count(), 1 << 16);
  820. }
  821. #[test]
  822. fn diff_mismatch() {
  823. let a = vec![1, 2, 3, 4];
  824. let b = vec![1.0, 5.0, 3.0, 4.0];
  825. let b_map = b.into_iter().map(|f| f as i32);
  826. let diff = it::diff_with(a.iter(), b_map, |a, b| *a == b);
  827. assert!(match diff {
  828. Some(it::Diff::FirstMismatch(1, _, from_diff)) =>
  829. from_diff.collect::<Vec<_>>() == vec![5, 3, 4],
  830. _ => false,
  831. });
  832. }
  833. #[test]
  834. fn diff_longer() {
  835. let a = vec![1, 2, 3, 4];
  836. let b = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
  837. let b_map = b.into_iter().map(|f| f as i32);
  838. let diff = it::diff_with(a.iter(), b_map, |a, b| *a == b);
  839. assert!(match diff {
  840. Some(it::Diff::Longer(_, remaining)) =>
  841. remaining.collect::<Vec<_>>() == vec![5, 6],
  842. _ => false,
  843. });
  844. }
  845. #[test]
  846. fn diff_shorter() {
  847. let a = vec![1, 2, 3, 4];
  848. let b = vec![1.0, 2.0];
  849. let b_map = b.into_iter().map(|f| f as i32);
  850. let diff = it::diff_with(a.iter(), b_map, |a, b| *a == b);
  851. assert!(match diff {
  852. Some(it::Diff::Shorter(len, _)) => len == 2,
  853. _ => false,
  854. });
  855. }
  856. #[test]
  857. fn minmax() {
  858. use std::cmp::Ordering;
  859. use crate::it::MinMaxResult;
  860. // A peculiar type: Equality compares both tuple items, but ordering only the
  861. // first item. This is so we can check the stability property easily.
  862. #[derive(Clone, Debug, PartialEq, Eq)]
  863. struct Val(u32, u32);
  864. impl PartialOrd<Val> for Val {
  865. fn partial_cmp(&self, other: &Val) -> Option<Ordering> {
  866. self.0.partial_cmp(&other.0)
  867. }
  868. }
  869. impl Ord for Val {
  870. fn cmp(&self, other: &Val) -> Ordering {
  871. self.0.cmp(&other.0)
  872. }
  873. }
  874. assert_eq!(None::<Option<u32>>.iter().minmax(), MinMaxResult::NoElements);
  875. assert_eq!(Some(1u32).iter().minmax(), MinMaxResult::OneElement(&1));
  876. let data = vec![Val(0, 1), Val(2, 0), Val(0, 2), Val(1, 0), Val(2, 1)];
  877. let minmax = data.iter().minmax();
  878. assert_eq!(minmax, MinMaxResult::MinMax(&Val(0, 1), &Val(2, 1)));
  879. let (min, max) = data.iter().minmax_by_key(|v| v.1).into_option().unwrap();
  880. assert_eq!(min, &Val(2, 0));
  881. assert_eq!(max, &Val(0, 2));
  882. let (min, max) = data.iter().minmax_by(|x, y| x.1.cmp(&y.1)).into_option().unwrap();
  883. assert_eq!(min, &Val(2, 0));
  884. assert_eq!(max, &Val(0, 2));
  885. }
  886. #[test]
  887. fn format() {
  888. let data = [0, 1, 2, 3];
  889. let ans1 = "0, 1, 2, 3";
  890. let ans2 = "0--1--2--3";
  891. let t1 = format!("{}", data.iter().format(", "));
  892. assert_eq!(t1, ans1);
  893. let t2 = format!("{:?}", data.iter().format("--"));
  894. assert_eq!(t2, ans2);
  895. let dataf = [1.1, 2.71828, -22.];
  896. let t3 = format!("{:.2e}", dataf.iter().format(", "));
  897. assert_eq!(t3, "1.10e0, 2.72e0, -2.20e1");
  898. }
  899. #[test]
  900. fn while_some() {
  901. let ns = (1..10).map(|x| if x % 5 != 0 { Some(x) } else { None })
  902. .while_some();
  903. it::assert_equal(ns, vec![1, 2, 3, 4]);
  904. }
  905. #[allow(deprecated)]
  906. #[test]
  907. fn fold_while() {
  908. let mut iterations = 0;
  909. let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  910. let sum = vec.into_iter().fold_while(0, |acc, item| {
  911. iterations += 1;
  912. let new_sum = acc.clone() + item;
  913. if new_sum <= 20 {
  914. FoldWhile::Continue(new_sum)
  915. } else {
  916. FoldWhile::Done(acc)
  917. }
  918. }).into_inner();
  919. assert_eq!(iterations, 6);
  920. assert_eq!(sum, 15);
  921. }
  922. #[test]
  923. fn tree_fold1() {
  924. let x = [
  925. "",
  926. "0",
  927. "0 1 x",
  928. "0 1 x 2 x",
  929. "0 1 x 2 3 x x",
  930. "0 1 x 2 3 x x 4 x",
  931. "0 1 x 2 3 x x 4 5 x x",
  932. "0 1 x 2 3 x x 4 5 x 6 x x",
  933. "0 1 x 2 3 x x 4 5 x 6 7 x x x",
  934. "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 x",
  935. "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x x",
  936. "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x 10 x x",
  937. "0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x 10 11 x x x",
  938. "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",
  939. "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",
  940. "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",
  941. "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",
  942. ];
  943. for (i, &s) in x.iter().enumerate() {
  944. let expected = if s == "" { None } else { Some(s.to_string()) };
  945. let num_strings = (0..i).map(|x| x.to_string());
  946. let actual = num_strings.tree_fold1(|a, b| format!("{} {} x", a, b));
  947. assert_eq!(actual, expected);
  948. }
  949. }
  950. #[test]
  951. fn exactly_one_question_mark_syntax_works() {
  952. exactly_one_question_mark_return().unwrap_err();
  953. }
  954. fn exactly_one_question_mark_return() -> Result<(), ExactlyOneError<std::slice::Iter<'static, ()>>> {
  955. [].iter().exactly_one()?;
  956. Ok(())
  957. }
  958. #[test]
  959. fn multiunzip() {
  960. let (a, b, c): (Vec<_>, Vec<_>, Vec<_>) = [(0, 1, 2), (3, 4, 5), (6, 7, 8)].iter().cloned().multiunzip();
  961. assert_eq!((a, b, c), (vec![0, 3, 6], vec![1, 4, 7], vec![2, 5, 8]));
  962. let (): () = [(), (), ()].iter().cloned().multiunzip();
  963. let t: (Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>) = [(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)].iter().cloned().multiunzip();
  964. assert_eq!(t, (vec![0], vec![1], vec![2], vec![3], vec![4], vec![5], vec![6], vec![7], vec![8], vec![9], vec![10], vec![11]));
  965. }