1 extern crate itertools;
2
3 use itertools::Stride;
4 use itertools::StrideMut;
5 use itertools::equal;
6
7 #[test]
mut_stride()8 fn mut_stride() {
9 let mut xs = vec![1, 1, 1, 1, 1, 1];
10 for x in StrideMut::from_slice(&mut *xs, 2) {
11 *x = 0;
12 }
13 assert_eq!(xs, vec![0, 1, 0, 1, 0, 1]);
14 }
15
16 #[test]
mut_stride_compose()17 fn mut_stride_compose() {
18 let mut xs = vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
19 {
20 let iter1 = StrideMut::from_slice(&mut *xs, 2);
21 let iter2 = StrideMut::from_stride(iter1, 3);
22 for x in iter2 {
23 *x = 0;
24 }
25 }
26 assert_eq!(xs, vec![0, 1, 1, 1, 1, 1, 0, 1, 1, 1]);
27
28 let mut vs = vec![1, 2, 3];
29 let mut it = StrideMut::from_slice(&mut *vs, 1);
30 {
31 assert_eq!(it.get_mut(3), None);
32 assert_eq!(it.get_mut(1), Some(&mut 2));
33 }
34 }
35
36 #[test]
stride_uneven()37 fn stride_uneven() {
38 let xs = &[7, 9, 8];
39 let it = Stride::from_slice(xs, 2);
40 assert!(it.size_hint() == (2, Some(2)));
41 assert!(equal(it, &[7, 8]));
42
43 let xs = &[7, 9, 8, 10];
44 let it = Stride::from_slice(&xs[1..], 2);
45 assert!(it.size_hint() == (2, Some(2)));
46 assert!(equal(it, &[9, 10]));
47 }
48
49 #[test]
stride_compose()50 fn stride_compose() {
51 let xs = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
52 let odds = Stride::from_slice(xs, 2);
53 let it = Stride::from_stride(odds, 2);
54 assert!(equal(it, &[1, 5, 9]));
55
56 let xs = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
57 let evens = Stride::from_slice(&xs[1..], 2);
58 let it = Stride::from_stride(evens, 2);
59 assert!(equal(it, &[2, 6]));
60
61 let xs = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
62 let evens = Stride::from_slice(&xs[1..], 2);
63 let it = Stride::from_stride(evens, 1);
64 assert!(equal(it, &[2, 4, 6, 8]));
65
66 let xs = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
67 let mut odds = Stride::from_slice(xs, 2);
68 odds.swap_ends();
69 let it = Stride::from_stride(odds, 2);
70 assert!(equal(it, &[9, 5, 1]));
71
72 let xs = &[1, 2, 3];
73 let every = Stride::from_slice(xs, 1);
74 assert_eq!(every.len(), 3);
75 assert_eq!(every.get(1), Some(&2));
76 let odds = Stride::from_stride(every, 2);
77 assert_eq!(odds.len(), 2);
78 assert_eq!(odds.get(0), Some(&1));
79 assert_eq!(odds.get(1), Some(&3));
80 assert_eq!(odds.get(2), None);
81 assert!(equal(odds, &[1, 3]));
82
83 let xs = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
84 let evens = Stride::from_slice(&xs[1..], 2);
85 let it = Stride::from_stride(evens, -2);
86 assert!(equal(it, &[8, 4]));
87 }
88
89 #[test]
from_stride_empty()90 fn from_stride_empty()
91 {
92 let xs = &[1, 2, 3, 4, 5, 6, 7, 8, 9];
93 let mut odds = Stride::from_slice(xs, 2);
94 odds.by_ref().count();
95 assert!(odds.len() == 0);
96 assert!(odds.next().is_none());
97 let mut it = Stride::from_stride(odds, 2);
98 assert!(it.len() == 0);
99 assert!(it.next().is_none());
100 }
101
102 #[test]
stride()103 fn stride() {
104 let xs: &[u8] = &[];
105 let mut it = Stride::from_slice(xs, 1);
106 assert!(it.size_hint() == (0, Some(0)));
107 assert!(it.next().is_none());
108
109 let xs = &[7, 9, 8, 10];
110 let it = Stride::from_slice(xs, 2);
111 assert!(it.size_hint() == (2, Some(2)));
112 assert!(equal(it, &[7, 8]));
113
114 let it = Stride::from_slice(xs, 2).rev();
115 assert!(it.size_hint() == (2, Some(2)));
116 assert!(equal(it, &[8, 7]));
117
118 let xs = &[7, 9, 8, 10];
119 let it = Stride::from_slice(xs, 1);
120 assert!(it.size_hint() == (4, Some(4)));
121 assert!(equal(it, &[7, 9, 8, 10]));
122
123 let it = Stride::from_slice(xs, 1).rev();
124 assert!(it.size_hint() == (4, Some(4)));
125 assert!(equal(it, &[10, 8, 9, 7]));
126
127 let mut it = Stride::from_slice(xs, 2);
128 it.swap_ends();
129 assert!(it.size_hint() == (2, Some(2)));
130 assert!(equal(it, &[8, 7]));
131
132 let it = Stride::from_slice(xs, -2);
133 assert_eq!(it.size_hint(), (2, Some(2)));
134 assert!(equal(it, &[10, 9]));
135 }
136
137 #[test]
stride_index()138 fn stride_index() {
139 let xs = &[7, 9, 8, 10];
140 let it = Stride::from_slice(xs, 2);
141 assert_eq!(it[0], 7);
142 assert_eq!(it[1], 8);
143 }
144
145 #[test]
146 #[should_panic]
stride_index_fail()147 fn stride_index_fail() {
148 let xs = &[7, 9, 8, 10];
149 let it = Stride::from_slice(xs, 2);
150 let _ = it[2];
151 }
152