Skip to content

Commit 5f4fc82

Browse files
committed
Add unit tests for exact_chunks/exact_chunks_mut
These are basically modified copies of the chunks/chunks_mut tests.
1 parent ed77483 commit 5f4fc82

File tree

4 files changed

+162
-0
lines changed

4 files changed

+162
-0
lines changed

src/liballoc/tests/lib.rs

+1
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,7 @@
3030
#![feature(string_retain)]
3131
#![feature(unboxed_closures)]
3232
#![feature(unicode)]
33+
#![feature(exact_chunks)]
3334

3435
extern crate alloc_system;
3536
extern crate std_unicode;

src/liballoc/tests/slice.rs

+56
Original file line numberDiff line numberDiff line change
@@ -910,6 +910,30 @@ fn test_chunksator_0() {
910910
let _it = v.chunks(0);
911911
}
912912

913+
#[test]
914+
fn test_exact_chunksator() {
915+
let v = &[1, 2, 3, 4, 5];
916+
917+
assert_eq!(v.exact_chunks(2).len(), 2);
918+
919+
let chunks: &[&[_]] = &[&[1, 2], &[3, 4]];
920+
assert_eq!(v.exact_chunks(2).collect::<Vec<_>>(), chunks);
921+
let chunks: &[&[_]] = &[&[1, 2, 3]];
922+
assert_eq!(v.exact_chunks(3).collect::<Vec<_>>(), chunks);
923+
let chunks: &[&[_]] = &[];
924+
assert_eq!(v.exact_chunks(6).collect::<Vec<_>>(), chunks);
925+
926+
let chunks: &[&[_]] = &[&[3, 4], &[1, 2]];
927+
assert_eq!(v.exact_chunks(2).rev().collect::<Vec<_>>(), chunks);
928+
}
929+
930+
#[test]
931+
#[should_panic]
932+
fn test_exact_chunksator_0() {
933+
let v = &[1, 2, 3, 4];
934+
let _it = v.exact_chunks(0);
935+
}
936+
913937
#[test]
914938
fn test_reverse_part() {
915939
let mut values = [1, 2, 3, 4, 5];
@@ -1146,6 +1170,38 @@ fn test_mut_chunks_0() {
11461170
let _it = v.chunks_mut(0);
11471171
}
11481172

1173+
#[test]
1174+
fn test_mut_exact_chunks() {
1175+
let mut v = [0, 1, 2, 3, 4, 5, 6];
1176+
assert_eq!(v.exact_chunks_mut(2).len(), 3);
1177+
for (i, chunk) in v.exact_chunks_mut(3).enumerate() {
1178+
for x in chunk {
1179+
*x = i as u8;
1180+
}
1181+
}
1182+
let result = [0, 0, 0, 1, 1, 1, 6];
1183+
assert_eq!(v, result);
1184+
}
1185+
1186+
#[test]
1187+
fn test_mut_exact_chunks_rev() {
1188+
let mut v = [0, 1, 2, 3, 4, 5, 6];
1189+
for (i, chunk) in v.exact_chunks_mut(3).rev().enumerate() {
1190+
for x in chunk {
1191+
*x = i as u8;
1192+
}
1193+
}
1194+
let result = [1, 1, 1, 0, 0, 0, 6];
1195+
assert_eq!(v, result);
1196+
}
1197+
1198+
#[test]
1199+
#[should_panic]
1200+
fn test_mut_exact_chunks_0() {
1201+
let mut v = [1, 2, 3, 4];
1202+
let _it = v.exact_chunks_mut(0);
1203+
}
1204+
11491205
#[test]
11501206
fn test_mut_last() {
11511207
let mut x = [1, 2, 3, 4, 5];

src/libcore/tests/lib.rs

+1
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,7 @@
4242
#![feature(try_from)]
4343
#![feature(try_trait)]
4444
#![feature(unique)]
45+
#![feature(exact_chunks)]
4546

4647
extern crate core;
4748
extern crate test;

src/libcore/tests/slice.rs

+104
Original file line numberDiff line numberDiff line change
@@ -202,6 +202,110 @@ fn test_chunks_mut_zip() {
202202
assert_eq!(v1, [13, 14, 19, 20, 14]);
203203
}
204204

205+
#[test]
206+
fn test_exact_chunks_count() {
207+
let v: &[i32] = &[0, 1, 2, 3, 4, 5];
208+
let c = v.exact_chunks(3);
209+
assert_eq!(c.count(), 2);
210+
211+
let v2: &[i32] = &[0, 1, 2, 3, 4];
212+
let c2 = v2.exact_chunks(2);
213+
assert_eq!(c2.count(), 2);
214+
215+
let v3: &[i32] = &[];
216+
let c3 = v3.exact_chunks(2);
217+
assert_eq!(c3.count(), 0);
218+
}
219+
220+
#[test]
221+
fn test_exact_chunks_nth() {
222+
let v: &[i32] = &[0, 1, 2, 3, 4, 5];
223+
let mut c = v.exact_chunks(2);
224+
assert_eq!(c.nth(1).unwrap(), &[2, 3]);
225+
assert_eq!(c.next().unwrap(), &[4, 5]);
226+
227+
let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
228+
let mut c2 = v2.exact_chunks(3);
229+
assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
230+
assert_eq!(c2.next(), None);
231+
}
232+
233+
#[test]
234+
fn test_exact_chunks_last() {
235+
let v: &[i32] = &[0, 1, 2, 3, 4, 5];
236+
let c = v.exact_chunks(2);
237+
assert_eq!(c.last().unwrap(), &[4, 5]);
238+
239+
let v2: &[i32] = &[0, 1, 2, 3, 4];
240+
let c2 = v2.exact_chunks(2);
241+
assert_eq!(c2.last().unwrap(), &[2, 3]);
242+
}
243+
244+
#[test]
245+
fn test_exact_chunks_zip() {
246+
let v1: &[i32] = &[0, 1, 2, 3, 4];
247+
let v2: &[i32] = &[6, 7, 8, 9, 10];
248+
249+
let res = v1.exact_chunks(2)
250+
.zip(v2.exact_chunks(2))
251+
.map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
252+
.collect::<Vec<_>>();
253+
assert_eq!(res, vec![14, 22]);
254+
}
255+
256+
#[test]
257+
fn test_exact_chunks_mut_count() {
258+
let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
259+
let c = v.exact_chunks_mut(3);
260+
assert_eq!(c.count(), 2);
261+
262+
let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
263+
let c2 = v2.exact_chunks_mut(2);
264+
assert_eq!(c2.count(), 2);
265+
266+
let v3: &mut [i32] = &mut [];
267+
let c3 = v3.exact_chunks_mut(2);
268+
assert_eq!(c3.count(), 0);
269+
}
270+
271+
#[test]
272+
fn test_exact_chunks_mut_nth() {
273+
let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
274+
let mut c = v.exact_chunks_mut(2);
275+
assert_eq!(c.nth(1).unwrap(), &[2, 3]);
276+
assert_eq!(c.next().unwrap(), &[4, 5]);
277+
278+
let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
279+
let mut c2 = v2.exact_chunks_mut(3);
280+
assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
281+
assert_eq!(c2.next(), None);
282+
}
283+
284+
#[test]
285+
fn test_exact_chunks_mut_last() {
286+
let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
287+
let c = v.exact_chunks_mut(2);
288+
assert_eq!(c.last().unwrap(), &[4, 5]);
289+
290+
let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
291+
let c2 = v2.exact_chunks_mut(2);
292+
assert_eq!(c2.last().unwrap(), &[2, 3]);
293+
}
294+
295+
#[test]
296+
fn test_exact_chunks_mut_zip() {
297+
let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
298+
let v2: &[i32] = &[6, 7, 8, 9, 10];
299+
300+
for (a, b) in v1.exact_chunks_mut(2).zip(v2.exact_chunks(2)) {
301+
let sum = b.iter().sum::<i32>();
302+
for v in a {
303+
*v += sum;
304+
}
305+
}
306+
assert_eq!(v1, [13, 14, 19, 20, 4]);
307+
}
308+
205309
#[test]
206310
fn test_windows_count() {
207311
let v: &[i32] = &[0, 1, 2, 3, 4, 5];

0 commit comments

Comments
 (0)