@@ -366,3 +366,191 @@ fn test_contains() {
366366
367367 assert ! ( !l. contains( & 3 ) ) ;
368368}
369+
370+ #[ test]
371+ fn drain_filter_empty ( ) {
372+ let mut list: LinkedList < i32 > = LinkedList :: new ( ) ;
373+
374+ {
375+ let mut iter = list. drain_filter ( |_| true ) ;
376+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( 0 ) ) ) ;
377+ assert_eq ! ( iter. next( ) , None ) ;
378+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( 0 ) ) ) ;
379+ assert_eq ! ( iter. next( ) , None ) ;
380+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( 0 ) ) ) ;
381+ }
382+
383+ assert_eq ! ( list. len( ) , 0 ) ;
384+ assert_eq ! ( list. into_iter( ) . collect:: <Vec <_>>( ) , vec![ ] ) ;
385+ }
386+
387+ #[ test]
388+ fn drain_filter_zst ( ) {
389+ let mut list: LinkedList < _ > = vec ! [ ( ) , ( ) , ( ) , ( ) , ( ) ] . into_iter ( ) . collect ( ) ;
390+ let initial_len = list. len ( ) ;
391+ let mut count = 0 ;
392+
393+ {
394+ let mut iter = list. drain_filter ( |_| true ) ;
395+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( initial_len) ) ) ;
396+ while let Some ( _) = iter. next ( ) {
397+ count += 1 ;
398+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( initial_len - count) ) ) ;
399+ }
400+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( 0 ) ) ) ;
401+ assert_eq ! ( iter. next( ) , None ) ;
402+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( 0 ) ) ) ;
403+ }
404+
405+ assert_eq ! ( count, initial_len) ;
406+ assert_eq ! ( list. len( ) , 0 ) ;
407+ assert_eq ! ( list. into_iter( ) . collect:: <Vec <_>>( ) , vec![ ] ) ;
408+ }
409+
410+ #[ test]
411+ fn drain_filter_false ( ) {
412+ let mut list: LinkedList < _ > = vec ! [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ] . into_iter ( ) . collect ( ) ;
413+
414+ let initial_len = list. len ( ) ;
415+ let mut count = 0 ;
416+
417+ {
418+ let mut iter = list. drain_filter ( |_| false ) ;
419+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( initial_len) ) ) ;
420+ for _ in iter. by_ref ( ) {
421+ count += 1 ;
422+ }
423+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( 0 ) ) ) ;
424+ assert_eq ! ( iter. next( ) , None ) ;
425+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( 0 ) ) ) ;
426+ }
427+
428+ assert_eq ! ( count, 0 ) ;
429+ assert_eq ! ( list. len( ) , initial_len) ;
430+ assert_eq ! ( list. into_iter( ) . collect:: <Vec <_>>( ) , vec![ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ] ) ;
431+ }
432+
433+ #[ test]
434+ fn drain_filter_true ( ) {
435+ let mut list: LinkedList < _ > = vec ! [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ] . into_iter ( ) . collect ( ) ;
436+
437+ let initial_len = list. len ( ) ;
438+ let mut count = 0 ;
439+
440+ {
441+ let mut iter = list. drain_filter ( |_| true ) ;
442+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( initial_len) ) ) ;
443+ while let Some ( _) = iter. next ( ) {
444+ count += 1 ;
445+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( initial_len - count) ) ) ;
446+ }
447+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( 0 ) ) ) ;
448+ assert_eq ! ( iter. next( ) , None ) ;
449+ assert_eq ! ( iter. size_hint( ) , ( 0 , Some ( 0 ) ) ) ;
450+ }
451+
452+ assert_eq ! ( count, initial_len) ;
453+ assert_eq ! ( list. len( ) , 0 ) ;
454+ assert_eq ! ( list. into_iter( ) . collect:: <Vec <_>>( ) , vec![ ] ) ;
455+ }
456+
457+ #[ test]
458+ fn drain_filter_complex ( ) {
459+
460+ { // [+xxx++++++xxxxx++++x+x++]
461+ let mut list = vec ! [
462+ 1 ,
463+ 2 , 4 , 6 ,
464+ 7 , 9 , 11 , 13 , 15 , 17 ,
465+ 18 , 20 , 22 , 24 , 26 ,
466+ 27 , 29 , 31 , 33 ,
467+ 34 ,
468+ 35 ,
469+ 36 ,
470+ 37 , 39
471+ ] . into_iter ( ) . collect :: < LinkedList < _ > > ( ) ;
472+
473+ let removed = list. drain_filter ( |x| * x % 2 == 0 ) . collect :: < Vec < _ > > ( ) ;
474+ assert_eq ! ( removed. len( ) , 10 ) ;
475+ assert_eq ! ( removed, vec![ 2 , 4 , 6 , 18 , 20 , 22 , 24 , 26 , 34 , 36 ] ) ;
476+
477+ assert_eq ! ( list. len( ) , 14 ) ;
478+ assert_eq ! (
479+ list. into_iter( ) . collect:: <Vec <_>>( ) ,
480+ vec![ 1 , 7 , 9 , 11 , 13 , 15 , 17 , 27 , 29 , 31 , 33 , 35 , 37 , 39 ]
481+ ) ;
482+ }
483+
484+ { // [xxx++++++xxxxx++++x+x++]
485+ let mut list = vec ! [
486+ 2 , 4 , 6 ,
487+ 7 , 9 , 11 , 13 , 15 , 17 ,
488+ 18 , 20 , 22 , 24 , 26 ,
489+ 27 , 29 , 31 , 33 ,
490+ 34 ,
491+ 35 ,
492+ 36 ,
493+ 37 , 39
494+ ] . into_iter ( ) . collect :: < LinkedList < _ > > ( ) ;
495+
496+ let removed = list. drain_filter ( |x| * x % 2 == 0 ) . collect :: < Vec < _ > > ( ) ;
497+ assert_eq ! ( removed. len( ) , 10 ) ;
498+ assert_eq ! ( removed, vec![ 2 , 4 , 6 , 18 , 20 , 22 , 24 , 26 , 34 , 36 ] ) ;
499+
500+ assert_eq ! ( list. len( ) , 13 ) ;
501+ assert_eq ! (
502+ list. into_iter( ) . collect:: <Vec <_>>( ) ,
503+ vec![ 7 , 9 , 11 , 13 , 15 , 17 , 27 , 29 , 31 , 33 , 35 , 37 , 39 ]
504+ ) ;
505+ }
506+
507+ { // [xxx++++++xxxxx++++x+x]
508+ let mut list = vec ! [
509+ 2 , 4 , 6 ,
510+ 7 , 9 , 11 , 13 , 15 , 17 ,
511+ 18 , 20 , 22 , 24 , 26 ,
512+ 27 , 29 , 31 , 33 ,
513+ 34 ,
514+ 35 ,
515+ 36
516+ ] . into_iter ( ) . collect :: < LinkedList < _ > > ( ) ;
517+
518+ let removed = list. drain_filter ( |x| * x % 2 == 0 ) . collect :: < Vec < _ > > ( ) ;
519+ assert_eq ! ( removed. len( ) , 10 ) ;
520+ assert_eq ! ( removed, vec![ 2 , 4 , 6 , 18 , 20 , 22 , 24 , 26 , 34 , 36 ] ) ;
521+
522+ assert_eq ! ( list. len( ) , 11 ) ;
523+ assert_eq ! (
524+ list. into_iter( ) . collect:: <Vec <_>>( ) ,
525+ vec![ 7 , 9 , 11 , 13 , 15 , 17 , 27 , 29 , 31 , 33 , 35 ]
526+ ) ;
527+ }
528+
529+ { // [xxxxxxxxxx+++++++++++]
530+ let mut list = vec ! [
531+ 2 , 4 , 6 , 8 , 10 , 12 , 14 , 16 , 18 , 20 ,
532+ 1 , 3 , 5 , 7 , 9 , 11 , 13 , 15 , 17 , 19
533+ ] . into_iter ( ) . collect :: < LinkedList < _ > > ( ) ;
534+
535+ let removed = list. drain_filter ( |x| * x % 2 == 0 ) . collect :: < Vec < _ > > ( ) ;
536+ assert_eq ! ( removed. len( ) , 10 ) ;
537+ assert_eq ! ( removed, vec![ 2 , 4 , 6 , 8 , 10 , 12 , 14 , 16 , 18 , 20 ] ) ;
538+
539+ assert_eq ! ( list. len( ) , 10 ) ;
540+ assert_eq ! ( list. into_iter( ) . collect:: <Vec <_>>( ) , vec![ 1 , 3 , 5 , 7 , 9 , 11 , 13 , 15 , 17 , 19 ] ) ;
541+ }
542+
543+ { // [+++++++++++xxxxxxxxxx]
544+ let mut list = vec ! [
545+ 1 , 3 , 5 , 7 , 9 , 11 , 13 , 15 , 17 , 19 ,
546+ 2 , 4 , 6 , 8 , 10 , 12 , 14 , 16 , 18 , 20
547+ ] . into_iter ( ) . collect :: < LinkedList < _ > > ( ) ;
548+
549+ let removed = list. drain_filter ( |x| * x % 2 == 0 ) . collect :: < Vec < _ > > ( ) ;
550+ assert_eq ! ( removed. len( ) , 10 ) ;
551+ assert_eq ! ( removed, vec![ 2 , 4 , 6 , 8 , 10 , 12 , 14 , 16 , 18 , 20 ] ) ;
552+
553+ assert_eq ! ( list. len( ) , 10 ) ;
554+ assert_eq ! ( list. into_iter( ) . collect:: <Vec <_>>( ) , vec![ 1 , 3 , 5 , 7 , 9 , 11 , 13 , 15 , 17 , 19 ] ) ;
555+ }
556+ }
0 commit comments