@@ -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 :: < 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
+
205
309
#[ test]
206
310
fn test_windows_count ( ) {
207
311
let v: & [ i32 ] = & [ 0 , 1 , 2 , 3 , 4 , 5 ] ;
0 commit comments