c1707aaf0b
Currently the `Debug` implementation for `MaybeUninit` winds up being
pretty verbose. This struct:
#[derive(Debug)]
pub struct Foo {
pub a: u32,
pub b: &'static str,
pub c: MaybeUninit<u32>,
pub d: MaybeUninit<String>,
}
Prints as:
Foo {
a: 0,
b: "hello",
c: core::mem::maybe_uninit::MaybeUninit<u32>,
d: core::mem::maybe_uninit::MaybeUninit<alloc::string::String>,
}
The goal is just to be a standin for content so the path prefix doesn't
add any useful information. Change the implementation to trim
`MaybeUninit`'s leading path, meaning the new result is now:
Foo {
a: 0,
b: "hello",
c: MaybeUninit<u32>,
d: MaybeUninit<alloc::string::String>,
}
52 lines
1.5 KiB
Rust
52 lines
1.5 KiB
Rust
mod builders;
|
|
mod float;
|
|
mod num;
|
|
|
|
#[test]
|
|
fn test_format_flags() {
|
|
// No residual flags left by pointer formatting
|
|
let p = "".as_ptr();
|
|
assert_eq!(format!("{:p} {:x}", p, 16), format!("{p:p} 10"));
|
|
|
|
assert_eq!(format!("{: >3}", 'a'), " a");
|
|
}
|
|
|
|
#[test]
|
|
fn test_pointer_formats_data_pointer() {
|
|
let b: &[u8] = b"";
|
|
let s: &str = "";
|
|
assert_eq!(format!("{s:p}"), format!("{:p}", s.as_ptr()));
|
|
assert_eq!(format!("{b:p}"), format!("{:p}", b.as_ptr()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_estimated_capacity() {
|
|
assert_eq!(format_args!("").estimated_capacity(), 0);
|
|
assert_eq!(format_args!("{}", { "" }).estimated_capacity(), 0);
|
|
assert_eq!(format_args!("Hello").estimated_capacity(), 5);
|
|
assert_eq!(format_args!("Hello, {}!", { "" }).estimated_capacity(), 16);
|
|
assert_eq!(format_args!("{}, hello!", { "World" }).estimated_capacity(), 0);
|
|
assert_eq!(format_args!("{}. 16-bytes piece", { "World" }).estimated_capacity(), 32);
|
|
}
|
|
|
|
#[test]
|
|
fn pad_integral_resets() {
|
|
struct Bar;
|
|
|
|
impl core::fmt::Display for Bar {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
"1".fmt(f)?;
|
|
f.pad_integral(true, "", "5")?;
|
|
"1".fmt(f)
|
|
}
|
|
}
|
|
|
|
assert_eq!(format!("{Bar:<03}"), "1 0051 ");
|
|
}
|
|
|
|
#[test]
|
|
fn test_maybe_uninit_short() {
|
|
// Ensure that the trimmed `MaybeUninit` Debug implementation doesn't break
|
|
let x = core::mem::MaybeUninit::new(0u32);
|
|
assert_eq!(format!("{x:?}"), "MaybeUninit<u32>");
|
|
}
|