Add unit tests for exact_chunks/exact_chunks_mut · rust-lang/rust@5f4fc82 (original) (raw)
`@@ -202,6 +202,110 @@ fn test_chunks_mut_zip() {
`
202
202
`assert_eq!(v1, [13, 14, 19, 20, 14]);
`
203
203
`}
`
204
204
``
``
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::() + b.iter().sum::())
`
``
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::();
`
``
302
`+
for v in a {
`
``
303
`+
*v += sum;
`
``
304
`+
}
`
``
305
`+
}
`
``
306
`+
assert_eq!(v1, [13, 14, 19, 20, 4]);
`
``
307
`+
}
`
``
308
+
205
309
`#[test]
`
206
310
`fn test_windows_count() {
`
207
311
`let v: &[i32] = &[0, 1, 2, 3, 4, 5];
`