Skip to content

Commit a855391

Browse files
matthiaskrgrmatthiaskrgr
authored
Rollup merge of rust-lang#119853 - klensy:rustfmt-ignore, r=cuviper
rustfmt.toml: don't ignore just any tests path, only root one Previously ignored any `tests` path, now only /tests at repo root. For reference, https://git-scm.com/docs/gitignore#_pattern_format
2 parents e8acbea + aa696c5 commit a855391

File tree

22 files changed

+127
-96
lines changed

22 files changed

+127
-96
lines changed

‎compiler/rustc_errors/src/markdown/tests/term.rs

+3-2
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,8 @@ use termcolor::{BufferWriter, ColorChoice};
55
use super::*;
66

77
const INPUT: &str = include_str!("input.md");
8-
const OUTPUT_PATH: &[&str] = &[env!("CARGO_MANIFEST_DIR"), "src","markdown","tests","output.stdout"];
8+
const OUTPUT_PATH: &[&str] =
9+
&[env!("CARGO_MANIFEST_DIR"), "src", "markdown", "tests", "output.stdout"];
910

1011
const TEST_WIDTH: usize = 80;
1112

@@ -34,7 +35,7 @@ quis dolor non venenatis. Aliquam ut. ";
3435
fn test_wrapping_write() {
3536
WIDTH.with(|w| w.set(TEST_WIDTH));
3637
let mut buf = BufWriter::new(Vec::new());
37-
let txt = TXT.replace("-\n","-").replace("_\n","_").replace('\n', " ").replace(" ", "");
38+
let txt = TXT.replace("-\n", "-").replace("_\n", "_").replace('\n', " ").replace(" ", "");
3839
write_wrapping(&mut buf, &txt, 0, None).unwrap();
3940
write_wrapping(&mut buf, &txt, 4, None).unwrap();
4041
write_wrapping(

‎library/alloc/tests/autotraits.rs

+1-6
Original file line numberDiff line numberDiff line change
@@ -55,12 +55,7 @@ fn test_btree_map() {
5555

5656
require_send_sync(async {
5757
let _v = None::<
58-
alloc::collections::btree_map::ExtractIf<
59-
'_,
60-
&u32,
61-
&u32,
62-
fn(&&u32, &mut &u32) -> bool,
63-
>,
58+
alloc::collections::btree_map::ExtractIf<'_, &u32, &u32, fn(&&u32, &mut &u32) -> bool>,
6459
>;
6560
async {}.await;
6661
});

‎library/alloc/tests/vec.rs

+3-7
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
use core::alloc::{Allocator, Layout};
2-
use core::{assert_eq, assert_ne};
32
use core::num::NonZeroUsize;
43
use core::ptr::NonNull;
4+
use core::{assert_eq, assert_ne};
55
use std::alloc::System;
66
use std::assert_matches::assert_matches;
77
use std::borrow::Cow;
@@ -1212,7 +1212,7 @@ fn test_in_place_specialization_step_up_down() {
12121212
assert_eq!(sink.len(), 2);
12131213

12141214
let mut src: Vec<[u8; 3]> = Vec::with_capacity(17);
1215-
src.resize( 8, [0; 3]);
1215+
src.resize(8, [0; 3]);
12161216
let iter = src.into_iter().map(|[a, b, _]| [a, b]);
12171217
assert_in_place_trait(&iter);
12181218
let sink: Vec<[u8; 2]> = iter.collect();
@@ -1221,11 +1221,7 @@ fn test_in_place_specialization_step_up_down() {
12211221

12221222
let src = vec![[0u8; 4]; 256];
12231223
let srcptr = src.as_ptr();
1224-
let iter = src
1225-
.into_iter()
1226-
.flat_map(|a| {
1227-
a.into_iter().map(|b| b.wrapping_add(1))
1228-
});
1224+
let iter = src.into_iter().flat_map(|a| a.into_iter().map(|b| b.wrapping_add(1)));
12291225
assert_in_place_trait(&iter);
12301226
let sink = iter.collect::<Vec<_>>();
12311227
assert_eq!(srcptr as *const u8, sink.as_ptr());

‎library/core/tests/array.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
1-
use core::{array, assert_eq};
21
use core::num::NonZeroUsize;
32
use core::sync::atomic::{AtomicUsize, Ordering};
3+
use core::{array, assert_eq};
44

55
#[test]
66
fn array_from_ref() {

‎library/core/tests/cell.rs

+8-8
Original file line numberDiff line numberDiff line change
@@ -466,14 +466,14 @@ fn const_cells() {
466466
const CELL: Cell<i32> = Cell::new(3);
467467
const _: i32 = CELL.into_inner();
468468

469-
/* FIXME(#110395)
470-
const UNSAFE_CELL_FROM: UnsafeCell<i32> = UnsafeCell::from(3);
471-
const _: i32 = UNSAFE_CELL.into_inner();
469+
/* FIXME(#110395)
470+
const UNSAFE_CELL_FROM: UnsafeCell<i32> = UnsafeCell::from(3);
471+
const _: i32 = UNSAFE_CELL.into_inner();
472472
473-
const REF_CELL_FROM: RefCell<i32> = RefCell::from(3);
474-
const _: i32 = REF_CELL.into_inner();
473+
const REF_CELL_FROM: RefCell<i32> = RefCell::from(3);
474+
const _: i32 = REF_CELL.into_inner();
475475
476-
const CELL_FROM: Cell<i32> = Cell::from(3);
477-
const _: i32 = CELL.into_inner();
478-
*/
476+
const CELL_FROM: Cell<i32> = Cell::from(3);
477+
const _: i32 = CELL.into_inner();
478+
*/
479479
}

‎library/core/tests/error.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use core::error::{request_value, request_ref, Request};
1+
use core::error::{request_ref, request_value, Request};
22

33
// Test the `Request` API.
44
#[derive(Debug)]

‎library/core/tests/fmt/mod.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -22,11 +22,11 @@ fn test_pointer_formats_data_pointer() {
2222
#[test]
2323
fn test_estimated_capacity() {
2424
assert_eq!(format_args!("").estimated_capacity(), 0);
25-
assert_eq!(format_args!("{}", {""}).estimated_capacity(), 0);
25+
assert_eq!(format_args!("{}", { "" }).estimated_capacity(), 0);
2626
assert_eq!(format_args!("Hello").estimated_capacity(), 5);
27-
assert_eq!(format_args!("Hello, {}!", {""}).estimated_capacity(), 16);
28-
assert_eq!(format_args!("{}, hello!", {"World"}).estimated_capacity(), 0);
29-
assert_eq!(format_args!("{}. 16-bytes piece", {"World"}).estimated_capacity(), 32);
27+
assert_eq!(format_args!("Hello, {}!", { "" }).estimated_capacity(), 16);
28+
assert_eq!(format_args!("{}, hello!", { "World" }).estimated_capacity(), 0);
29+
assert_eq!(format_args!("{}. 16-bytes piece", { "World" }).estimated_capacity(), 32);
3030
}
3131

3232
#[test]

‎library/core/tests/hash/mod.rs

+4-2
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,8 @@ impl Hasher for MyHasher {
3535
#[test]
3636
fn test_writer_hasher() {
3737
// FIXME(#110395)
38-
/* const */ fn hash<T: Hash>(t: &T) -> u64 {
38+
/* const */
39+
fn hash<T: Hash>(t: &T) -> u64 {
3940
let mut s = MyHasher { hash: 0 };
4041
t.hash(&mut s);
4142
s.finish()
@@ -140,7 +141,8 @@ impl Hash for Custom {
140141
#[test]
141142
fn test_custom_state() {
142143
// FIXME(#110395)
143-
/* const */ fn hash<T: Hash>(t: &T) -> u64 {
144+
/* const */
145+
fn hash<T: Hash>(t: &T) -> u64 {
144146
let mut c = CustomHasher { output: 0 };
145147
t.hash(&mut c);
146148
c.finish()

‎library/core/tests/iter/adapters/chain.rs

+12-3
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,10 @@ fn test_iterator_chain_advance_by() {
4242
let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
4343
assert_eq!(iter.advance_by(xs.len() + i), Ok(()));
4444
assert_eq!(iter.next(), Some(&ys[i]));
45-
assert_eq!(iter.advance_by(100), Err(NonZeroUsize::new(100 - (ys.len() - i - 1)).unwrap()));
45+
assert_eq!(
46+
iter.advance_by(100),
47+
Err(NonZeroUsize::new(100 - (ys.len() - i - 1)).unwrap())
48+
);
4649
assert_eq!(iter.advance_by(0), Ok(()));
4750
}
4851

@@ -71,15 +74,21 @@ fn test_iterator_chain_advance_back_by() {
7174
let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
7275
assert_eq!(iter.advance_back_by(i), Ok(()));
7376
assert_eq!(iter.next_back(), Some(&ys[ys.len() - i - 1]));
74-
assert_eq!(iter.advance_back_by(100), Err(NonZeroUsize::new(100 - (len - i - 1)).unwrap()));
77+
assert_eq!(
78+
iter.advance_back_by(100),
79+
Err(NonZeroUsize::new(100 - (len - i - 1)).unwrap())
80+
);
7581
assert_eq!(iter.advance_back_by(0), Ok(()));
7682
}
7783

7884
for i in 0..xs.len() {
7985
let mut iter = Unfuse::new(xs).chain(Unfuse::new(ys));
8086
assert_eq!(iter.advance_back_by(ys.len() + i), Ok(()));
8187
assert_eq!(iter.next_back(), Some(&xs[xs.len() - i - 1]));
82-
assert_eq!(iter.advance_back_by(100), Err(NonZeroUsize::new(100 - (xs.len() - i - 1)).unwrap()));
88+
assert_eq!(
89+
iter.advance_back_by(100),
90+
Err(NonZeroUsize::new(100 - (xs.len() - i - 1)).unwrap())
91+
);
8392
assert_eq!(iter.advance_back_by(0), Ok(()));
8493
}
8594

‎library/core/tests/iter/adapters/flatten.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
1-
use core::assert_eq;
21
use super::*;
2+
use core::assert_eq;
33
use core::iter::*;
44
use core::num::NonZeroUsize;
55

‎library/core/tests/iter/adapters/step_by.rs

+9-13
Original file line numberDiff line numberDiff line change
@@ -245,7 +245,6 @@ fn test_step_by_skip() {
245245
assert_eq!((200..=255u8).step_by(10).nth(3), Some(230));
246246
}
247247

248-
249248
struct DeOpt<I: Iterator>(I);
250249

251250
impl<I: Iterator> Iterator for DeOpt<I> {
@@ -265,17 +264,15 @@ impl<I: DoubleEndedIterator> DoubleEndedIterator for DeOpt<I> {
265264
#[test]
266265
fn test_step_by_fold_range_specialization() {
267266
macro_rules! t {
268-
($range:expr, $var: ident, $body:tt) => {
269-
{
270-
// run the same tests for the non-optimized version
271-
let mut $var = DeOpt($range);
272-
$body
273-
}
274-
{
275-
let mut $var = $range;
276-
$body
277-
}
267+
($range:expr, $var: ident, $body:tt) => {{
268+
// run the same tests for the non-optimized version
269+
let mut $var = DeOpt($range);
270+
$body
278271
}
272+
{
273+
let mut $var = $range;
274+
$body
275+
}};
279276
}
280277

281278
t!((1usize..5).step_by(1), r, {
@@ -288,13 +285,12 @@ fn test_step_by_fold_range_specialization() {
288285
assert_eq!(r.sum::<usize>(), 2);
289286
});
290287

291-
292288
t!((0usize..5).step_by(2), r, {
293289
assert_eq!(r.next(), Some(0));
294290
assert_eq!(r.sum::<usize>(), 6);
295291
});
296292

297-
t!((usize::MAX - 6 .. usize::MAX).step_by(5), r, {
293+
t!((usize::MAX - 6..usize::MAX).step_by(5), r, {
298294
assert_eq!(r.next(), Some(usize::MAX - 6));
299295
assert_eq!(r.sum::<usize>(), usize::MAX - 1);
300296
});

‎library/core/tests/iter/adapters/take.rs

+4-1
Original file line numberDiff line numberDiff line change
@@ -93,7 +93,10 @@ fn test_take_advance_by() {
9393
assert_eq!((0..2).take(1).advance_back_by(10), Err(NonZeroUsize::new(9).unwrap()));
9494
assert_eq!((0..0).take(1).advance_back_by(1), Err(NonZeroUsize::new(1).unwrap()));
9595
assert_eq!((0..0).take(1).advance_back_by(0), Ok(()));
96-
assert_eq!((0..usize::MAX).take(100).advance_back_by(usize::MAX), Err(NonZeroUsize::new(usize::MAX - 100).unwrap()));
96+
assert_eq!(
97+
(0..usize::MAX).take(100).advance_back_by(usize::MAX),
98+
Err(NonZeroUsize::new(usize::MAX - 100).unwrap())
99+
);
97100
}
98101

99102
#[test]

‎library/core/tests/iter/adapters/zip.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -184,7 +184,7 @@ fn test_zip_nested_sideffectful() {
184184
let it = xs.iter_mut().map(|x| *x = 1).enumerate().zip(&ys);
185185
it.count();
186186
}
187-
let length_aware = &xs == &[1, 1, 1, 1, 0, 0];
187+
let length_aware = &xs == &[1, 1, 1, 1, 0, 0];
188188
let probe_first = &xs == &[1, 1, 1, 1, 1, 0];
189189

190190
// either implementation is valid according to zip documentation

‎library/core/tests/iter/traits/iterator.rs

+8-2
Original file line numberDiff line numberDiff line change
@@ -168,7 +168,10 @@ fn test_iterator_advance_back_by() {
168168
let mut iter = v.iter();
169169
assert_eq!(iter.advance_back_by(i), Ok(()));
170170
assert_eq!(iter.next_back().unwrap(), &v[v.len() - 1 - i]);
171-
assert_eq!(iter.advance_back_by(100), Err(NonZeroUsize::new(100 - (v.len() - 1 - i)).unwrap()));
171+
assert_eq!(
172+
iter.advance_back_by(100),
173+
Err(NonZeroUsize::new(100 - (v.len() - 1 - i)).unwrap())
174+
);
172175
}
173176

174177
assert_eq!(v.iter().advance_back_by(v.len()), Ok(()));
@@ -183,7 +186,10 @@ fn test_iterator_rev_advance_back_by() {
183186
let mut iter = v.iter().rev();
184187
assert_eq!(iter.advance_back_by(i), Ok(()));
185188
assert_eq!(iter.next_back().unwrap(), &v[i]);
186-
assert_eq!(iter.advance_back_by(100), Err(NonZeroUsize::new(100 - (v.len() - 1 - i)).unwrap()));
189+
assert_eq!(
190+
iter.advance_back_by(100),
191+
Err(NonZeroUsize::new(100 - (v.len() - 1 - i)).unwrap())
192+
);
187193
}
188194

189195
assert_eq!(v.iter().rev().advance_back_by(v.len()), Ok(()));

‎library/core/tests/net/ip_addr.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -664,7 +664,11 @@ fn ipv6_properties() {
664664
&[0x20, 1, 0, 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
665665
global | unicast_global
666666
);
667-
check!("2001:30::", &[0x20, 1, 0, 0x30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], global | unicast_global);
667+
check!(
668+
"2001:30::",
669+
&[0x20, 1, 0, 0x30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
670+
global | unicast_global
671+
);
668672
check!("2001:40::", &[0x20, 1, 0, 0x40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], unicast_global);
669673

670674
check!(

‎library/core/tests/option.rs

+21-21
Original file line numberDiff line numberDiff line change
@@ -178,19 +178,19 @@ fn test_or_else() {
178178
assert_eq!(x.or_else(two), Some(2));
179179
assert_eq!(x.or_else(none), None);
180180

181-
/* FIXME(#110395)
182-
const FOO: Option<isize> = Some(1);
183-
const A: Option<isize> = FOO.or_else(two);
184-
const B: Option<isize> = FOO.or_else(none);
185-
assert_eq!(A, Some(1));
186-
assert_eq!(B, Some(1));
187-
188-
const BAR: Option<isize> = None;
189-
const C: Option<isize> = BAR.or_else(two);
190-
const D: Option<isize> = BAR.or_else(none);
191-
assert_eq!(C, Some(2));
192-
assert_eq!(D, None);
193-
*/
181+
/* FIXME(#110395)
182+
const FOO: Option<isize> = Some(1);
183+
const A: Option<isize> = FOO.or_else(two);
184+
const B: Option<isize> = FOO.or_else(none);
185+
assert_eq!(A, Some(1));
186+
assert_eq!(B, Some(1));
187+
188+
const BAR: Option<isize> = None;
189+
const C: Option<isize> = BAR.or_else(two);
190+
const D: Option<isize> = BAR.or_else(none);
191+
assert_eq!(C, Some(2));
192+
assert_eq!(D, None);
193+
*/
194194
}
195195

196196
#[test]
@@ -486,15 +486,15 @@ const fn option_const_mut() {
486486
None => unreachable!(),
487487
}
488488
}
489-
/* FIXME(const-hack)
490-
{
491-
let as_mut: Option<&mut usize> = Option::from(&mut option);
492-
match as_mut {
493-
Some(v) => *v = 42,
494-
None => unreachable!(),
489+
/* FIXME(const-hack)
490+
{
491+
let as_mut: Option<&mut usize> = Option::from(&mut option);
492+
match as_mut {
493+
Some(v) => *v = 42,
494+
None => unreachable!(),
495+
}
495496
}
496-
}
497-
*/
497+
*/
498498
}
499499

500500
#[test]

‎library/core/tests/ptr.rs

+20-4
Original file line numberDiff line numberDiff line change
@@ -478,7 +478,11 @@ fn align_offset_various_strides() {
478478
x |= test_stride::<A9>(ptr::invalid::<A9>(ptr), align);
479479

480480
#[repr(packed)]
481-
struct A10(#[allow(dead_code)] u32, #[allow(dead_code)] u32, #[allow(dead_code)] u16);
481+
struct A10(
482+
#[allow(dead_code)] u32,
483+
#[allow(dead_code)] u32,
484+
#[allow(dead_code)] u16,
485+
);
482486
x |= test_stride::<A10>(ptr::invalid::<A10>(ptr), align);
483487

484488
x |= test_stride::<u32>(ptr::invalid::<u32>(ptr), align);
@@ -532,19 +536,31 @@ fn align_offset_various_strides_const() {
532536
test_stride::<A6>(ptr::invalid::<A6>(ptr), ptr, align);
533537

534538
#[repr(packed)]
535-
struct A7(#[allow(dead_code)] u32, #[allow(dead_code)] u16, #[allow(dead_code)] u8);
539+
struct A7(
540+
#[allow(dead_code)] u32,
541+
#[allow(dead_code)] u16,
542+
#[allow(dead_code)] u8,
543+
);
536544
test_stride::<A7>(ptr::invalid::<A7>(ptr), ptr, align);
537545

538546
#[repr(packed)]
539547
struct A8(#[allow(dead_code)] u32, #[allow(dead_code)] u32);
540548
test_stride::<A8>(ptr::invalid::<A8>(ptr), ptr, align);
541549

542550
#[repr(packed)]
543-
struct A9(#[allow(dead_code)] u32, #[allow(dead_code)] u32, #[allow(dead_code)] u8);
551+
struct A9(
552+
#[allow(dead_code)] u32,
553+
#[allow(dead_code)] u32,
554+
#[allow(dead_code)] u8,
555+
);
544556
test_stride::<A9>(ptr::invalid::<A9>(ptr), ptr, align);
545557

546558
#[repr(packed)]
547-
struct A10(#[allow(dead_code)] u32, #[allow(dead_code)] u32, #[allow(dead_code)] u16);
559+
struct A10(
560+
#[allow(dead_code)] u32,
561+
#[allow(dead_code)] u32,
562+
#[allow(dead_code)] u16,
563+
);
548564
test_stride::<A10>(ptr::invalid::<A10>(ptr), ptr, align);
549565

550566
test_stride::<u32>(ptr::invalid::<u32>(ptr), ptr, align);

0 commit comments

Comments
 (0)