Skip to content

Commit f1e5933

Browse files
cuvipercuviper
committed
Clippy fixes in tests
1 parent d41d29a commit f1e5933

File tree

17 files changed

+136
-215
lines changed

17 files changed

+136
-215
lines changed

‎examples/cpu_monitor.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ use docopt::Docopt;
88
use std::io;
99
use std::process;
1010

11-
const USAGE: &'static str = "
11+
const USAGE: &str = "
1212
Usage: cpu_monitor [options] <scenario>
1313
cpu_monitor --help
1414
@@ -76,7 +76,7 @@ fn tasks_ended(args: &Args) {
7676
}
7777

7878
fn task_stall_root(args: &Args) {
79-
rayon::join(|| task(args), || wait_for_user());
79+
rayon::join(|| task(args), wait_for_user);
8080
}
8181

8282
fn task_stall_scope(args: &Args) {

‎rayon-core/src/scope/test.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -77,7 +77,7 @@ struct Tree<T: Send> {
7777
impl<T: Send> Tree<T> {
7878
fn iter<'s>(&'s self) -> vec::IntoIter<&'s T> {
7979
once(&self.value)
80-
.chain(self.children.iter().flat_map(|c| c.iter()))
80+
.chain(self.children.iter().flat_map(Tree::iter))
8181
.collect::<Vec<_>>() // seems like it shouldn't be needed... but prevents overflow
8282
.into_iter()
8383
}
@@ -127,7 +127,7 @@ fn random_tree1(depth: usize, rng: &mut XorShiftRng) -> Tree<u32> {
127127

128128
Tree {
129129
value: rng.gen_range(0, 1_000_000),
130-
children: children,
130+
children,
131131
}
132132
}
133133

‎rayon-core/src/thread_pool/test.rs

Lines changed: 8 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -68,14 +68,11 @@ fn sleeper_stop() {
6868
}
6969

7070
/// Create a start/exit handler that increments an atomic counter.
71-
fn count_handler() -> (Arc<AtomicUsize>, Box<::StartHandler>) {
71+
fn count_handler() -> (Arc<AtomicUsize>, impl Fn(usize)) {
7272
let count = Arc::new(AtomicUsize::new(0));
73-
(
74-
count.clone(),
75-
Box::new(move |_| {
76-
count.fetch_add(1, Ordering::SeqCst);
77-
}),
78-
)
73+
(count.clone(), move |_| {
74+
count.fetch_add(1, Ordering::SeqCst);
75+
})
7976
}
8077

8178
/// Wait until a counter is no longer shared, then return its value.
@@ -109,8 +106,8 @@ fn failed_thread_stack() {
109106
let builder = ThreadPoolBuilder::new()
110107
.num_threads(10)
111108
.stack_size(stack_size)
112-
.start_handler(move |i| start_handler(i))
113-
.exit_handler(move |i| exit_handler(i));
109+
.start_handler(start_handler)
110+
.exit_handler(exit_handler);
114111

115112
let pool = builder.build();
116113
assert!(pool.is_err(), "thread stack should have failed!");
@@ -128,8 +125,8 @@ fn panic_thread_name() {
128125
let (exit_count, exit_handler) = count_handler();
129126
let builder = ThreadPoolBuilder::new()
130127
.num_threads(10)
131-
.start_handler(move |i| start_handler(i))
132-
.exit_handler(move |i| exit_handler(i))
128+
.start_handler(start_handler)
129+
.exit_handler(exit_handler)
133130
.thread_name(|i| {
134131
if i >= 5 {
135132
panic!();

‎rayon-demo/src/factorial/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ const N: u32 = 9999;
1010

1111
/// Compute the Factorial using a plain iterator.
1212
fn factorial(n: u32) -> BigUint {
13-
(1..n + 1).map(BigUint::from).fold(BigUint::one(), Mul::mul)
13+
(1..=n).map(BigUint::from).fold(BigUint::one(), Mul::mul)
1414
}
1515

1616
#[bench]

‎rayon-demo/src/fibonacci/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ extern crate rayon;
1717
extern crate test;
1818

1919
const N: u32 = 32;
20-
const FN: u32 = 2178309;
20+
const FN: u32 = 2_178_309;
2121

2222
fn fib_iterative(n: u32) -> u32 {
2323
let mut a = 0;

‎rayon-demo/src/map_collect.rs

Lines changed: 45 additions & 75 deletions
Original file line numberDiff line numberDiff line change
@@ -41,13 +41,10 @@ mod util {
4141
PI: ParallelIterator<Item = (K, V)> + Send,
4242
{
4343
let mutex = Mutex::new(HashMap::new());
44-
pi.fold(
45-
|| Vec::new(),
46-
|mut vec, elem| {
47-
vec.push(elem);
48-
vec
49-
},
50-
)
44+
pi.fold(Vec::new, |mut vec, elem| {
45+
vec.push(elem);
46+
vec
47+
})
5148
.for_each(|vec| {
5249
let mut guard = mutex.lock().unwrap();
5350
guard.extend(vec);
@@ -74,13 +71,10 @@ mod util {
7471
PI: ParallelIterator<Item = (K, V)> + Send,
7572
{
7673
let list: LinkedList<Vec<(_, _)>> = pi
77-
.fold(
78-
|| Vec::new(),
79-
|mut vec, elem| {
80-
vec.push(elem);
81-
vec
82-
},
83-
)
74+
.fold(Vec::new, |mut vec, elem| {
75+
vec.push(elem);
76+
vec
77+
})
8478
.collect();
8579
list.into_iter().fold(HashMap::new(), |mut map, vec| {
8680
map.extend(vec);
@@ -96,13 +90,10 @@ mod util {
9690
PI: ParallelIterator<Item = (K, V)> + Send,
9791
{
9892
let list: LinkedList<Vec<(_, _)>> = pi
99-
.fold(
100-
|| Vec::new(),
101-
|mut vec, elem| {
102-
vec.push(elem);
103-
vec
104-
},
105-
)
93+
.fold(Vec::new, |mut vec, elem| {
94+
vec.push(elem);
95+
vec
96+
})
10697
.collect();
10798

10899
let len = list.iter().map(Vec::len).sum();
@@ -121,13 +112,10 @@ mod util {
121112
PI: ParallelIterator<Item = (K, V)> + Send,
122113
{
123114
let list: LinkedList<Vec<(_, _)>> = pi
124-
.fold(
125-
|| Vec::new(),
126-
|mut vec, elem| {
127-
vec.push(elem);
128-
vec
129-
},
130-
)
115+
.fold(Vec::new, |mut vec, elem| {
116+
vec.push(elem);
117+
vec
118+
})
131119
.map(|vec| {
132120
let mut list = LinkedList::new();
133121
list.push_back(vec);
@@ -154,21 +142,15 @@ mod util {
154142
PI: ParallelIterator<Item = (K, V)> + Send,
155143
{
156144
let vecs: Vec<Vec<(_, _)>> = pi
157-
.fold(
158-
|| Vec::new(),
159-
|mut vec, elem| {
160-
vec.push(elem);
161-
vec
162-
},
163-
)
145+
.fold(Vec::new, |mut vec, elem| {
146+
vec.push(elem);
147+
vec
148+
})
164149
.map(|v| vec![v])
165-
.reduce(
166-
|| Vec::new(),
167-
|mut left, mut right| {
168-
left.append(&mut right);
169-
left
170-
},
171-
);
150+
.reduce(Vec::new, |mut left, mut right| {
151+
left.append(&mut right);
152+
left
153+
});
172154

173155
let len = vecs.iter().map(Vec::len).sum();
174156
vecs.into_iter()
@@ -185,25 +167,19 @@ mod util {
185167
V: Send,
186168
PI: ParallelIterator<Item = (K, V)> + Send,
187169
{
188-
pi.fold(
189-
|| HashMap::new(),
190-
|mut map, (k, v)| {
191-
map.insert(k, v);
192-
map
193-
},
194-
)
195-
.reduce(
196-
|| HashMap::new(),
197-
|mut map1, mut map2| {
198-
if map1.len() > map2.len() {
199-
map1.extend(map2);
200-
map1
201-
} else {
202-
map2.extend(map1);
203-
map2
204-
}
205-
},
206-
)
170+
pi.fold(HashMap::new, |mut map, (k, v)| {
171+
map.insert(k, v);
172+
map
173+
})
174+
.reduce(HashMap::new, |mut map1, mut map2| {
175+
if map1.len() > map2.len() {
176+
map1.extend(map2);
177+
map1
178+
} else {
179+
map2.extend(map1);
180+
map2
181+
}
182+
})
207183
}
208184

209185
/// Fold into vecs and then reduce them together as hashmaps.
@@ -213,21 +189,15 @@ mod util {
213189
V: Send,
214190
PI: ParallelIterator<Item = (K, V)> + Send,
215191
{
216-
pi.fold(
217-
|| Vec::new(),
218-
|mut vec, elem| {
219-
vec.push(elem);
220-
vec
221-
},
222-
)
192+
pi.fold(Vec::new, |mut vec, elem| {
193+
vec.push(elem);
194+
vec
195+
})
223196
.map(HashMap::from_iter)
224-
.reduce(
225-
|| HashMap::new(),
226-
|mut map1, map2| {
227-
map1.extend(map2);
228-
map1
229-
},
230-
)
197+
.reduce(HashMap::new, |mut map1, map2| {
198+
map1.extend(map2);
199+
map1
200+
})
231201
}
232202
}
233203

‎rayon-demo/src/pythagoras/mod.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -23,37 +23,37 @@ where
2323
FN: Fn(Iter<u32>) -> N + Sync,
2424
N: ParallelIterator<Item = u32>,
2525
{
26-
map_m((1u32..2000).into_par_iter())
26+
map_m((1u32..2_000).into_par_iter())
2727
.map(|m| -> u32 {
2828
map_n((1..m).into_par_iter())
2929
.filter(|n| (m - n).is_odd() && m.gcd(n) == 1)
30-
.map(|n| 4000000 / (m * m + n * n))
30+
.map(|n| 4_000_000 / (m * m + n * n))
3131
.sum()
3232
})
3333
.sum()
3434
}
3535

3636
/// Same as par_euclid, without tweaking split lengths
3737
fn par_euclid_weightless() -> u32 {
38-
(1u32..2000)
38+
(1u32..2_000)
3939
.into_par_iter()
4040
.map(|m| -> u32 {
4141
(1..m)
4242
.into_par_iter()
4343
.filter(|n| (m - n).is_odd() && m.gcd(n) == 1)
44-
.map(|n| 4000000 / (m * m + n * n))
44+
.map(|n| 4_000_000 / (m * m + n * n))
4545
.sum()
4646
})
4747
.sum()
4848
}
4949

5050
/// Same as par_euclid, without using rayon.
5151
fn euclid() -> u32 {
52-
(1u32..2000)
52+
(1u32..2_000)
5353
.map(|m| {
5454
(1..m)
5555
.filter(|n| (m - n).is_odd() && m.gcd(n) == 1)
56-
.map(|n| 4000000 / (m * m + n * n))
56+
.map(|n| 4_000_000 / (m * m + n * n))
5757
.fold(0, Add::add)
5858
})
5959
.fold(0, Add::add)

‎rayon-demo/src/quicksort/bench.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ fn bench_harness<F: FnMut(&mut [u32])>(mut f: F, b: &mut test::Bencher) {
1313
sort_vec = base_vec.clone();
1414
f(&mut sort_vec);
1515
});
16-
assert!(super::is_sorted(&mut sort_vec));
16+
assert!(super::is_sorted(&sort_vec));
1717
}
1818

1919
#[bench]

0 commit comments

Comments
 (0)