Skip to content

Commit 1ae96fc

Browse files
rs-sacrs-sac
committed
Update tests with Range parameter to BTreeMap::extract_if etc.
1 parent 51d247c commit 1ae96fc

File tree

7 files changed

+56
-46
lines changed

7 files changed

+56
-46
lines changed

‎library/alloc/src/collections/btree/map/tests.rs‎

Lines changed: 25 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -944,7 +944,7 @@ mod test_extract_if {
944944
#[test]
945945
fn empty() {
946946
let mut map: BTreeMap<i32, i32> = BTreeMap::new();
947-
map.extract_if(|_, _| unreachable!("there's nothing to decide on")).for_each(drop);
947+
map.extract_if(.., |_, _| unreachable!("there's nothing to decide on")).for_each(drop);
948948
assert_eq!(map.height(), None);
949949
map.check();
950950
}
@@ -954,7 +954,7 @@ mod test_extract_if {
954954
fn consumed_keeping_all() {
955955
let pairs = (0..3).map(|i| (i, i));
956956
let mut map = BTreeMap::from_iter(pairs);
957-
assert!(map.extract_if(|_, _| false).eq(iter::empty()));
957+
assert!(map.extract_if(.., |_, _| false).eq(iter::empty()));
958958
map.check();
959959
}
960960

@@ -963,7 +963,7 @@ mod test_extract_if {
963963
fn consumed_removing_all() {
964964
let pairs = (0..3).map(|i| (i, i));
965965
let mut map = BTreeMap::from_iter(pairs.clone());
966-
assert!(map.extract_if(|_, _| true).eq(pairs));
966+
assert!(map.extract_if(.., |_, _| true).eq(pairs));
967967
assert!(map.is_empty());
968968
map.check();
969969
}
@@ -974,7 +974,7 @@ mod test_extract_if {
974974
let pairs = (0..3).map(|i| (i, i));
975975
let mut map = BTreeMap::from_iter(pairs);
976976
assert!(
977-
map.extract_if(|_, v| {
977+
map.extract_if(.., |_, v| {
978978
*v += 6;
979979
false
980980
})
@@ -991,7 +991,7 @@ mod test_extract_if {
991991
let pairs = (0..3).map(|i| (i, i));
992992
let mut map = BTreeMap::from_iter(pairs);
993993
assert!(
994-
map.extract_if(|_, v| {
994+
map.extract_if(.., |_, v| {
995995
*v += 6;
996996
true
997997
})
@@ -1005,7 +1005,7 @@ mod test_extract_if {
10051005
fn underfull_keeping_all() {
10061006
let pairs = (0..3).map(|i| (i, i));
10071007
let mut map = BTreeMap::from_iter(pairs);
1008-
map.extract_if(|_, _| false).for_each(drop);
1008+
map.extract_if(.., |_, _| false).for_each(drop);
10091009
assert!(map.keys().copied().eq(0..3));
10101010
map.check();
10111011
}
@@ -1015,7 +1015,7 @@ mod test_extract_if {
10151015
let pairs = (0..3).map(|i| (i, i));
10161016
for doomed in 0..3 {
10171017
let mut map = BTreeMap::from_iter(pairs.clone());
1018-
map.extract_if(|i, _| *i == doomed).for_each(drop);
1018+
map.extract_if(.., |i, _| *i == doomed).for_each(drop);
10191019
assert_eq!(map.len(), 2);
10201020
map.check();
10211021
}
@@ -1026,7 +1026,7 @@ mod test_extract_if {
10261026
let pairs = (0..3).map(|i| (i, i));
10271027
for sacred in 0..3 {
10281028
let mut map = BTreeMap::from_iter(pairs.clone());
1029-
map.extract_if(|i, _| *i != sacred).for_each(drop);
1029+
map.extract_if(.., |i, _| *i != sacred).for_each(drop);
10301030
assert!(map.keys().copied().eq(sacred..=sacred));
10311031
map.check();
10321032
}
@@ -1036,7 +1036,7 @@ mod test_extract_if {
10361036
fn underfull_removing_all() {
10371037
let pairs = (0..3).map(|i| (i, i));
10381038
let mut map = BTreeMap::from_iter(pairs);
1039-
map.extract_if(|_, _| true).for_each(drop);
1039+
map.extract_if(.., |_, _| true).for_each(drop);
10401040
assert!(map.is_empty());
10411041
map.check();
10421042
}
@@ -1045,7 +1045,7 @@ mod test_extract_if {
10451045
fn height_0_keeping_all() {
10461046
let pairs = (0..node::CAPACITY).map(|i| (i, i));
10471047
let mut map = BTreeMap::from_iter(pairs);
1048-
map.extract_if(|_, _| false).for_each(drop);
1048+
map.extract_if(.., |_, _| false).for_each(drop);
10491049
assert!(map.keys().copied().eq(0..node::CAPACITY));
10501050
map.check();
10511051
}
@@ -1055,7 +1055,7 @@ mod test_extract_if {
10551055
let pairs = (0..node::CAPACITY).map(|i| (i, i));
10561056
for doomed in 0..node::CAPACITY {
10571057
let mut map = BTreeMap::from_iter(pairs.clone());
1058-
map.extract_if(|i, _| *i == doomed).for_each(drop);
1058+
map.extract_if(.., |i, _| *i == doomed).for_each(drop);
10591059
assert_eq!(map.len(), node::CAPACITY - 1);
10601060
map.check();
10611061
}
@@ -1066,7 +1066,7 @@ mod test_extract_if {
10661066
let pairs = (0..node::CAPACITY).map(|i| (i, i));
10671067
for sacred in 0..node::CAPACITY {
10681068
let mut map = BTreeMap::from_iter(pairs.clone());
1069-
map.extract_if(|i, _| *i != sacred).for_each(drop);
1069+
map.extract_if(.., |i, _| *i != sacred).for_each(drop);
10701070
assert!(map.keys().copied().eq(sacred..=sacred));
10711071
map.check();
10721072
}
@@ -1076,15 +1076,15 @@ mod test_extract_if {
10761076
fn height_0_removing_all() {
10771077
let pairs = (0..node::CAPACITY).map(|i| (i, i));
10781078
let mut map = BTreeMap::from_iter(pairs);
1079-
map.extract_if(|_, _| true).for_each(drop);
1079+
map.extract_if(.., |_, _| true).for_each(drop);
10801080
assert!(map.is_empty());
10811081
map.check();
10821082
}
10831083

10841084
#[test]
10851085
fn height_0_keeping_half() {
10861086
let mut map = BTreeMap::from_iter((0..16).map(|i| (i, i)));
1087-
assert_eq!(map.extract_if(|i, _| *i % 2 == 0).count(), 8);
1087+
assert_eq!(map.extract_if(.., |i, _| *i % 2 == 0).count(), 8);
10881088
assert_eq!(map.len(), 8);
10891089
map.check();
10901090
}
@@ -1093,7 +1093,7 @@ mod test_extract_if {
10931093
fn height_1_removing_all() {
10941094
let pairs = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i));
10951095
let mut map = BTreeMap::from_iter(pairs);
1096-
map.extract_if(|_, _| true).for_each(drop);
1096+
map.extract_if(.., |_, _| true).for_each(drop);
10971097
assert!(map.is_empty());
10981098
map.check();
10991099
}
@@ -1103,7 +1103,7 @@ mod test_extract_if {
11031103
let pairs = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i));
11041104
for doomed in 0..MIN_INSERTS_HEIGHT_1 {
11051105
let mut map = BTreeMap::from_iter(pairs.clone());
1106-
map.extract_if(|i, _| *i == doomed).for_each(drop);
1106+
map.extract_if(.., |i, _| *i == doomed).for_each(drop);
11071107
assert_eq!(map.len(), MIN_INSERTS_HEIGHT_1 - 1);
11081108
map.check();
11091109
}
@@ -1114,7 +1114,7 @@ mod test_extract_if {
11141114
let pairs = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i));
11151115
for sacred in 0..MIN_INSERTS_HEIGHT_1 {
11161116
let mut map = BTreeMap::from_iter(pairs.clone());
1117-
map.extract_if(|i, _| *i != sacred).for_each(drop);
1117+
map.extract_if(.., |i, _| *i != sacred).for_each(drop);
11181118
assert!(map.keys().copied().eq(sacred..=sacred));
11191119
map.check();
11201120
}
@@ -1125,7 +1125,7 @@ mod test_extract_if {
11251125
let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i));
11261126
for doomed in (0..MIN_INSERTS_HEIGHT_2).step_by(12) {
11271127
let mut map = BTreeMap::from_iter(pairs.clone());
1128-
map.extract_if(|i, _| *i == doomed).for_each(drop);
1128+
map.extract_if(.., |i, _| *i == doomed).for_each(drop);
11291129
assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2 - 1);
11301130
map.check();
11311131
}
@@ -1136,7 +1136,7 @@ mod test_extract_if {
11361136
let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i));
11371137
for sacred in (0..MIN_INSERTS_HEIGHT_2).step_by(12) {
11381138
let mut map = BTreeMap::from_iter(pairs.clone());
1139-
map.extract_if(|i, _| *i != sacred).for_each(drop);
1139+
map.extract_if(.., |i, _| *i != sacred).for_each(drop);
11401140
assert!(map.keys().copied().eq(sacred..=sacred));
11411141
map.check();
11421142
}
@@ -1146,7 +1146,7 @@ mod test_extract_if {
11461146
fn height_2_removing_all() {
11471147
let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i));
11481148
let mut map = BTreeMap::from_iter(pairs);
1149-
map.extract_if(|_, _| true).for_each(drop);
1149+
map.extract_if(.., |_, _| true).for_each(drop);
11501150
assert!(map.is_empty());
11511151
map.check();
11521152
}
@@ -1162,7 +1162,7 @@ mod test_extract_if {
11621162
map.insert(b.spawn(Panic::InDrop), ());
11631163
map.insert(c.spawn(Panic::Never), ());
11641164

1165-
catch_unwind(move || map.extract_if(|dummy, _| dummy.query(true)).for_each(drop))
1165+
catch_unwind(move || map.extract_if(.., |dummy, _| dummy.query(true)).for_each(drop))
11661166
.unwrap_err();
11671167

11681168
assert_eq!(a.queried(), 1);
@@ -1185,7 +1185,7 @@ mod test_extract_if {
11851185
map.insert(c.spawn(Panic::InQuery), ());
11861186

11871187
catch_unwind(AssertUnwindSafe(|| {
1188-
map.extract_if(|dummy, _| dummy.query(true)).for_each(drop)
1188+
map.extract_if(.., |dummy, _| dummy.query(true)).for_each(drop)
11891189
}))
11901190
.unwrap_err();
11911191

@@ -1214,7 +1214,7 @@ mod test_extract_if {
12141214
map.insert(c.spawn(Panic::InQuery), ());
12151215

12161216
{
1217-
let mut it = map.extract_if(|dummy, _| dummy.query(true));
1217+
let mut it = map.extract_if(.., |dummy, _| dummy.query(true));
12181218
catch_unwind(AssertUnwindSafe(|| while it.next().is_some() {})).unwrap_err();
12191219
// Iterator behavior after a panic is explicitly unspecified,
12201220
// so this is just the current implementation:
@@ -1658,7 +1658,7 @@ fn assert_sync() {
16581658
}
16591659

16601660
fn extract_if<T: Sync + Ord>(v: &mut BTreeMap<T, T>) -> impl Sync + '_ {
1661-
v.extract_if(|_, _| false)
1661+
v.extract_if(.., |_, _| false)
16621662
}
16631663

16641664
fn iter<T: Sync>(v: &BTreeMap<T, T>) -> impl Sync + '_ {
@@ -1727,7 +1727,7 @@ fn assert_send() {
17271727
}
17281728

17291729
fn extract_if<T: Send + Ord>(v: &mut BTreeMap<T, T>) -> impl Send + '_ {
1730-
v.extract_if(|_, _| false)
1730+
v.extract_if(.., |_, _| false)
17311731
}
17321732

17331733
fn iter<T: Send + Sync>(v: &BTreeMap<T, T>) -> impl Send + '_ {

‎library/alloc/src/collections/btree/set/tests.rs‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -368,8 +368,8 @@ fn test_extract_if() {
368368
let mut x = BTreeSet::from([1]);
369369
let mut y = BTreeSet::from([1]);
370370

371-
x.extract_if(|_| true).for_each(drop);
372-
y.extract_if(|_| false).for_each(drop);
371+
x.extract_if(.., |_| true).for_each(drop);
372+
y.extract_if(.., |_| false).for_each(drop);
373373
assert_eq!(x.len(), 0);
374374
assert_eq!(y.len(), 1);
375375
}
@@ -385,7 +385,7 @@ fn test_extract_if_drop_panic_leak() {
385385
set.insert(b.spawn(Panic::InDrop));
386386
set.insert(c.spawn(Panic::Never));
387387

388-
catch_unwind(move || set.extract_if(|dummy| dummy.query(true)).for_each(drop)).ok();
388+
catch_unwind(move || set.extract_if(.., |dummy| dummy.query(true)).for_each(drop)).ok();
389389

390390
assert_eq!(a.queried(), 1);
391391
assert_eq!(b.queried(), 1);
@@ -406,7 +406,7 @@ fn test_extract_if_pred_panic_leak() {
406406
set.insert(b.spawn(Panic::InQuery));
407407
set.insert(c.spawn(Panic::InQuery));
408408

409-
catch_unwind(AssertUnwindSafe(|| set.extract_if(|dummy| dummy.query(true)).for_each(drop)))
409+
catch_unwind(AssertUnwindSafe(|| set.extract_if(.., |dummy| dummy.query(true)).for_each(drop)))
410410
.ok();
411411

412412
assert_eq!(a.queried(), 1);
@@ -605,7 +605,7 @@ fn assert_sync() {
605605
}
606606

607607
fn extract_if<T: Sync + Ord>(v: &mut BTreeSet<T>) -> impl Sync + '_ {
608-
v.extract_if(|_| false)
608+
v.extract_if(.., |_| false)
609609
}
610610

611611
fn difference<T: Sync + Ord>(v: &BTreeSet<T>) -> impl Sync + '_ {
@@ -644,7 +644,7 @@ fn assert_send() {
644644
}
645645

646646
fn extract_if<T: Send + Ord>(v: &mut BTreeSet<T>) -> impl Send + '_ {
647-
v.extract_if(|_| false)
647+
v.extract_if(.., |_| false)
648648
}
649649

650650
fn difference<T: Send + Sync + Ord>(v: &BTreeSet<T>) -> impl Send + '_ {

‎library/alloctests/benches/btree/map.rs‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -386,15 +386,15 @@ pub fn clone_slim_100_and_clear(b: &mut Bencher) {
386386
#[bench]
387387
pub fn clone_slim_100_and_drain_all(b: &mut Bencher) {
388388
let src = slim_map(100);
389-
b.iter(|| src.clone().extract_if(|_, _| true).count())
389+
b.iter(|| src.clone().extract_if(.., |_, _| true).count())
390390
}
391391

392392
#[bench]
393393
pub fn clone_slim_100_and_drain_half(b: &mut Bencher) {
394394
let src = slim_map(100);
395395
b.iter(|| {
396396
let mut map = src.clone();
397-
assert_eq!(map.extract_if(|i, _| i % 2 == 0).count(), 100 / 2);
397+
assert_eq!(map.extract_if(.., |i, _| i % 2 == 0).count(), 100 / 2);
398398
assert_eq!(map.len(), 100 / 2);
399399
})
400400
}
@@ -457,15 +457,15 @@ pub fn clone_slim_10k_and_clear(b: &mut Bencher) {
457457
#[bench]
458458
pub fn clone_slim_10k_and_drain_all(b: &mut Bencher) {
459459
let src = slim_map(10_000);
460-
b.iter(|| src.clone().extract_if(|_, _| true).count())
460+
b.iter(|| src.clone().extract_if(.., |_, _| true).count())
461461
}
462462

463463
#[bench]
464464
pub fn clone_slim_10k_and_drain_half(b: &mut Bencher) {
465465
let src = slim_map(10_000);
466466
b.iter(|| {
467467
let mut map = src.clone();
468-
assert_eq!(map.extract_if(|i, _| i % 2 == 0).count(), 10_000 / 2);
468+
assert_eq!(map.extract_if(.., |i, _| i % 2 == 0).count(), 10_000 / 2);
469469
assert_eq!(map.len(), 10_000 / 2);
470470
})
471471
}
@@ -528,15 +528,15 @@ pub fn clone_fat_val_100_and_clear(b: &mut Bencher) {
528528
#[bench]
529529
pub fn clone_fat_val_100_and_drain_all(b: &mut Bencher) {
530530
let src = fat_val_map(100);
531-
b.iter(|| src.clone().extract_if(|_, _| true).count())
531+
b.iter(|| src.clone().extract_if(.., |_, _| true).count())
532532
}
533533

534534
#[bench]
535535
pub fn clone_fat_val_100_and_drain_half(b: &mut Bencher) {
536536
let src = fat_val_map(100);
537537
b.iter(|| {
538538
let mut map = src.clone();
539-
assert_eq!(map.extract_if(|i, _| i % 2 == 0).count(), 100 / 2);
539+
assert_eq!(map.extract_if(.., |i, _| i % 2 == 0).count(), 100 / 2);
540540
assert_eq!(map.len(), 100 / 2);
541541
})
542542
}

‎library/alloctests/benches/btree/set.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -69,15 +69,15 @@ pub fn clone_100_and_clear(b: &mut Bencher) {
6969
#[bench]
7070
pub fn clone_100_and_drain_all(b: &mut Bencher) {
7171
let src = slim_set(100);
72-
b.iter(|| src.clone().extract_if(|_| true).count())
72+
b.iter(|| src.clone().extract_if(.., |_| true).count())
7373
}
7474

7575
#[bench]
7676
pub fn clone_100_and_drain_half(b: &mut Bencher) {
7777
let src = slim_set(100);
7878
b.iter(|| {
7979
let mut set = src.clone();
80-
assert_eq!(set.extract_if(|i| i % 2 == 0).count(), 100 / 2);
80+
assert_eq!(set.extract_if(.., |i| i % 2 == 0).count(), 100 / 2);
8181
assert_eq!(set.len(), 100 / 2);
8282
})
8383
}
@@ -140,15 +140,15 @@ pub fn clone_10k_and_clear(b: &mut Bencher) {
140140
#[bench]
141141
pub fn clone_10k_and_drain_all(b: &mut Bencher) {
142142
let src = slim_set(10_000);
143-
b.iter(|| src.clone().extract_if(|_| true).count())
143+
b.iter(|| src.clone().extract_if(.., |_| true).count())
144144
}
145145

146146
#[bench]
147147
pub fn clone_10k_and_drain_half(b: &mut Bencher) {
148148
let src = slim_set(10_000);
149149
b.iter(|| {
150150
let mut set = src.clone();
151-
assert_eq!(set.extract_if(|i| i % 2 == 0).count(), 10_000 / 2);
151+
assert_eq!(set.extract_if(.., |i| i % 2 == 0).count(), 10_000 / 2);
152152
assert_eq!(set.len(), 10_000 / 2);
153153
})
154154
}

‎library/alloctests/tests/autotraits.rs‎

Lines changed: 12 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
use std::ops::Range;
2+
13
fn require_sync<T: Sync>(_: T) {}
24
fn require_send_sync<T: Send + Sync>(_: T) {}
35

@@ -55,7 +57,13 @@ fn test_btree_map() {
5557

5658
require_send_sync(async {
5759
let _v = None::<
58-
alloc::collections::btree_map::ExtractIf<'_, &u32, &u32, fn(&&u32, &mut &u32) -> bool>,
60+
alloc::collections::btree_map::ExtractIf<
61+
'_,
62+
&u32,
63+
&u32,
64+
Range<u32>,
65+
fn(&&u32, &mut &u32) -> bool,
66+
>,
5967
>;
6068
async {}.await;
6169
});
@@ -144,7 +152,9 @@ fn test_btree_set() {
144152
});
145153

146154
require_send_sync(async {
147-
let _v = None::<alloc::collections::btree_set::ExtractIf<'_, &u32, fn(&&u32) -> bool>>;
155+
let _v = None::<
156+
alloc::collections::btree_set::ExtractIf<'_, &u32, Range<u32>, fn(&&u32) -> bool>,
157+
>;
148158
async {}.await;
149159
});
150160

0 commit comments

Comments
 (0)