#! [cfg_attr(not(feature =
"std" ), no_std)]
#! [cfg_attr(nightly, feature(never_type))]
#! [allow(dead_code)]
// some code is tested for type checking only
#[ cfg(not(feature =
"std" ))]
extern crate alloc;
#[ cfg(not(feature =
"std" ))]
use alloc::{format, string::ToString};
use derive_more::with_trait::{
Binary, Display, LowerExp, LowerHex, Octal, Pointer, UpperExp, UpperHex,
};
mod structs {
use super ::*;
mod unit {
use super ::*;
#[ derive(Display)]
struct Unit;
#[ derive(Display)]
struct r
#RawUnit ;
#[ derive(Display)]
struct Tuple();
#[ derive(Display)]
struct Struct {}
#[ test]
fn assert() {
assert_eq!(Unit.to_string(),
"Unit" );
assert_eq!(r
#RawUnit .to_string(),
"RawUnit" );
assert_eq!(Tuple().to_string(),
"Tuple" );
assert_eq!(
Struct {}.to_string(),
"Struct" );
}
mod str {
use super ::*;
#[ derive(Display)]
#[ display(
"unit" )]
pub struct Unit;
#[ derive(Display)]
#[ display(
"tuple" )]
pub struct Tuple();
#[ derive(Display)]
#[ display(
"struct" )]
pub struct Struct {}
#[ test]
fn assert() {
assert_eq!(Unit.to_string(),
"unit" );
assert_eq!(Tuple().to_string(),
"tuple" );
assert_eq!(
Struct {}.to_string(),
"struct" );
}
}
mod interpolated {
use super ::*;
#[ derive(Display)]
#[ display(
"unit: {}" ,
0 )]
pub struct Unit;
#[ derive(Display)]
#[ display(
"tuple: {}" ,
0 )]
pub struct Tuple();
#[ derive(Display)]
#[ display(
"struct: {}" ,
0 )]
pub struct Struct {}
#[ test]
fn assert() {
assert_eq!(Unit.to_string(),
"unit: 0" );
assert_eq!(Tuple().to_string(),
"tuple: 0" );
assert_eq!(
Struct {}.to_string(),
"struct: 0" );
}
}
mod transparency {
use super ::*;
mod interpolated {
use super ::*;
const I32: i32 =
11 ;
const F64: f64 =
3 .
15 ;
const POINTER: &f64 = &
3 .
15 ;
#[ derive(Display)]
#[ display(
"{I32}" )]
struct Display;
#[ derive(Display)]
#[ display(
"{I32:?}" )]
struct Debug;
#[ derive(Display)]
#[ display(
"{:b}" , I32)]
struct Binary;
#[ derive(Display)]
#[ display(
"{0:o}" , I32)]
struct Octal;
#[ derive(Display)]
#[ display(
"{I32:x}" )]
struct LowerHex;
#[ derive(Display)]
#[ display(
"{:X}" , I32)]
struct UpperHex;
#[ derive(Display)]
#[ display(
"{F64:e}" )]
struct LowerExp;
#[ derive(Display)]
#[ display(
"{named:E}" , named = F64)]
struct UpperExp;
#[ derive(Display)]
#[ display(
"{POINTER:p}" )]
struct Pointer;
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , Display),
"011" );
assert_eq!(format!(
"{:03}" , Debug),
"011" );
assert_eq!(format!(
"{:07}" , Binary),
"0001011" );
assert_eq!(format!(
"{:07}" , Octal),
"0000013" );
assert_eq!(format!(
"{:03}" , LowerHex),
"00b" );
assert_eq!(format!(
"{:03}" , UpperHex),
"00B" );
assert_eq!(format!(
"{:07}" , LowerExp),
"03.15e0" );
assert_eq!(format!(
"{:07}" , UpperExp),
"03.15E0" );
assert_eq!(format!(
"{:018}" , Pointer), format!(
"{POINTER:018p}" ));
}
}
mod omitted {
use super ::*;
mod on_modifiers {
use super ::*;
const I32: i32 =
11 ;
const F64: f64 =
3 .
15 ;
#[ derive(Display)]
#[ display(
"{I32:x?}" )]
struct LowerDebug;
#[ derive(Display)]
#[ display(
"{I32:X?}" )]
struct UpperDebug;
#[ derive(Display)]
#[ display(
"{:^}" , I32)]
struct Align;
#[ derive(Display)]
#[ display(
"{:+}" , I32)]
struct Sign;
#[ derive(Display)]
#[ display(
"{:#b}" , I32)]
struct Alternate;
#[ derive(Display)]
#[ display(
"{:0}" , I32)]
struct ZeroPadded;
#[ derive(Display)]
#[ display(
"{:07}" , I32)]
struct Width;
#[ derive(Display)]
#[ display(
"{:.1}" , F64)]
struct Precision;
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , LowerDebug),
"b" );
assert_eq!(format!(
"{:03}" , UpperDebug),
"B" );
assert_eq!(format!(
"{:03}" , Align),
"11" );
assert_eq!(format!(
"{:04}" , Sign),
"+11" );
assert_eq!(format!(
"{:07}" , Alternate),
"0b1011" );
assert_eq!(format!(
"{:07}" , ZeroPadded),
"11" );
assert_eq!(format!(
"{:03}" , Width),
"0000011" );
assert_eq!(format!(
"{:.3}" , Precision),
"3.1" );
}
}
}
}
}
mod single_field {
use super ::*;
#[ derive(Display)]
struct Tuple(i32);
#[ derive(Binary)]
struct Binary(i32);
#[ derive(Display)]
struct Struct {
field: i32,
}
#[ derive(Octal)]
struct Octal {
field: i32,
}
#[ test]
fn assert() {
assert_eq!(Tuple(
0 ).to_string(),
"0" );
assert_eq!(format!(
"{:b}" , Binary(
10 )),
"1010" );
assert_eq!(
Struct { field:
0 }.to_string(),
"0" );
assert_eq!(format!(
"{:o}" , Octal { field:
10 }).to_string(),
"12" );
}
mod str {
use super ::*;
#[ derive(Display)]
#[ display(
"tuple" )]
struct Tuple(i32);
#[ derive(Display)]
#[ display(
"struct" )]
struct Struct {
field: i32,
}
#[ test]
fn assert() {
assert_eq!(Tuple(
0 ).to_string(),
"tuple" );
assert_eq!(
Struct { field:
0 }.to_string(),
"struct" );
}
}
mod interpolated {
use super ::*;
#[ derive(Display)]
#[ display(
"tuple: {_0} {}" , _
0 )]
struct Tuple(i32);
#[ derive(Display)]
#[ display(
"struct: {field} {}" , field)]
struct Struct {
field: i32,
}
#[ test]
fn assert() {
assert_eq!(Tuple(
0 ).to_string(),
"tuple: 0 0" );
assert_eq!(
Struct { field:
0 }.to_string(),
"struct: 0 0" );
}
}
mod transparency {
use super ::*;
mod direct {
use super ::*;
#[ derive(Display)]
struct TupleDisplay(i32);
#[ derive(Binary)]
struct TupleBinary(i32);
#[ derive(Octal)]
struct TupleOctal(i32);
#[ derive(LowerHex)]
struct StructLowerHex {
field: i32,
}
#[ derive(UpperHex)]
struct StructUpperHex {
field: i32,
}
#[ derive(LowerExp)]
struct StructLowerExp {
field: f64,
}
#[ derive(UpperExp)]
struct StructUpperExp {
field: f64,
}
#[ derive(Pointer)]
struct StructPointer<
'a> {
field: &
'a i32,
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , TupleDisplay(
7 )),
"007" );
assert_eq!(format!(
"{:07b}" , TupleBinary(
7 )),
"0000111" );
assert_eq!(format!(
"{:03o}" , TupleOctal(
9 )),
"011" );
assert_eq!(format!(
"{:03x}" , StructLowerHex { field:
42 }),
"02a" );
assert_eq!(format!(
"{:03X}" , StructUpperHex { field:
42 }),
"02A" );
assert_eq!(
format!(
"{:07e}" , StructLowerExp { field:
42 .
0 }),
"004.2e1" ,
);
assert_eq!(
format!(
"{:07E}" , StructUpperExp { field:
42 .
0 }),
"004.2E1" ,
);
let a =
42 ;
assert_eq!(
format!(
"{:018p}" , StructPointer { field: &a }),
format!(
"{:018p}" , &a),
);
}
}
mod interpolated {
use super ::*;
#[ derive(Display)]
#[ display(
"{_0}" )]
struct TupleDisplay(i32);
#[ derive(Display)]
#[ display(
"{_0:?}" )]
struct TupleDebug(i32);
#[ derive(Display)]
#[ display(
"{:b}" , _
0 )]
struct TupleBinary(i32);
#[ derive(Display)]
#[ display(
"{0:o}" , _
0 )]
struct TupleOctal(i32);
#[ derive(Display)]
#[ display(
"{field:x}" )]
struct StructLowerHex {
field: i32,
}
#[ derive(Display)]
#[ display(
"{:X}" , field)]
struct StructUpperHex {
field: i32,
}
#[ derive(Display)]
#[ display(
"{field:e}" )]
struct StructLowerExp {
field: f64,
}
#[ derive(Display)]
#[ display(
"{named:E}" , named = field)]
struct StructUpperExp {
field: f64,
}
#[ derive(Display)]
#[ display(
"{field:p}" )]
struct StructPointer<
'a> {
field: &
'a i32,
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , TupleDisplay(
7 )),
"007" );
assert_eq!(format!(
"{:03}" , TupleDebug(
8 )),
"008" );
assert_eq!(format!(
"{:07}" , TupleBinary(
7 )),
"0000111" );
assert_eq!(format!(
"{:03}" , TupleOctal(
9 )),
"011" );
assert_eq!(format!(
"{:03}" , StructLowerHex { field:
42 }),
"02a" );
assert_eq!(format!(
"{:03}" , StructUpperHex { field:
42 }),
"02A" );
assert_eq!(
format!(
"{:07}" , StructLowerExp { field:
42 .
0 }),
"004.2e1" ,
);
assert_eq!(
format!(
"{:07}" , StructUpperExp { field:
42 .
0 }),
"004.2E1" ,
);
let a =
42 ;
assert_eq!(
format!(
"{:018}" , StructPointer { field: &a }),
format!(
"{:018p}" , &a),
);
}
}
mod suppressed {
use super ::*;
#[ derive(Display)]
#[ display(
"{}" , format_args!(
"{_0}" ))]
struct TupleDisplay(i32);
#[ derive(Display)]
#[ display(
"{}" , format_args!(
"{_0:?}" ))]
struct TupleDebug(i32);
#[ derive(Display)]
#[ display(
"{}" , format_args!(
"{_0:b}" ))]
struct TupleBinary(i32);
#[ derive(Display)]
#[ display(
"{}" , format_args!(
"{_0:o}" ))]
struct TupleOctal(i32);
#[ derive(Display)]
#[ display(
"{}" , format_args!(
"{field:x}" ))]
struct StructLowerHex {
field: i32,
}
#[ derive(Display)]
#[ display(
"{}" , format_args!(
"{field:X}" ))]
struct StructUpperHex {
field: i32,
}
#[ derive(Display)]
#[ display(
"{}" , format_args!(
"{field:e}" ))]
struct StructLowerExp {
field: f64,
}
#[ derive(Display)]
#[ display(
"{}" , format_args!(
"{field:E}" ))]
struct StructUpperExp {
field: f64,
}
#[ derive(Display)]
#[ display(
"{}" , format_args!(
"{field:p}" , field = *field))]
struct StructPointer<
'a> {
field: &
'a i32,
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , TupleDisplay(
7 )),
"7" );
assert_eq!(format!(
"{:03}" , TupleDebug(
8 )),
"8" );
assert_eq!(format!(
"{:07}" , TupleBinary(
7 )),
"111" );
assert_eq!(format!(
"{:03}" , TupleOctal(
9 )),
"11" );
assert_eq!(format!(
"{:03}" , StructLowerHex { field:
42 }),
"2a" );
assert_eq!(format!(
"{:03}" , StructUpperHex { field:
42 }),
"2A" );
assert_eq!(
format!(
"{:07}" , StructLowerExp { field:
42 .
0 }),
"4.2e1" ,
);
assert_eq!(
format!(
"{:07}" , StructUpperExp { field:
42 .
0 }),
"4.2E1" ,
);
let a =
42 ;
assert_eq!(
format!(
"{:018}" , StructPointer { field: &a }),
format!(
"{:p}" , &a),
);
}
}
mod omitted {
use super ::*;
mod on_modifiers {
use super ::*;
#[ derive(Display)]
#[ display(
"{_0:x?}" )]
struct LowerDebug(i32);
#[ derive(Display)]
#[ display(
"{_0:X?}" )]
struct UpperDebug(i32);
#[ derive(Display)]
#[ display(
"{:^}" , _
0 )]
struct Align(i32);
#[ derive(Display)]
#[ display(
"{:+}" , _
0 )]
struct Sign(i32);
#[ derive(Display)]
#[ display(
"{:#b}" , _
0 )]
struct Alternate(i32);
#[ derive(Display)]
#[ display(
"{:0}" , _
0 )]
struct ZeroPadded(i32);
#[ derive(Display)]
#[ display(
"{:07}" , _
0 )]
struct Width(i32);
#[ derive(Display)]
#[ display(
"{:.5}" , _
0 )]
struct Precision(f64);
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , LowerDebug(
7 )),
"7" );
assert_eq!(format!(
"{:03}" , UpperDebug(
8 )),
"8" );
assert_eq!(format!(
"{:03}" , Align(
5 )),
"5" );
assert_eq!(format!(
"{:03}" , Sign(
5 )),
"+5" );
assert_eq!(format!(
"{:07}" , Alternate(
5 )),
"0b101" );
assert_eq!(format!(
"{:07}" , ZeroPadded(-
5 )),
"-5" );
assert_eq!(format!(
"{:03}" , Width(
5 )),
"0000005" );
assert_eq!(format!(
"{:.3}" , Precision(
1 .
23456789 )),
"1.23457" );
}
}
}
}
mod r
#unsized {
use core::ptr;
use super ::*;
#[ derive(Display)]
struct Tuple(str);
#[ derive(Display)]
struct Struct {
tail: str,
}
#[ test]
fn assert() {
let dat =
"14" ;
let t =
unsafe { &*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Tuple) };
assert_eq!(t.to_string(),
"14" );
let s =
unsafe { &*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Struct ) };
assert_eq!(s.to_string(),
"14" );
}
mod interpolated {
use core::ptr;
use super ::*;
#[ derive(Display)]
#[ display(
"{}." , _
0 )]
struct Tuple1(str);
#[ derive(Display)]
#[ display(
"{_0}." )]
struct Tuple2(str);
#[ derive(Display)]
#[ display(
"{}." , tail)]
struct Struct1 {
tail: str,
}
#[ derive(Display)]
#[ display(
"{tail}." )]
struct Struct2 {
tail: str,
}
#[ test]
fn assert() {
let dat =
"14" ;
let t1 =
unsafe {
&*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Tuple1)
};
assert_eq!(t1.to_string(),
"14." );
let t2 =
unsafe {
&*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Tuple2)
};
assert_eq!(t2.to_string(),
"14." );
let s1 =
unsafe {
&*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Struct1)
};
assert_eq!(s1.to_string(),
"14." );
let s2 =
unsafe {
&*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Struct2)
};
assert_eq!(s2.to_string(),
"14." );
}
}
}
#[ cfg(nightly)]
mod never {
use super ::*;
#[ derive(Display)]
struct Tuple(!);
#[ derive(Display)]
struct Struct {
field: !,
}
}
}
mod multi_field {
use super ::*;
mod str {
use super ::*;
#[ derive(Display)]
#[ display(
"tuple" )]
struct Tuple(i32, i32);
#[ derive(Display)]
#[ display(
"struct" )]
struct Struct {
field1: i32,
field2: i32,
}
#[ test]
fn assert() {
assert_eq!(Tuple(
1 ,
2 ).to_string(),
"tuple" );
assert_eq!(
Struct {
field1:
1 ,
field2:
2 ,
}
.to_string(),
"struct" ,
);
}
}
mod interpolated {
use super ::*;
#[ derive(Display)]
#[ display(
"{_0} {ident} {_1} {} {}" ,
_
1 , _
0 + _
1 , ident =
123 , _
1 = _
0 ,
)]
struct Tuple(i32, i32);
#[ derive(Display)]
#[ display(
"{field1} {ident} {field2} {} {}" ,
field2, field1 + field2, ident =
123 , field2 = field1,
)]
struct Struct {
field1: i32,
field2: i32,
}
#[ test]
fn assert() {
assert_eq!(Tuple(
1 ,
2 ).to_string(),
"1 123 1 2 3" );
assert_eq!(
Struct {
field1:
1 ,
field2:
2 ,
}
.to_string(),
"1 123 1 2 3" ,
);
}
}
mod transparency {
use super ::*;
mod interpolated {
use super ::*;
#[ derive(Display)]
#[ display(
"{_0}" )]
struct TupleDisplay(i32, u64);
#[ derive(Display)]
#[ display(
"{:?}" , _
1 )]
struct TupleDebug(i32, u64);
#[ derive(Display)]
#[ display(
"{0:b}" , _
1 )]
struct TupleBinary(i32, u64);
#[ derive(Display)]
#[ display(
"{named:o}" , named = _
0 )]
struct TupleOctal(i32, u64);
#[ derive(Display)]
#[ display(
"{b:x}" )]
struct StructLowerHex {
a: i32,
b: u64,
}
#[ derive(Display)]
#[ display(
"{:X}" , a)]
struct StructUpperHex {
a: i32,
b: u64,
}
#[ derive(Display)]
#[ display(
"{a:e}" )]
struct StructLowerExp {
a: f64,
b: f32,
}
#[ derive(Display)]
#[ display(
"{:E}" , b)]
struct StructUpperExp {
a: f64,
b: f32,
}
#[ derive(Display)]
#[ display(
"{b:p}" )]
struct StructPointer<
'a> {
a: &
'a i32,
b: &
'a i32,
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , TupleDisplay(
7 ,
8 )),
"007" );
assert_eq!(format!(
"{:03}" , TupleDebug(
7 ,
8 )),
"008" );
assert_eq!(format!(
"{:07}" , TupleBinary(
6 ,
7 )),
"0000111" );
assert_eq!(format!(
"{:03}" , TupleOctal(
9 ,
10 )),
"011" );
assert_eq!(
format!(
"{:03}" , StructLowerHex { a:
41 , b:
42 }),
"02a"
);
assert_eq!(
format!(
"{:03}" , StructUpperHex { a:
42 , b:
43 }),
"02A"
);
assert_eq!(
format!(
"{:07}" , StructLowerExp { a:
42 .
0 , b:
43 .
0 }),
"004.2e1" ,
);
assert_eq!(
format!(
"{:07}" , StructUpperExp { a:
41 .
0 , b:
42 .
0 }),
"004.2E1" ,
);
let (a, b) = (
42 ,
43 );
assert_eq!(
format!(
"{:018}" , StructPointer { a: &a, b: &b }),
format!(
"{:018p}" , &b),
);
}
}
}
mod r
#unsized {
use super ::*;
mod interpolated {
use core::ptr;
use super ::*;
#[ derive(Display)]
#[ display(
"{}.{}" , _
0 , _
1 )]
struct Tuple1(char, str);
#[ derive(Display)]
#[ display(
"{_0}.{_1}" )]
struct Tuple2(char, str);
#[ derive(Display)]
#[ display(
"{}.{}" , head, tail)]
struct Struct1 {
head: char,
tail: str,
}
#[ derive(Display)]
#[ display(
"{head}.{tail}" )]
struct Struct2 {
head: char,
tail: str,
}
#[ test]
fn assert() {
let dat = [
51 i32,
3028017 ];
let t1 =
unsafe {
&*(ptr::addr_of!(dat)
as *
const [i32]
as *
const Tuple1)
};
assert_eq!(t1.to_string(),
"3.14" );
let t2 =
unsafe {
&*(ptr::addr_of!(dat)
as *
const [i32]
as *
const Tuple2)
};
assert_eq!(t2.to_string(),
"3.14" );
let s1 =
unsafe {
&*(ptr::addr_of!(dat)
as *
const [i32]
as *
const Struct1)
};
assert_eq!(s1.to_string(),
"3.14" );
let s2 =
unsafe {
&*(ptr::addr_of!(dat)
as *
const [i32]
as *
const Struct2)
};
assert_eq!(s2.to_string(),
"3.14" );
}
}
}
#[ cfg(nightly)]
mod never {
use super ::*;
#[ derive(Display)]
#[ display(
"{_0}" )]
struct Tuple(i32, !);
#[ derive(Display)]
#[ display(
"{field}" )]
struct Struct {
field: !,
other: i32,
}
}
}
}
mod enums {
use super ::*;
mod no_variants {
use super ::*;
#[ derive(Display)]
enum Void {}
const fn assert<T: Display>() {}
const _: () = assert::<Void>();
}
mod unit_variant {
use super ::*;
#[ derive(Display)]
enum Enum {
Unit,
r
#RawUnit ,
Unnamed(),
Named {},
#[ display(
"STR_UNIT" )]
StrUnit,
#[ display(
"STR_UNNAMED" )]
StrUnnamed(),
#[ display(
"STR_NAMED" )]
StrNamed {},
}
#[ test]
fn assert() {
assert_eq!(
Enum ::Unit.to_string(),
"Unit" );
assert_eq!(
Enum ::r
#RawUnit .to_string(),
"RawUnit" );
assert_eq!(
Enum ::Unnamed().to_string(),
"Unnamed" );
assert_eq!(
Enum ::Named {}.to_string(),
"Named" );
assert_eq!(
Enum ::StrUnit.to_string(),
"STR_UNIT" );
assert_eq!(
Enum ::StrUnnamed().to_string(),
"STR_UNNAMED" );
assert_eq!(
Enum ::StrNamed {}.to_string(),
"STR_NAMED" );
}
mod transparency {
use super ::*;
mod interpolated {
use super ::*;
const I32: i32 =
11 ;
const F64: f64 =
3 .
15 ;
const POINTER: &f64 = &
3 .
15 ;
#[ derive(Display)]
enum Unit {
#[ display(
"{I32}" )]
Display,
#[ display(
"{I32:?}" )]
Debug,
#[ display(
"{:b}" , I32)]
Binary,
#[ display(
"{0:o}" , I32)]
Octal,
#[ display(
"{I32:x}" )]
LowerHex,
#[ display(
"{:X}" , I32)]
UpperHex,
#[ display(
"{F64:e}" )]
LowerExp,
#[ display(
"{named:E}" , named = F64)]
UpperExp,
#[ display(
"{POINTER:p}" )]
Pointer,
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , Unit::Display),
"011" );
assert_eq!(format!(
"{:03}" , Unit::Debug),
"011" );
assert_eq!(format!(
"{:07}" , Unit::Binary),
"0001011" );
assert_eq!(format!(
"{:07}" , Unit::Octal),
"0000013" );
assert_eq!(format!(
"{:03}" , Unit::LowerHex),
"00b" );
assert_eq!(format!(
"{:03}" , Unit::UpperHex),
"00B" );
assert_eq!(format!(
"{:07}" , Unit::LowerExp),
"03.15e0" );
assert_eq!(format!(
"{:07}" , Unit::UpperExp),
"03.15E0" );
assert_eq!(
format!(
"{:018}" , Unit::Pointer),
format!(
"{POINTER:018p}" ),
);
}
}
mod omitted {
use super ::*;
mod on_modifiers {
use super ::*;
const I32: i32 =
11 ;
const F64: f64 =
3 .
15 ;
#[ derive(Display)]
enum Unit {
#[ display(
"{I32:x?}" )]
LowerDebug,
#[ display(
"{I32:X?}" )]
UpperDebug,
#[ display(
"{:^}" , I32)]
Align,
#[ display(
"{:+}" , I32)]
Sign,
#[ display(
"{:#b}" , I32)]
Alternate,
#[ display(
"{:0}" , I32)]
ZeroPadded,
#[ display(
"{:07}" , I32)]
Width,
#[ display(
"{:.1}" , F64)]
Precision,
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , Unit::LowerDebug),
"b" );
assert_eq!(format!(
"{:03}" , Unit::UpperDebug),
"B" );
assert_eq!(format!(
"{:03}" , Unit::Align),
"11" );
assert_eq!(format!(
"{:04}" , Unit::Sign),
"+11" );
assert_eq!(format!(
"{:07}" , Unit::Alternate),
"0b1011" );
assert_eq!(format!(
"{:07}" , Unit::ZeroPadded),
"11" );
assert_eq!(format!(
"{:03}" , Unit::Width),
"0000011" );
assert_eq!(format!(
"{:.3}" , Unit::Precision),
"3.1" );
}
}
}
}
}
mod single_field_variant {
use super ::*;
#[ derive(Display)]
enum Enum {
Unnamed(i32),
Named {
field: i32,
},
#[ display(
"unnamed" )]
StrUnnamed(i32),
#[ display(
"named" )]
StrNamed {
field: i32,
},
#[ display(
"{_0} {}" , _
0 )]
InterpolatedUnnamed(i32),
#[ display(
"{field} {}" , field)]
InterpolatedNamed {
field: i32,
},
}
#[ test]
fn assert() {
assert_eq!(
Enum ::Unnamed(
1 ).to_string(),
"1" );
assert_eq!(
Enum ::Named { field:
1 }.to_string(),
"1" );
assert_eq!(
Enum ::StrUnnamed(
1 ).to_string(),
"unnamed" );
assert_eq!(
Enum ::StrNamed { field:
1 }.to_string(),
"named" );
assert_eq!(
Enum ::InterpolatedUnnamed(
1 ).to_string(),
"1 1" );
assert_eq!(
Enum ::InterpolatedNamed { field:
1 }.to_string(),
"1 1" );
}
mod transparency {
use super ::*;
mod direct {
use super ::*;
#[ derive(Display)]
enum Display {
A(i32),
B { field: u8 },
}
#[ derive(Binary)]
enum Binary {
A(i32),
B { field: u8 },
}
#[ derive(Octal)]
enum Octal {
A(i32),
B { field: u8 },
}
#[ derive(LowerHex)]
enum LowerHex {
A(i32),
B { field: u8 },
}
#[ derive(UpperHex)]
enum UpperHex {
A(i32),
B { field: u8 },
}
#[ derive(LowerExp)]
enum LowerExp {
A(f64),
B { field: f32 },
}
#[ derive(UpperExp)]
enum UpperExp {
A(f64),
B { field: f32 },
}
#[ derive(Pointer)]
enum Pointer<
'a> {
A(&
'a i32),
B { field: &
'a u8 },
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , Display::A(
7 )),
"007" );
assert_eq!(format!(
"{:03}" , Display::B { field:
8 }),
"008" );
assert_eq!(format!(
"{:07b}" , Binary::A(
7 )),
"0000111" );
assert_eq!(format!(
"{:07b}" , Binary::B { field:
8 }),
"0001000" );
assert_eq!(format!(
"{:03o}" , Octal::A(
9 )),
"011" );
assert_eq!(format!(
"{:03o}" , Octal::B { field:
10 }),
"012" );
assert_eq!(format!(
"{:03x}" , LowerHex::A(
42 )),
"02a" );
assert_eq!(format!(
"{:03x}" , LowerHex::B { field:
43 }),
"02b" );
assert_eq!(format!(
"{:03X}" , UpperHex::A(
42 )),
"02A" );
assert_eq!(format!(
"{:03X}" , UpperHex::B { field:
43 }),
"02B" );
assert_eq!(format!(
"{:07e}" , LowerExp::A(
42 .
0 )),
"004.2e1" );
assert_eq!(
format!(
"{:07e}" , LowerExp::B { field:
43 .
0 }),
"004.3e1" ,
);
assert_eq!(format!(
"{:07E}" , UpperExp::A(
42 .
0 )),
"004.2E1" );
assert_eq!(
format!(
"{:07E}" , UpperExp::B { field:
43 .
0 }),
"004.3E1" ,
);
let (a, b) = (
7 ,
42 );
assert_eq!(
format!(
"{:018p}" , Pointer::A(&a)),
format!(
"{:018p}" , &a),
);
assert_eq!(
format!(
"{:018p}" , Pointer::B { field: &b }),
format!(
"{:018p}" , &b),
);
}
}
mod interpolated {
use super ::*;
#[ derive(Display)]
enum Display {
#[ display(
"{_0}" )]
A(i32),
#[ display(
"{}" , field)]
B { field: u8 },
}
#[ derive(Display)]
enum Debug {
#[ display(
"{0:?}" , _
0 )]
A(i32),
#[ display(
"{named:?}" , named = field)]
B { field: u8 },
}
#[ derive(Display)]
enum Binary {
#[ display(
"{_0:b}" )]
A(i32),
#[ display(
"{:b}" , field)]
B { field: u8 },
}
#[ derive(Display)]
enum Octal {
#[ display(
"{_0:o}" )]
A(i32),
#[ display(
"{:o}" , field)]
B { field: u8 },
}
#[ derive(Display)]
enum LowerHex {
#[ display(
"{_0:x}" )]
A(i32),
#[ display(
"{:x}" , field)]
B { field: u8 },
}
#[ derive(Display)]
enum UpperHex {
#[ display(
"{_0:X}" )]
A(i32),
#[ display(
"{:X}" , field)]
B { field: u8 },
}
#[ derive(Display)]
enum LowerExp {
#[ display(
"{:e}" , _
0 )]
A(f64),
#[ display(
"{field:e}" )]
B { field: f32 },
}
#[ derive(Display)]
enum UpperExp {
#[ display(
"{:E}" , _
0 )]
A(f64),
#[ display(
"{field:E}" )]
B { field: f32 },
}
#[ derive(Display)]
enum Pointer<
'a> {
#[ display(
"{:p}" , *_
0 )]
A(&
'a i32),
#[ display(
"{field:p}" )]
B { field: &
'a u8 },
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , Display::A(
7 )),
"007" );
assert_eq!(format!(
"{:03}" , Display::B { field:
8 }),
"008" );
assert_eq!(format!(
"{:03}" , Debug::A(
8 )),
"008" );
assert_eq!(format!(
"{:03}" , Debug::B { field:
9 }),
"009" );
assert_eq!(format!(
"{:07}" , Binary::A(
7 )),
"0000111" );
assert_eq!(format!(
"{:07}" , Binary::B { field:
8 }),
"0001000" );
assert_eq!(format!(
"{:03}" , Octal::A(
9 )),
"011" );
assert_eq!(format!(
"{:03}" , Octal::B { field:
10 }),
"012" );
assert_eq!(format!(
"{:03}" , LowerHex::A(
42 )),
"02a" );
assert_eq!(format!(
"{:03}" , LowerHex::B { field:
43 }),
"02b" );
assert_eq!(format!(
"{:03}" , UpperHex::A(
42 )),
"02A" );
assert_eq!(format!(
"{:03}" , UpperHex::B { field:
43 }),
"02B" );
assert_eq!(format!(
"{:07}" , LowerExp::A(
42 .
0 )),
"004.2e1" );
assert_eq!(
format!(
"{:07}" , LowerExp::B { field:
43 .
0 }),
"004.3e1" ,
);
assert_eq!(format!(
"{:07}" , UpperExp::A(
42 .
0 )),
"004.2E1" );
assert_eq!(
format!(
"{:07}" , UpperExp::B { field:
43 .
0 }),
"004.3E1" ,
);
let (a, b) = (
7 ,
42 );
assert_eq!(
format!(
"{:018}" , Pointer::A(&a)),
format!(
"{:018p}" , &a),
);
assert_eq!(
format!(
"{:018}" , Pointer::B { field: &b }),
format!(
"{:018p}" , &b),
);
}
}
mod suppressed {
use super ::*;
#[ derive(Display)]
enum Display {
#[ display(
"{}" , format_args!(
"{_0}" ))]
A(i32),
#[ display(
"{}" , format_args!(
"{}" , field))]
B { field: u8 },
}
#[ derive(Display)]
enum Debug {
#[ display(
"{}" , format_args!(
"{_0:?}" ))]
A(i32),
#[ display(
"{}" , format_args!(
"{:?}" , field))]
B { field: u8 },
}
#[ derive(Display)]
enum Binary {
#[ display(
"{}" , format_args!(
"{_0:b}" ))]
A(i32),
#[ display(
"{}" , format_args!(
"{:b}" , field))]
B { field: u8 },
}
#[ derive(Display)]
enum Octal {
#[ display(
"{}" , format_args!(
"{_0:o}" ))]
A(i32),
#[ display(
"{}" , format_args!(
"{:o}" , field))]
B { field: u8 },
}
#[ derive(Display)]
enum LowerHex {
#[ display(
"{}" , format_args!(
"{_0:x}" ))]
A(i32),
#[ display(
"{}" , format_args!(
"{:x}" , field))]
B { field: u8 },
}
#[ derive(Display)]
enum UpperHex {
#[ display(
"{}" , format_args!(
"{_0:X}" ))]
A(i32),
#[ display(
"{}" , format_args!(
"{:X}" , field))]
B { field: u8 },
}
#[ derive(Display)]
enum LowerExp {
#[ display(
"{}" , format_args!(
"{:e}" , _
0 ))]
A(f64),
#[ display(
"{}" , format_args!(
"{field:e}" ))]
B { field: f32 },
}
#[ derive(Display)]
enum UpperExp {
#[ display(
"{}" , format_args!(
"{:E}" , _
0 ))]
A(f64),
#[ display(
"{}" , format_args!(
"{field:E}" ))]
B { field: f32 },
}
#[ derive(Display)]
enum Pointer<
'a> {
#[ display(
"{}" , format_args!(
"{:p}" , *_
0 ))]
A(&
'a i32),
#[ display(
"{}" , format_args!(
"{field:p}" , field = *field))]
B { field: &
'a u8 },
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , Display::A(
7 )),
"7" );
assert_eq!(format!(
"{:03}" , Display::B { field:
8 }),
"8" );
assert_eq!(format!(
"{:03}" , Debug::A(
8 )),
"8" );
assert_eq!(format!(
"{:03}" , Debug::B { field:
9 }),
"9" );
assert_eq!(format!(
"{:07}" , Binary::A(
7 )),
"111" );
assert_eq!(format!(
"{:07}" , Binary::B { field:
8 }),
"1000" );
assert_eq!(format!(
"{:03}" , Octal::A(
9 )),
"11" );
assert_eq!(format!(
"{:03}" , Octal::B { field:
10 }),
"12" );
assert_eq!(format!(
"{:03}" , LowerHex::A(
42 )),
"2a" );
assert_eq!(format!(
"{:03}" , LowerHex::B { field:
43 }),
"2b" );
assert_eq!(format!(
"{:03}" , UpperHex::A(
42 )),
"2A" );
assert_eq!(format!(
"{:03}" , UpperHex::B { field:
43 }),
"2B" );
assert_eq!(format!(
"{:07}" , LowerExp::A(
42 .
0 )),
"4.2e1" );
assert_eq!(format!(
"{:07}" , LowerExp::B { field:
43 .
0 }),
"4.3e1" );
assert_eq!(format!(
"{:07}" , UpperExp::A(
42 .
0 )),
"4.2E1" );
assert_eq!(format!(
"{:07}" , UpperExp::B { field:
43 .
0 }),
"4.3E1" );
let (a, b) = (
7 ,
42 );
assert_eq!(format!(
"{:018}" , Pointer::A(&a)), format!(
"{:0p}" , &a));
assert_eq!(
format!(
"{:018}" , Pointer::B { field: &b }),
format!(
"{:p}" , &b),
);
}
}
}
#[ cfg(nightly)]
mod never {
use super ::*;
#[ derive(Display)]
enum Enum {
Unnamed(!),
Named { field: ! },
}
}
}
mod multi_field_variant {
use super ::*;
#[ derive(Display)]
enum Enum {
#[ display(
"unnamed" )]
StrUnnamed(i32, i32),
#[ display(
"named" )]
StrNamed { field1: i32, field2: i32 },
#[ display(
"{_0} {ident} {_1} {} {}" ,
_
1 , _
0 + _
1 , ident =
123 , _
1 = _
0 ,
)]
InterpolatedUnnamed(i32, i32),
#[ display(
"{field1} {ident} {field2} {} {}" ,
field2, field1 + field2, ident =
123 , field2 = field1,
)]
InterpolatedNamed { field1: i32, field2: i32 },
}
#[ test]
fn assert() {
assert_eq!(
Enum ::StrUnnamed(
1 ,
2 ).to_string(),
"unnamed" );
assert_eq!(
Enum ::StrNamed {
field1:
1 ,
field2:
2 ,
}
.to_string(),
"named" ,
);
assert_eq!(
Enum ::InterpolatedUnnamed(
1 ,
2 ).to_string(),
"1 123 1 2 3" );
assert_eq!(
Enum ::InterpolatedNamed {
field1:
1 ,
field2:
2 ,
}
.to_string(),
"1 123 1 2 3" ,
);
}
mod transparency {
use super ::*;
mod interpolated {
use super ::*;
#[ derive(Display)]
enum Display {
#[ display(
"{_0}" )]
A(i32, i64),
#[ display(
"{}" , b)]
B { a: u8, b: i32 },
}
#[ derive(Display)]
enum Debug {
#[ display(
"{0:?}" , _
1 )]
A(i32, i64),
#[ display(
"{named:?}" , named = a)]
B { a: u8, b: i32 },
}
#[ derive(Display)]
enum Binary {
#[ display(
"{_0:b}" )]
A(i32, i64),
#[ display(
"{:b}" , b)]
B { a: u8, b: i32 },
}
#[ derive(Display)]
enum Octal {
#[ display(
"{_0:o}" )]
A(i32, i64),
#[ display(
"{:o}" , b)]
B { a: u8, b: i32 },
}
#[ derive(Display)]
enum LowerHex {
#[ display(
"{_0:x}" )]
A(i32, i64),
#[ display(
"{:x}" , b)]
B { a: u8, b: i32 },
}
#[ derive(Display)]
enum UpperHex {
#[ display(
"{_0:X}" )]
A(i32, i64),
#[ display(
"{:X}" , b)]
B { a: u8, b: i32 },
}
#[ derive(Display)]
enum LowerExp {
#[ display(
"{:e}" , _
1 )]
A(f64, f32),
#[ display(
"{a:e}" )]
B { a: f64, b: f32 },
}
#[ derive(Display)]
enum UpperExp {
#[ display(
"{:E}" , _
1 )]
A(f64, f32),
#[ display(
"{a:E}" )]
B { a: f64, b: f32 },
}
#[ derive(Display)]
enum Pointer<
'a> {
#[ display(
"{:p}" , *_
1 )]
A(&
'a f64, &' a f32),
#[ display(
"{a:p}" )]
B { a: &
'a f64, b: &' a f32 },
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , Display::A(
7 ,
8 )),
"007" );
assert_eq!(format!(
"{:03}" , Display::B { a:
7 , b:
8 }),
"008" );
assert_eq!(format!(
"{:03}" , Debug::A(
7 ,
8 )),
"008" );
assert_eq!(format!(
"{:03}" , Debug::B { a:
7 , b:
8 }),
"007" );
assert_eq!(format!(
"{:07}" , Binary::A(
7 ,
8 )),
"0000111" );
assert_eq!(format!(
"{:07}" , Binary::B { a:
7 , b:
8 }),
"0001000" );
assert_eq!(format!(
"{:03}" , Octal::A(
9 ,
10 )),
"011" );
assert_eq!(format!(
"{:03}" , Octal::B { a:
9 , b:
10 }),
"012" );
assert_eq!(format!(
"{:03}" , LowerHex::A(
42 ,
41 )),
"02a" );
assert_eq!(format!(
"{:03}" , LowerHex::B { a:
42 , b:
43 }),
"02b" );
assert_eq!(format!(
"{:03}" , UpperHex::A(
42 ,
41 )),
"02A" );
assert_eq!(format!(
"{:03}" , UpperHex::B { a:
42 , b:
43 }),
"02B" );
assert_eq!(format!(
"{:07}" , LowerExp::A(
41 .
0 ,
42 .
0 )),
"004.2e1" );
assert_eq!(
format!(
"{:07}" , LowerExp::B { a:
43 .
0 , b:
52 .
0 }),
"004.3e1" ,
);
assert_eq!(format!(
"{:07}" , UpperExp::A(
41 .
0 ,
42 .
0 )),
"004.2E1" );
assert_eq!(
format!(
"{:07}" , UpperExp::B { a:
43 .
0 , b:
52 .
0 }),
"004.3E1" ,
);
let (a, b) = (
8 .
3 ,
42 .
1 );
assert_eq!(
format!(
"{:018}" , Pointer::A(&
7 .
0 , &a)),
format!(
"{:018p}" , &a),
);
assert_eq!(
format!(
"{:018}" , Pointer::B { a: &b, b: &
43 .
3 }),
format!(
"{:018p}" , &b),
);
}
}
}
#[ cfg(nightly)]
mod never {
use super ::*;
#[ derive(Display)]
enum Enum {
#[ display(
"{_0}" )]
Unnamed(i32, !),
#[ display(
"{field}" )]
Named { field: !, other: i32 },
}
}
mod shared_format {
use super ::*;
mod single {
use super ::*;
#[ derive(Display)]
#[ display(
"Variant: {_variant}" )]
enum Enum {
#[ display(
"A {_0}" )]
A(i32),
#[ display(
"B {}" , field)]
B {
field: i32,
},
C,
#[ display(
"D {_0} {}" , _
1 )]
D(i8, u8),
}
#[ test]
fn assert() {
assert_eq!(
Enum ::A(
1 ).to_string(),
"Variant: A 1" );
assert_eq!(
Enum ::B { field:
2 }.to_string(),
"Variant: B 2" );
assert_eq!(
Enum ::C.to_string(),
"Variant: C" );
assert_eq!(
Enum ::D(
1 ,
2 ).to_string(),
"Variant: D 1 2" );
}
}
mod transparent {
use super ::*;
#[ derive(Display)]
#[ display(
"{_variant}" )]
enum Enum {
#[ display(
"A {_0}" )]
A(i32),
#[ display(
"B {}" , field)]
B {
field: i32,
},
C,
#[ display(
"D {_0} {}" , _
1 )]
D(i8, u8),
#[ display(
"{_0:b}" )]
TransparentBinary(i32),
}
#[ test]
fn assert() {
assert_eq!(
Enum ::A(
1 ).to_string(),
"A 1" );
assert_eq!(
Enum ::B { field:
2 }.to_string(),
"B 2" );
assert_eq!(
Enum ::C.to_string(),
"C" );
assert_eq!(
Enum ::D(
1 ,
2 ).to_string(),
"D 1 2" );
assert_eq!(
format!(
"{:08}" ,
Enum ::TransparentBinary(
4 )),
"00000100" ,
);
}
}
mod multiple {
use super ::*;
#[ derive(Display)]
#[ display(
"{_variant} Variant: {_variant} {}" , _variant)]
enum Enum {
#[ display(
"A {_0}" )]
A(i32),
#[ display(
"B {}" , field)]
B {
field: i32,
},
C,
#[ display(
"D {_0} {}" , _
1 )]
D(i8, u8),
}
#[ test]
fn assert() {
assert_eq!(
Enum ::A(
1 ).to_string(),
"A 1 Variant: A 1 A 1" );
assert_eq!(
Enum ::B { field:
2 }.to_string(),
"B 2 Variant: B 2 B 2" ,
);
assert_eq!(
Enum ::C.to_string(),
"C Variant: C C" );
assert_eq!(
Enum ::D(
1 ,
2 ).to_string(),
"D 1 2 Variant: D 1 2 D 1 2" ,);
}
}
mod none {
use super ::*;
/// Make sure that variant-specific bounds are not added if `_variant` is not used.
struct NoDisplay;
#[ derive(Display)]
#[ display(
"Variant" )]
enum Enum <T> {
#[ display(
"A {_0}" )]
A(i32),
#[ display(
"B {}" , field)]
B {
field: i32,
},
C,
#[ display(
"D {_0} {}" , _
1 )]
D(i8, u8),
E {
a: u8,
b: i8,
},
X(T),
}
#[ test]
fn assert() {
assert_eq!(
Enum ::<NoDisplay>::A(
1 ).to_string(),
"A 1" );
assert_eq!(
Enum ::<NoDisplay>::B { field:
2 }.to_string(),
"B 2" ,);
assert_eq!(
Enum ::<NoDisplay>::C.to_string(),
"Variant" );
assert_eq!(
Enum ::<NoDisplay>::D(
1 ,
2 ).to_string(),
"D 1 2" );
assert_eq!(
Enum ::<NoDisplay>::E { a:
2 , b:
1 }.to_string(),
"Variant"
);
assert_eq!(
Enum ::<NoDisplay>::X(NoDisplay).to_string(),
"Variant" );
}
}
mod use_field {
use super ::*;
#[ derive(Display)]
#[ display(
"Variant {_0}" )]
enum Enum <T> {
A(i32),
B(&
'static str),
#[ display(
"D {_0} {}" , _
1 )]
D(i8, u8),
E(u8, i8),
X(T),
}
#[ test]
fn assert() {
assert_eq!(
Enum ::<u8>::A(
1 ).to_string(),
"Variant 1" );
assert_eq!(
Enum ::<u8>::B(
"abc" ).to_string(),
"Variant abc" );
assert_eq!(
Enum ::<u8>::D(
1 ,
2 ).to_string(),
"D 1 2" );
assert_eq!(
Enum ::<u8>::E(
2 ,
1 ).to_string(),
"Variant 2" );
assert_eq!(
Enum ::<u8>::X(
9 ).to_string(),
"Variant 9" );
}
}
mod only_field {
use super ::*;
/// Make sure that top-level-specific bounds are not added if a field is not used.
struct NoDisplay;
#[ derive(Display)]
#[ display(
"{_0}" )]
enum Enum <X, Y> {
#[ display(
"A" )]
A(i32),
#[ display(
"B" )]
B(&
'static str),
#[ display(
"D {_0} {}" , _
1 )]
D(i8, u8),
E(u8, i8),
#[ display(
"X" )]
X(X),
Y(Y),
}
#[ test]
fn assert() {
assert_eq!(
Enum ::<NoDisplay, u8>::A(
1 ).to_string(),
"A" );
assert_eq!(
Enum ::<NoDisplay, u8>::B(
"abc" ).to_string(),
"B" );
assert_eq!(
Enum ::<NoDisplay, u8>::D(
1 ,
2 ).to_string(),
"D 1 2" );
assert_eq!(
Enum ::<NoDisplay, u8>::E(
2 ,
1 ).to_string(),
"2" );
assert_eq!(
Enum ::<NoDisplay, u8>::X(NoDisplay).to_string(),
"X" );
assert_eq!(
Enum ::<NoDisplay, u8>::Y(
9 ).to_string(),
"9" );
}
}
mod only_multiple_field {
use super ::*;
/// Make sure that top-level-specific bounds are not added if a field is not used.
struct NoDisplay;
#[ derive(Display)]
#[ display(
"{_0} & {_1}" )]
enum Enum <X, Y> {
#[ display(
"A" )]
A(i32),
#[ display(
"B" )]
B(&
'static str),
#[ display(
"D {_0} {}" , _
1 )]
D(i8, u8),
E(u8, i8),
#[ display(
"X" )]
X(X),
Y(Y, i8),
}
#[ test]
fn assert() {
assert_eq!(
Enum ::<NoDisplay, u8>::A(
1 ).to_string(),
"A" );
assert_eq!(
Enum ::<NoDisplay, u8>::B(
"abc" ).to_string(),
"B" );
assert_eq!(
Enum ::<NoDisplay, u8>::D(
1 ,
2 ).to_string(),
"D 1 2" );
assert_eq!(
Enum ::<NoDisplay, u8>::E(
2 ,
1 ).to_string(),
"2 & 1" );
assert_eq!(
Enum ::<NoDisplay, u8>::X(NoDisplay).to_string(),
"X" );
assert_eq!(
Enum ::<NoDisplay, u8>::Y(
9 ,
10 ).to_string(),
"9 & 10" );
}
}
mod use_field_and_variant {
use super ::*;
#[ derive(Display)]
#[ display(
"Variant {_variant} {}" , _
0 )]
enum Enum <T> {
#[ display(
"A" )]
A(i32),
#[ display(
"B" )]
B(&
'static str),
#[ display(
"D {_0} {}" , _
1 )]
D(i8, u8),
#[ display(
"X" )]
X(T),
Y(T),
}
#[ test]
fn assert() {
assert_eq!(
Enum ::<u8>::A(
1 ).to_string(),
"Variant A 1" );
assert_eq!(
Enum ::<u8>::B(
"abc" ).to_string(),
"Variant B abc" );
assert_eq!(
Enum ::<u8>::D(
1 ,
2 ).to_string(),
"Variant D 1 2 1" );
assert_eq!(
Enum ::<u8>::X(
9 ).to_string(),
"Variant X 9" );
assert_eq!(
Enum ::<u8>::Y(
9 ).to_string(),
"Variant 9 9" );
}
}
mod as_debug {
use super ::*;
#[ derive(Debug, Display)]
#[ display(
"{self:?}" )]
enum Enum {
#[ display(
"A {_0}" )]
A(i32),
#[ display(
"B {}" , field)]
B {
field: i32,
},
C,
#[ display(
"D {_0} {}" , _
1 )]
D(i8, u8),
E {
a: u8,
b: i8,
},
}
#[ test]
fn assert() {
assert_eq!(
Enum ::A(
1 ).to_string(),
"A 1" );
assert_eq!(
Enum ::B { field:
2 }.to_string(),
"B 2" );
assert_eq!(
Enum ::C.to_string(),
"C" );
assert_eq!(
Enum ::D(
1 ,
2 ).to_string(),
"D 1 2" );
assert_eq!(
Enum ::E { a:
2 , b:
1 }.to_string(),
"E { a: 2, b: 1 }" );
}
}
mod pointer {
use super ::*;
#[ derive(Display)]
#[ display(
"Pointer {_0:p} {_variant} {_0:p}" )]
enum Pointer<
'a> {
#[ display(
"A" )]
A(&
'a f64),
#[ display(
"B" )]
B(&
'a f32),
}
#[ test]
fn assert() {
let (a, b) = (
8 .
3 ,
42 .
1 );
assert_eq!(
Pointer::A(&a).to_string(),
format!(
"Pointer {0:p} A {0:p}" , &a),
);
assert_eq!(
Pointer::B(&b).to_string(),
format!(
"Pointer {0:p} B {0:p}" , &b),
);
}
}
}
}
}
mod generic {
use super ::*;
trait Bound {}
impl Bound
for () {}
fn display_bound<T: Bound>(_: &T) -> &
'static str {
"()"
}
#[ derive(Display)]
#[ display(
"Generic {}" , field)]
struct NamedGenericStruct<T> {
field: T,
}
#[ test]
fn named_generic_struct() {
assert_eq!(NamedGenericStruct { field:
1 }.to_string(),
"Generic 1" );
}
#[ derive(Display)]
#[ display(
"Generic {field}" )]
struct InterpolatedNamedGenericStruct<T> {
field: T,
}
#[ test]
fn interpolated_named_generic_struct() {
assert_eq!(
InterpolatedNamedGenericStruct { field:
1 }.to_string(),
"Generic 1" ,
);
}
#[ derive(Display)]
#[ display(
"Generic {field:<>width$.prec$} {field}" )]
struct InterpolatedNamedGenericStructWidthPrecision<T> {
field: T,
width: usize,
prec: usize,
}
#[ test]
fn interpolated_named_generic_struct_width_precision() {
assert_eq!(
InterpolatedNamedGenericStructWidthPrecision {
field:
1 .
2345 ,
width:
9 ,
prec:
2 ,
}
.to_string(),
"Generic <<<<<1.23 1.2345" ,
);
}
#[ derive(Display)]
struct AutoNamedGenericStruct<T> {
field: T,
}
#[ test]
fn auto_named_generic_struct() {
assert_eq!(AutoNamedGenericStruct { field:
1 }.to_string(),
"1" );
}
#[ derive(Display)]
#[ display(
"{alias}" , alias = field)]
struct AliasedNamedGenericStruct<T> {
field: T,
}
#[ test]
fn aliased_named_generic_struct() {
assert_eq!(AliasedNamedGenericStruct { field:
1 }.to_string(),
"1" );
}
#[ derive(Display)]
#[ display(
"{field1}" , field1 = field2)]
struct AliasedFieldNamedGenericStruct<T> {
field1: T,
field2: i32,
}
#[ test]
fn aliased_field_named_generic_struct() {
assert_eq!(
AliasedFieldNamedGenericStruct {
field1: (),
field2:
1 ,
}
.to_string(),
"1" ,
);
}
#[ derive(Display)]
#[ display(
"Generic {}" , _
0 )]
struct UnnamedGenericStruct<T>(T);
#[ test]
fn unnamed_generic_struct() {
assert_eq!(UnnamedGenericStruct(
2 ).to_string(),
"Generic 2" );
}
#[ derive(Display)]
#[ display(
"Generic {_0}" )]
struct InterpolatedUnnamedGenericStruct<T>(T);
#[ test]
fn interpolated_unnamed_generic_struct() {
assert_eq!(InterpolatedUnnamedGenericStruct(
2 ).to_string(),
"Generic 2" );
}
#[ derive(Display)]
struct AutoUnnamedGenericStruct<T>(T);
#[ test]
fn auto_unnamed_generic_struct() {
assert_eq!(AutoUnnamedGenericStruct(
2 ).to_string(),
"2" );
}
#[ derive(Display)]
#[ display(
"{alias}" , alias = _
0 )]
struct AliasedUnnamedGenericStruct<T>(T);
#[ test]
fn aliased_unnamed_generic_struct() {
assert_eq!(AliasedUnnamedGenericStruct(
2 ).to_string(),
"2" );
}
#[ derive(Display)]
#[ display(
"{_0}" , _
0 = _
1 )]
struct AliasedFieldUnnamedGenericStruct<T>(T, i32);
#[ test]
fn aliased_field_unnamed_generic_struct() {
assert_eq!(AliasedFieldUnnamedGenericStruct((),
2 ).to_string(),
"2" );
}
#[ derive(Display)]
enum GenericEnum<A, B> {
#[ display(
"Gen::A {}" , field)]
A { field: A },
#[ display(
"Gen::B {}" , _
0 )]
B(B),
}
#[ test]
fn generic_enum() {
assert_eq!(GenericEnum::A::<_, u8> { field:
1 }.to_string(),
"Gen::A 1" );
assert_eq!(GenericEnum::B::<u8, _>(
2 ).to_string(),
"Gen::B 2" );
}
#[ derive(Display)]
enum InterpolatedGenericEnum<A, B> {
#[ display(
"Gen::A {field}" )]
A { field: A },
#[ display(
"Gen::B {_0}" )]
B(B),
}
#[ test]
fn interpolated_generic_enum() {
assert_eq!(
InterpolatedGenericEnum::A::<_, u8> { field:
1 }.to_string(),
"Gen::A 1" ,
);
assert_eq!(
InterpolatedGenericEnum::B::<u8, _>(
2 ).to_string(),
"Gen::B 2" ,
);
}
#[ derive(Display)]
enum AutoGenericEnum<A, B> {
A { field: A },
B(B),
}
#[ test]
fn auto_generic_enum() {
assert_eq!(AutoGenericEnum::A::<_, u8> { field:
1 }.to_string(),
"1" );
assert_eq!(AutoGenericEnum::B::<u8, _>(
2 ).to_string(),
"2" );
}
#[ derive(Display)]
#[ display(
"{} {} <-> {0:o} {1:#x} <-> {0:?} {1:X?}" , a, b)]
struct MultiTraitNamedGenericStruct<A, B> {
a: A,
b: B,
}
#[ test]
fn multi_trait_named_generic_struct() {
let s = MultiTraitNamedGenericStruct { a:
8 u8, b:
255 };
assert_eq!(s.to_string(),
"8 255 <-> 10 0xff <-> 8 FF" );
}
#[ derive(Display)]
#[ display(
"{} {b} <-> {0:o} {1:#x} <-> {0:?} {1:X?}" , a, b)]
struct InterpolatedMultiTraitNamedGenericStruct<A, B> {
a: A,
b: B,
}
#[ test]
fn interpolated_multi_trait_named_generic_struct() {
let s = InterpolatedMultiTraitNamedGenericStruct { a:
8 u8, b:
255 };
assert_eq!(s.to_string(),
"8 255 <-> 10 0xff <-> 8 FF" );
}
#[ derive(Display)]
#[ display(
"{} {} {{}} {0:o} {1:#x} - {0:>4?} {1:^4X?}" , _
0 , _
1 )]
struct MultiTraitUnnamedGenericStruct<A, B>(A, B);
#[ test]
fn multi_trait_unnamed_generic_struct() {
let s = MultiTraitUnnamedGenericStruct(
8 u8,
255 );
assert_eq!(s.to_string(),
"8 255 {} 10 0xff - 8 FF " );
}
#[ derive(Display)]
#[ display(
"{} {_1} {{}} {0:o} {1:#x} - {0:>4?} {1:^4X?}" , _
0 , _
1 )]
struct InterpolatedMultiTraitUnnamedGenericStruct<A, B>(A, B);
#[ test]
fn interpolated_multi_trait_unnamed_generic_struct() {
let s = InterpolatedMultiTraitUnnamedGenericStruct(
8 u8,
255 );
assert_eq!(s.to_string(),
"8 255 {} 10 0xff - 8 FF " );
}
#[ derive(Display)]
#[ display(
"{}" ,
3 *
4 )]
struct UnusedGenericStruct<T>(T);
#[ test]
fn unused_generic_struct() {
let s = UnusedGenericStruct(());
assert_eq!(s.to_string(),
"12" );
}
mod associated_type_field_enumerator {
use super ::*;
trait Trait {
type Type ;
}
struct Struct ;
impl Trait for Struct {
type Type = i32;
}
#[ test]
fn auto_generic_named_struct_associated() {
#[ derive(Display)]
struct AutoGenericNamedStructAssociated<T:
Trait > {
field: <T
as Trait >::
Type ,
}
let s = AutoGenericNamedStructAssociated::<
Struct > { field:
10 };
assert_eq!(s.to_string(),
"10" );
}
#[ test]
fn auto_generic_unnamed_struct_associated() {
#[ derive(Display)]
struct AutoGenericUnnamedStructAssociated<T:
Trait >(<T
as Trait >::
Type );
let s = AutoGenericUnnamedStructAssociated::<
Struct >(
10 );
assert_eq!(s.to_string(),
"10" );
}
#[ test]
fn auto_generic_enum_associated() {
#[ derive(Display)]
enum AutoGenericEnumAssociated<T:
Trait > {
Enumerator(<T
as Trait >::
Type ),
}
let e = AutoGenericEnumAssociated::<
Struct >::Enumerator(
10 );
assert_eq!(e.to_string(),
"10" );
}
}
mod complex_type_field_enumerator {
use super ::*;
#[ derive(Display)]
struct Struct <T>(T);
#[ test]
fn auto_generic_named_struct_complex() {
#[ derive(Display)]
struct AutoGenericNamedStructComplex<T> {
field:
Struct <T>,
}
let s = AutoGenericNamedStructComplex { field:
Struct (
10 ) };
assert_eq!(s.to_string(),
"10" );
}
#[ test]
fn auto_generic_unnamed_struct_complex() {
#[ derive(Display)]
struct AutoGenericUnnamedStructComplex<T>(
Struct <T>);
let s = AutoGenericUnnamedStructComplex(
Struct (
10 ));
assert_eq!(s.to_string(),
"10" );
}
#[ test]
fn auto_generic_enum_complex() {
#[ derive(Display)]
enum AutoGenericEnumComplex<T> {
Enumerator(
Struct <T>),
}
let e = AutoGenericEnumComplex::Enumerator(
Struct (
10 ));
assert_eq!(e.to_string(),
"10" )
}
}
mod reference {
use super ::*;
#[ test]
fn auto_generic_reference() {
#[ derive(Display)]
struct AutoGenericReference<
'a, T>(&' a T);
let s = AutoGenericReference(&
10 );
assert_eq!(s.to_string(),
"10" );
}
#[ test]
fn auto_generic_static_reference() {
#[ derive(Display)]
struct AutoGenericStaticReference<T:
'static>(&' static T);
let s = AutoGenericStaticReference(&
10 );
assert_eq!(s.to_string(),
"10" );
}
}
mod indirect {
use super ::*;
#[ derive(Display)]
struct Struct <T>(T);
#[ test]
fn auto_generic_indirect() {
#[ derive(Display)]
struct AutoGenericIndirect<T:
'static>(Struct<&' static T>);
const V: i32 =
10 ;
let s = AutoGenericIndirect(
Struct (&V));
assert_eq!(s.to_string(),
"10" );
}
}
mod raw {
use super ::*;
#[ derive(Display)]
struct StructOne<T> {
r
#thing : T,
}
#[ derive(Display)]
struct StructOneKeyword<T> {
r
#struct : T,
}
#[ derive(Display)]
enum Enum <T> {
One { r
#thing : T },
}
#[ test]
fn assert() {
assert_eq!(StructOne::<u8> { r
#thing :
8 }.to_string(),
"8" );
assert_eq!(StructOneKeyword::<u8> { r
#struct :
8 }.to_string(),
"8" );
assert_eq!(
Enum ::<u8>::One { r
#thing :
8 }.to_string(),
"8" );
}
mod interpolated {
use super ::*;
#[ derive(Display)]
#[ display(
"{thing}" )]
struct StructOne<T> {
r
#thing : T,
}
#[ derive(Display)]
#[ display(
"{struct}" )]
struct StructOneKeyword<T> {
r
#struct : T,
}
#[ derive(Display)]
enum Enum1<T> {
#[ display(
"{thing}" )]
One { r
#thing : T },
}
#[ derive(Display)]
enum Enum1Keyword<T> {
#[ display(
"{struct}" )]
One { r
#struct : T },
}
#[ derive(Display)]
#[ display(
"{thing}" )]
enum Enum1Top<T> {
One { r
#thing : T },
}
#[ derive(Display)]
#[ display(
"{struct}" )]
enum Enum1TopKeyword<T> {
One { r
#struct : T },
}
#[ derive(Display)]
#[ display(
"{a}:{b}" )]
struct StructTwo<A, B> {
r
#a : A,
b: B,
}
#[ derive(Display)]
#[ display(
"{pub}:{b}" )]
struct StructTwoKeyword<A, B> {
r
#pub : A,
b: B,
}
#[ derive(Display)]
enum Enum2<A, B> {
#[ display(
"{a}:{b}" )]
Two { r
#a : A, b: B },
}
#[ derive(Display)]
enum Enum2Keyword<A, B> {
#[ display(
"{pub}:{b}" )]
Two { r
#pub : A, b: B },
}
#[ derive(Display)]
#[ display(
"{a}:{b}" )]
enum Enum2Shared<A, B> {
Two { r
#a : A, b: B },
}
#[ derive(Display)]
#[ display(
"{pub}:{b}" )]
enum Enum2SharedKeyword<A, B> {
Two { r
#pub : A, b: B },
}
#[ test]
fn assert() {
assert_eq!(StructOne::<u8> { r
#thing :
8 }.to_string(),
"8" );
assert_eq!(StructOneKeyword::<u8> { r
#struct :
8 }.to_string(),
"8" );
assert_eq!(Enum1::<u8>::One { r
#thing :
8 }.to_string(),
"8" );
assert_eq!(Enum1Keyword::<u8>::One { r
#struct :
8 }.to_string(),
"8" );
assert_eq!(Enum1Top::<u8>::One { r
#thing :
8 }.to_string(),
"8" );
assert_eq!(Enum1TopKeyword::<u8>::One { r
#struct :
8 }.to_string(),
"8" );
assert_eq!(StructTwo::<u8, u16> { r
#a :
8 , b:
16 }.to_string(),
"8:16" );
assert_eq!(
StructTwoKeyword::<u8, u16> { r
#pub :
8 , b:
16 }.to_string(),
"8:16" ,
);
assert_eq!(Enum2::<u8, u16>::Two { r
#a :
8 , b:
16 }.to_string(),
"8:16" );
assert_eq!(
Enum2Keyword::<u8, u16>::Two { r
#pub :
8 , b:
16 }.to_string(),
"8:16" ,
);
assert_eq!(
Enum2Shared::<u8, u16>::Two { r
#a :
8 , b:
16 }.to_string(),
"8:16" ,
);
assert_eq!(
Enum2SharedKeyword::<u8, u16>::Two { r
#pub :
8 , b:
16 }.to_string(),
"8:16" ,
);
}
}
}
mod bound {
use super ::*;
#[ test]
fn simple() {
#[ derive(Display)]
#[ display(
"{} {}" , _
0 , _
1 )]
struct Struct <T1, T2>(T1, T2);
let s =
Struct (
10 ,
20 );
assert_eq!(s.to_string(),
"10 20" );
}
#[ test]
fn debug() {
#[ derive(Debug)]
struct OnlyDebug;
#[ derive(Display)]
#[ display(
"{:?}" , _
0 )]
struct Struct <T>(T);
let s =
Struct (OnlyDebug);
assert_eq!(s.to_string(),
"OnlyDebug" );
}
#[ test]
fn underscored_simple() {
#[ derive(Display)]
#[ display(
"{_0} {_1}" )]
struct Struct <T1, T2>(T1, T2);
let s =
Struct (
10 ,
20 );
assert_eq!(s.to_string(),
"10 20" );
}
#[ test]
fn underscored_debug() {
#[ derive(Debug)]
struct OnlyDebug;
#[ derive(Display)]
#[ display(
"{_0:?}" )]
struct Struct <T>(T);
let s =
Struct (OnlyDebug);
assert_eq!(s.to_string(),
"OnlyDebug" );
}
#[ test]
fn redundant() {
#[ derive(Display)]
#[ display(bound(T1: ::core::fmt::Display, T2: ::core::fmt::Debug))]
#[ display(
"{} {:?}" , _
0 , _
1 )]
struct Struct <T1, T2>(T1, T2);
let s =
Struct (
10 ,
20 );
assert_eq!(s.to_string(),
"10 20" );
}
#[ test]
fn underscored_redundant() {
#[ derive(Display)]
#[ display(bound(T1: ::core::fmt::Display, T2: ::core::fmt::Debug))]
#[ display(
"{_0} {_1:?}" )]
struct Struct <T1, T2>(T1, T2);
let s =
Struct (
10 ,
20 );
assert_eq!(s.to_string(),
"10 20" );
}
#[ test]
fn complex() {
#[ derive(Debug)]
struct DebugOnly;
trait Trait1 {
fn function1(&
self ) -> &
'static str;
}
trait Trait2 {
fn function2(&
self ) -> &
'static str;
}
impl Trait1
for i32 {
fn function1(&
self ) -> &
'static str {
"WHAT"
}
}
impl Trait2
for i32 {
fn function2(&
self ) -> &
'static str {
"EVER"
}
}
impl Trait1
for DebugOnly {
fn function1(&
self ) -> &
'static str {
"MAN"
}
}
#[ derive(Display)]
#[ display(
"{} {} {} {} {:?}" , _
0 .function1(), _
0 , _
0 .function2(), _
1 .function1(), _
1 )]
#[ display(bound(T1: Trait1 + Trait2, T2: Trait1))]
struct Struct <T1, T2>(T1, T2);
let s =
Struct (
10 , DebugOnly);
assert_eq!(s.to_string(),
"WHAT 10 EVER MAN DebugOnly" );
}
#[ test]
fn underscored_complex() {
#[ derive(Debug)]
struct DebugOnly;
trait Trait1 {
fn function1(&
self ) -> &
'static str;
}
trait Trait2 {
fn function2(&
self ) -> &
'static str;
}
impl Trait1
for i32 {
fn function1(&
self ) -> &
'static str {
"WHAT"
}
}
impl Trait2
for i32 {
fn function2(&
self ) -> &
'static str {
"EVER"
}
}
impl Trait1
for DebugOnly {
fn function1(&
self ) -> &
'static str {
"MAN"
}
}
#[ derive(Display)]
#[ display(bound(T1: Trait1 + Trait2, T2: Trait1))]
#[ display(
"{} {_0} {} {} {_1:?}" , _
0 .function1(), _
0 .function2(), _
1 .function1())]
struct Struct <T1, T2>(T1, T2);
let s =
Struct (
10 , DebugOnly);
assert_eq!(s.to_string(),
"WHAT 10 EVER MAN DebugOnly" );
}
#[ test]
fn explicit_only() {
trait Trait {
fn function(&
self ) -> &
'static str;
}
struct NoDisplay;
impl Trait for NoDisplay {
fn function(&
self ) -> &
'static str {
"no display"
}
}
#[ derive(Display)]
#[ display(
"{}" , _
0 .function())]
#[ display(bound(T:
Trait ))]
struct Struct <T>(T);
let s =
Struct (NoDisplay);
assert_eq!(s.to_string(),
"no display" );
}
}
mod transparency {
use super ::*;
mod direct {
use super ::*;
#[ derive(
Display, Binary, Octal, LowerHex, UpperHex, LowerExp, UpperExp, Pointer
)]
struct Tuple<T>(T);
#[ derive(
Display, Binary, Octal, LowerHex, UpperHex, LowerExp, UpperExp, Pointer
)]
struct Struct <T> {
field: T,
}
#[ derive(
Display, Binary, Octal, LowerHex, UpperHex, LowerExp, UpperExp, Pointer
)]
enum Enum <A, B> {
A(A),
B { field: B },
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , Tuple(
7 )),
"007" );
assert_eq!(format!(
"{:03}" ,
Struct { field:
7 }),
"007" );
assert_eq!(format!(
"{:03}" ,
Enum ::<_, i8>::A(
7 )),
"007" );
assert_eq!(format!(
"{:03}" ,
Enum ::<i8, _>::B { field:
8 }),
"008" );
assert_eq!(format!(
"{:07b}" , Tuple(
7 )),
"0000111" );
assert_eq!(format!(
"{:07b}" ,
Struct { field:
7 }),
"0000111" );
assert_eq!(format!(
"{:07b}" ,
Enum ::<_, i8>::A(
7 )),
"0000111" );
assert_eq!(format!(
"{:07b}" ,
Enum ::<i8, _>::B { field:
8 }),
"0001000" );
assert_eq!(format!(
"{:03o}" , Tuple(
9 )),
"011" );
assert_eq!(format!(
"{:03o}" ,
Struct { field:
9 }),
"011" );
assert_eq!(format!(
"{:03o}" ,
Enum ::<_, i8>::A(
9 )),
"011" );
assert_eq!(format!(
"{:03o}" ,
Enum ::<i8, _>::B { field:
10 }),
"012" );
assert_eq!(format!(
"{:03x}" , Tuple(
42 )),
"02a" );
assert_eq!(format!(
"{:03x}" ,
Struct { field:
42 }),
"02a" );
assert_eq!(format!(
"{:03x}" ,
Enum ::<_, i8>::A(
42 )),
"02a" );
assert_eq!(format!(
"{:03x}" ,
Enum ::<i8, _>::B { field:
43 }),
"02b" );
assert_eq!(format!(
"{:03X}" , Tuple(
42 )),
"02A" );
assert_eq!(format!(
"{:03X}" ,
Struct { field:
42 }),
"02A" );
assert_eq!(format!(
"{:03X}" ,
Enum ::<_, i8>::A(
42 )),
"02A" );
assert_eq!(format!(
"{:03X}" ,
Enum ::<i8, _>::B { field:
43 }),
"02B" );
assert_eq!(format!(
"{:07e}" , Tuple(
42 .
0 )),
"004.2e1" );
assert_eq!(format!(
"{:07e}" ,
Struct { field:
42 .
0 }),
"004.2e1" );
assert_eq!(format!(
"{:07e}" ,
Enum ::<_, i8>::A(
42 .
0 )),
"004.2e1" );
assert_eq!(
format!(
"{:07e}" ,
Enum ::<i8, _>::B { field:
43 .
0 }),
"004.3e1" ,
);
assert_eq!(format!(
"{:07E}" , Tuple(
42 .
0 )),
"004.2E1" );
assert_eq!(format!(
"{:07E}" ,
Struct { field:
42 .
0 }),
"004.2E1" );
assert_eq!(format!(
"{:07E}" ,
Enum ::<_, i8>::A(
42 .
0 )),
"004.2E1" );
assert_eq!(
format!(
"{:07E}" ,
Enum ::<i8, _>::B { field:
43 .
0 }),
"004.3E1" ,
);
let (a, b) = (
42 ,
7 );
assert_eq!(format!(
"{:018p}" , Tuple(&a)), format!(
"{:018p}" , &a));
assert_eq!(
format!(
"{:018p}" ,
Struct { field: &a }),
format!(
"{:018p}" , &a),
);
assert_eq!(
format!(
"{:018p}" ,
Enum ::<_, &i8>::A(&b)),
format!(
"{:018p}" , &b),
);
assert_eq!(
format!(
"{:018p}" ,
Enum ::<&i8, _>::B { field: &a }),
format!(
"{:018p}" , &a),
);
}
}
mod interpolated {
use super ::*;
#[ derive(Display)]
#[ display(
"{_0}" )]
struct TupleDisplay<T>(T);
#[ derive(Display)]
#[ display(
"{0:?}" , _
0 )]
struct TupleDebug<T>(T);
#[ derive(Display)]
#[ display(
"{_0:b}" )]
struct TupleBinary<T, Y>(T, Y);
#[ derive(Display)]
#[ display(
"{_1:o}" )]
struct TupleOctal<Y, T>(Y, T);
#[ derive(Display)]
#[ display(
"{0:x}" , _
0 )]
struct TupleLowerHex<T>(T);
#[ derive(Display)]
#[ display(
"{_0:X}" )]
struct TupleUpperHex<T>(T);
#[ derive(Display)]
#[ display(
"{:e}" , _
0 )]
struct TupleLowerExp<T>(T);
#[ derive(Display)]
#[ display(
"{:E}" , _
0 )]
struct TupleUpperExp<T>(T);
#[ derive(Display)]
#[ display(
"{_0:p}" )]
struct TuplePointer<T>(T);
#[ derive(Display)]
#[ display(
"{field}" )]
struct StructDisplay<T> {
field: T,
}
#[ derive(Display)]
#[ display(
"{a:b}" )]
struct StructBinary<T, Y> {
a: T,
b: Y,
}
#[ derive(Display)]
#[ display(
"{named:o}" , named = b)]
struct StructOctal<Y, T> {
a: Y,
b: T,
}
#[ derive(Display)]
#[ display(
"{field:x}" )]
struct StructLowerHex<T> {
field: T,
}
#[ derive(Display)]
#[ display(
"{field:X}" )]
struct StructUpperHex<T> {
field: T,
}
#[ derive(Display)]
#[ display(
"{:e}" , field)]
struct StructLowerExp<T> {
field: T,
}
#[ derive(Display)]
#[ display(
"{:E}" , field)]
struct StructUpperExp<T> {
field: T,
}
#[ derive(Display)]
#[ display(
"{field:p}" )]
struct StructPointer<T> {
field: T,
}
#[ derive(Display)]
enum EnumDisplay<A, B> {
#[ display(
"{_0}" )]
A(A),
#[ display(
"{}" , field)]
B { field: B },
}
#[ derive(Display)]
enum EnumBinary<A, B, C, D> {
#[ display(
"{_0:b}" )]
A(A, C),
#[ display(
"{:b}" , b)]
B { b: B, d: D },
}
#[ derive(Display)]
enum EnumOctal<A, B, C, D> {
#[ display(
"{_1:o}" )]
A(A, C),
#[ display(
"{:o}" , d)]
B { b: B, d: D },
}
#[ derive(Display)]
enum EnumLowerHex<A, B> {
#[ display(
"{_0:x}" )]
A(A),
#[ display(
"{:x}" , field)]
B { field: B },
}
#[ derive(Display)]
enum EnumUpperHex<A, B> {
#[ display(
"{_0:X}" )]
A(A),
#[ display(
"{:X}" , field)]
B { field: B },
}
#[ derive(Display)]
enum EnumLowerExp<A, B> {
#[ display(
"{:e}" , _
0 )]
A(A),
#[ display(
"{field:e}" )]
B { field: B },
}
#[ derive(Display)]
enum EnumUpperExp<A, B> {
#[ display(
"{:E}" , _
0 )]
A(A),
#[ display(
"{field:E}" )]
B { field: B },
}
#[ derive(Display)]
enum EnumPointer<A, B> {
#[ display(
"{_0:p}" )]
A(A),
#[ display(
"{field:p}" )]
B { field: B },
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , TupleDisplay(
7 )),
"007" );
assert_eq!(format!(
"{:03}" , TupleDebug(
8 )),
"008" );
assert_eq!(format!(
"{:03}" , StructDisplay { field:
7 }),
"007" );
assert_eq!(format!(
"{:03}" , EnumDisplay::<_, i8>::A(
7 )),
"007" );
assert_eq!(
format!(
"{:03}" , EnumDisplay::<i8, _>::B { field:
8 }),
"008" ,
);
assert_eq!(format!(
"{:07}" , TupleBinary(
7 , ())),
"0000111" );
assert_eq!(format!(
"{:07}" , StructBinary { a:
7 , b: () }),
"0000111" );
assert_eq!(
format!(
"{:07}" , EnumBinary::<_, i8, _, ()>::A(
7 , ())),
"0000111" ,
);
assert_eq!(
format!(
"{:07}" , EnumBinary::<i8, _, (), _>::B { b:
8 , d: () }),
"0001000" ,
);
assert_eq!(format!(
"{:03}" , TupleOctal((),
9 )),
"011" );
assert_eq!(format!(
"{:03}" , StructOctal { a: (), b:
9 }),
"011" );
assert_eq!(
format!(
"{:03}" , EnumOctal::<_, (), _, i8>::A((),
9 )),
"011" ,
);
assert_eq!(
format!(
"{:03}" , EnumOctal::<(), _, i8, _>::B { b: (), d:
10 }),
"012" ,
);
assert_eq!(format!(
"{:03}" , TupleLowerHex(
42 )),
"02a" );
assert_eq!(format!(
"{:03}" , StructLowerHex { field:
42 }),
"02a" );
assert_eq!(format!(
"{:03}" , EnumLowerHex::<_, i8>::A(
42 )),
"02a" );
assert_eq!(
format!(
"{:03}" , EnumLowerHex::<i8, _>::B { field:
43 }),
"02b" ,
);
assert_eq!(format!(
"{:03}" , TupleUpperHex(
42 )),
"02A" );
assert_eq!(format!(
"{:03}" , StructUpperHex { field:
42 }),
"02A" );
assert_eq!(format!(
"{:03}" , EnumUpperHex::<_, i8>::A(
42 )),
"02A" );
assert_eq!(
format!(
"{:03}" , EnumUpperHex::<i8, _>::B { field:
43 }),
"02B" ,
);
assert_eq!(format!(
"{:07}" , TupleLowerExp(
42 .
0 )),
"004.2e1" );
assert_eq!(format!(
"{:07}" , StructLowerExp { field:
42 .
0 }),
"004.2e1" );
assert_eq!(format!(
"{:07}" , EnumLowerExp::<_, i8>::A(
42 .
0 )),
"004.2e1" );
assert_eq!(
format!(
"{:07}" , EnumLowerExp::<i8, _>::B { field:
43 .
0 }),
"004.3e1" ,
);
assert_eq!(format!(
"{:07}" , TupleUpperExp(
42 .
0 )),
"004.2E1" );
assert_eq!(format!(
"{:07}" , StructUpperExp { field:
42 .
0 }),
"004.2E1" );
assert_eq!(format!(
"{:07}" , EnumUpperExp::<_, i8>::A(
42 .
0 )),
"004.2E1" );
assert_eq!(
format!(
"{:07}" , EnumUpperExp::<i8, _>::B { field:
43 .
0 }),
"004.3E1" ,
);
let (a, b) = (
42 ,
7 );
assert_eq!(format!(
"{:018}" , TuplePointer(&a)), format!(
"{:018p}" , &a));
assert_eq!(
format!(
"{:018}" , StructPointer { field: &a }),
format!(
"{:018p}" , &a),
);
assert_eq!(
format!(
"{:018}" , EnumPointer::<_, &i8>::A(&b)),
format!(
"{:018p}" , &b),
);
assert_eq!(
format!(
"{:018}" , EnumPointer::<&i8, _>::B { field: &a }),
format!(
"{:018p}" , &a),
);
}
mod shared_format {
use super ::*;
#[ derive(Display)]
#[ display(
"{_0}" )]
enum EnumDisplay<A, B> {
A(A),
B(B),
}
#[ derive(Display)]
#[ display(
"{:b}" , _
0 )]
enum EnumBinary<A, B, C, D> {
A(A, C),
B(B, D),
}
#[ derive(Display)]
#[ display(
"{:o}" , d)]
enum EnumOctal<A, B, C, D> {
A { b: A, d: C },
B { b: B, d: D },
}
#[ derive(Display)]
#[ display(
"{field:x}" )]
enum EnumLowerHex<A, B> {
A { field: A },
B { field: B },
}
#[ derive(Display)]
#[ display(
"{:X}" , field)]
enum EnumUpperHex<A, B> {
A { field: A },
B { field: B },
}
#[ derive(Display)]
#[ display(
"{_0:e}" )]
enum EnumLowerExp<A, B> {
A(A),
B(B),
}
#[ derive(Display)]
#[ display(
"{:E}" , _
0 )]
enum EnumUpperExp<A, B> {
A(A),
B(B),
}
#[ derive(Display)]
#[ display(
"{_0:p}" )]
enum EnumPointer<A, B> {
A(A),
B(B),
}
#[ test]
fn assert() {
assert_eq!(format!(
"{:03}" , EnumDisplay::<i8, u8>::A(
7 )),
"007" );
assert_eq!(format!(
"{:03}" , EnumDisplay::<i8, u8>::B(
8 )),
"008" );
assert_eq!(format!(
"{:07}" , TupleBinary(
7 , ())),
"0000111" );
assert_eq!(
format!(
"{:07}" , EnumBinary::<i8, u8, (), ()>::A(
7 , ())),
"0000111" ,
);
assert_eq!(
format!(
"{:07}" , EnumBinary::<i8, u8, (), ()>::B(
8 , ())),
"0001000" ,
);
assert_eq!(
format!(
"{:03}" ,
EnumOctal::<(), (), i8, u8>::A { b: (), d:
9 },
),
"011" ,
);
assert_eq!(
format!(
"{:03}" ,
EnumOctal::<(), (), i8, u8>::B { b: (), d:
10 },
),
"012" ,
);
assert_eq!(
format!(
"{:03}" , EnumLowerHex::<i8, u8>::A { field:
42 }),
"02a" ,
);
assert_eq!(
format!(
"{:03}" , EnumLowerHex::<i8, u8>::B { field:
43 }),
"02b" ,
);
assert_eq!(
format!(
"{:03}" , EnumUpperHex::<i8, u8>::A { field:
42 }),
"02A" ,
);
assert_eq!(
format!(
"{:03}" , EnumUpperHex::<i8, u8>::B { field:
43 }),
"02B" ,
);
assert_eq!(
format!(
"{:07}" , EnumLowerExp::<f32, f64>::A(
42 .
0 )),
"004.2e1"
);
assert_eq!(
format!(
"{:07}" , EnumLowerExp::<f32, f64>::B(
43 .
0 )),
"004.3e1"
);
assert_eq!(
format!(
"{:07}" , EnumUpperExp::<f32, f64>::A(
42 .
0 )),
"004.2E1"
);
assert_eq!(
format!(
"{:07}" , EnumUpperExp::<f32, f64>::B(
43 .
0 )),
"004.3E1" ,
);
let (a, b) = (
42 ,
7 );
assert_eq!(
format!(
"{:018}" , EnumPointer::<&i8, &u8>::A(&b)),
format!(
"{:018p}" , &b),
);
assert_eq!(
format!(
"{:018}" , EnumPointer::<&i8, &u8>::B(&a)),
format!(
"{:018p}" , &a),
);
}
mod mixed {
use super ::*;
#[ derive(Display)]
#[ display(
"{_variant}" )]
enum EnumDisplay<A, B> {
A(A),
#[ display(
"{_0}" )]
B(B),
}
#[ derive(Display)]
#[ display(
"{_variant}" )]
enum EnumBinary<A, B, C, D> {
#[ display(
"{_0:b}" )]
A(A, C),
#[ display(
"{:b}" , b)]
B { b: B, d: D },
}
#[ derive(Display)]
#[ display(
"{_variant}" )]
enum EnumOctal<A, B, C, D> {
#[ display(
"{_1:o}" )]
A(A, C),
#[ display(
"{:o}" , d)]
B { b: B, d: D },
}
#[ derive(Display)]
#[ display(
"{_variant}" )]
enum EnumLowerHex<A, B> {
#[ display(
"{_0:x}" )]
A(A),
#[ display(
"{:x}" , field)]
B { field: B },
}
#[ derive(Display)]
#[ display(
"{_variant}" )]
enum EnumUpperHex<A, B> {
#[ display(
"{_0:X}" )]
A(A),
#[ display(
"{:X}" , field)]
B { field: B },
}
#[ derive(Display)]
#[ display(
"{_variant}" )]
enum EnumLowerExp<A, B> {
#[ display(
"{:e}" , _
0 )]
A(A),
#[ display(
"{field:e}" )]
B { field: B },
}
#[ derive(Display)]
#[ display(
"{_variant}" )]
enum EnumUpperExp<A, B> {
#[ display(
"{:E}" , _
0 )]
A(A),
#[ display(
"{field:E}" )]
B { field: B },
}
#[ derive(Display)]
#[ display(
"{_variant}" )]
enum EnumPointer<A, B> {
#[ display(
"{_0:p}" )]
A(A),
#[ display(
"{field:p}" )]
B { field: B },
}
#[ test]
fn assert() {
assert_eq!(
format!(
"{:03}" , EnumDisplay::<i8, u8>::A(
7 )),
"007" ,
);
assert_eq!(
format!(
"{:03}" , EnumDisplay::<i8, u8>::B(
8 )),
"008" ,
);
assert_eq!(
format!(
"{:07}" , EnumBinary::<_, i8, _, ()>::A(
7 , ())),
"0000111" ,
);
assert_eq!(
format!(
"{:07}" ,
EnumBinary::<i8, _, (), _>::B { b:
8 , d: () },
),
"0001000" ,
);
assert_eq!(
format!(
"{:03}" , EnumOctal::<_, (), _, i8>::A((),
9 )),
"011" ,
);
assert_eq!(
format!(
"{:03}" ,
EnumOctal::<(), _, i8, _>::B { b: (), d:
10 }
),
"012" ,
);
assert_eq!(
format!(
"{:03}" , EnumLowerHex::<_, i8>::A(
42 )),
"02a" ,
);
assert_eq!(
format!(
"{:03}" , EnumLowerHex::<i8, _>::B { field:
43 }),
"02b" ,
);
assert_eq!(
format!(
"{:03}" , EnumUpperHex::<_, i8>::A(
42 )),
"02A" ,
);
assert_eq!(
format!(
"{:03}" , EnumUpperHex::<i8, _>::B { field:
43 }),
"02B" ,
);
assert_eq!(
format!(
"{:07}" , EnumLowerExp::<_, i8>::A(
42 .
0 )),
"004.2e1" ,
);
assert_eq!(
format!(
"{:07}" , EnumLowerExp::<i8, _>::B { field:
43 .
0 }),
"004.3e1" ,
);
assert_eq!(
format!(
"{:07}" , EnumUpperExp::<_, i8>::A(
42 .
0 )),
"004.2E1" ,
);
assert_eq!(
format!(
"{:07}" , EnumUpperExp::<i8, _>::B { field:
43 .
0 }),
"004.3E1" ,
);
let (a, b) = (
42 ,
7 );
assert_eq!(
format!(
"{:018}" , EnumPointer::<_, &i8>::A(&b)),
format!(
"{:018p}" , &b),
);
assert_eq!(
format!(
"{:018}" , EnumPointer::<&i8, _>::B { field: &a }),
format!(
"{:018p}" , &a),
);
}
}
}
}
mod omitted {
use super ::*;
mod on_modifiers {
use super ::*;
#[ derive(Display)]
enum Enum <A, B, C, D> {
#[ display(
"{_0:x?}" )]
LowerDebug(A),
#[ display(
"{_0:X?}" )]
UpperDebug(B),
#[ display(
"{:^}" , _
0 )]
Align(C),
#[ display(
"{:+}" , _
0 )]
Sign(C),
#[ display(
"{:#b}" , _
0 )]
Alternate(C),
#[ display(
"{:0}" , _
0 )]
ZeroPadded(C),
#[ display(
"{:07}" , _
0 )]
Width(C),
#[ display(
"{:.5}" , _
0 )]
Precision(D),
}
#[ test]
fn assert() {
assert_eq!(
format!(
"{:03}" ,
Enum ::<_, u8, u8, f64>::LowerDebug(
7 )),
"7" ,
);
assert_eq!(
format!(
"{:03}" ,
Enum ::<u8, _, u8, f64>::UpperDebug(
8 )),
"8" ,
);
assert_eq!(format!(
"{:03}" ,
Enum ::<u8, u8, _, f64>::Align(
5 )),
"5" );
assert_eq!(format!(
"{:03}" ,
Enum ::<u8, u8, _, f64>::Sign(
5 )),
"+5" );
assert_eq!(
format!(
"{:07}" ,
Enum ::<u8, u8, _, f64>::Alternate(
5 )),
"0b101" ,
);
assert_eq!(
format!(
"{:07}" ,
Enum ::<u8, u8, _, f64>::ZeroPadded(-
5 )),
"-5" ,
);
assert_eq!(
format!(
"{:03}" ,
Enum ::<u8, u8, _, f64>::Width(
5 )),
"0000005" ,
);
assert_eq!(
format!(
"{:.3}" ,
Enum ::<u8, u8, u8, _>::Precision(
1 .
23456789 )),
"1.23457" ,
);
}
}
}
}
mod r
#unsized {
use core::ptr;
use super ::*;
#[ derive(Display)]
struct Tuple<T: ?Sized>(T);
#[ derive(Display)]
struct Struct <T: ?Sized> {
tail: T,
}
#[ test]
fn assert() {
let dat =
"14" ;
let t =
unsafe { &*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Tuple<str>) };
assert_eq!(t.to_string(),
"14" );
let s =
unsafe {
&*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Struct <str>)
};
assert_eq!(s.to_string(),
"14" );
}
mod interpolated {
use core::ptr;
use super ::*;
#[ derive(Display)]
#[ display(
"{}." , _
0 )]
struct Tuple1<T: ?Sized>(T);
#[ derive(Display)]
#[ display(
"{_0}." )]
struct Tuple2<T: ?Sized>(T);
#[ derive(Display)]
#[ display(
"{}." , tail)]
struct Struct1<T: ?Sized> {
tail: T,
}
#[ derive(Display)]
#[ display(
"{tail}." )]
struct Struct2<T: ?Sized> {
tail: T,
}
#[ test]
fn assert() {
let dat =
"14" ;
let t1 =
unsafe {
&*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Tuple1<str>)
};
assert_eq!(t1.to_string(),
"14." );
let t2 =
unsafe {
&*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Tuple2<str>)
};
assert_eq!(t2.to_string(),
"14." );
let s1 =
unsafe {
&*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Struct1<str>)
};
assert_eq!(s1.to_string(),
"14." );
let s2 =
unsafe {
&*(ptr::addr_of!(*dat)
as *
const [i32]
as *
const Struct2<str>)
};
assert_eq!(s2.to_string(),
"14." );
}
}
}
}
// See: https://github.com/JelteF/derive_more/issues/363
mod type_variables {
mod our_alloc {
#[ cfg(not(feature =
"std" ))]
pub use alloc::{boxed::
Box , format, vec::Vec};
#[ cfg(not(feature =
"std" ))]
pub use core::iter;
#[ cfg(feature =
"std" )]
pub use std::{boxed::
Box , format, iter, vec::Vec};
}
use our_alloc::{format, iter,
Box };
// We want `Vec` in scope to test that code generation works if it is there.
#[ allow(unused_imports)]
use our_alloc::Vec;
use derive_more::with_trait::Display;
#[ derive(Display, Debug)]
#[ display(
"{inner:?}" )]
#[ display(bounds(T: Display))]
struct OptionalBox<T> {
inner: Option<
Box <T>>,
}
#[ derive(Display, Debug)]
#[ display(
"{next}" )]
struct ItemStruct {
next: OptionalBox<ItemStruct>,
}
#[ derive(Display)]
#[ derive(Debug)]
struct ItemTuple(OptionalBox<ItemTuple>);
#[ derive(Display)]
#[ derive(Debug)]
#[ display(
"Item({_0})" )]
struct ItemTupleContainerFmt(OptionalBox<ItemTupleContainerFmt>);
#[ derive(Display, Debug)]
#[ display(
"{next}" )]
enum ItemEnumOuterFormat {
Variant1 {
next: OptionalBox<ItemEnumOuterFormat>,
},
Variant2 {
next: OptionalBox<i32>,
},
}
#[ derive(Display, Debug)]
enum ItemEnumInnerFormat {
#[ display(
"{next} {inner}" )]
Node {
next: OptionalBox<ItemEnumInnerFormat>,
inner: i32,
},
#[ display(
"{inner}" )]
Leaf { inner: i32 },
}
#[ derive(Display)]
#[ derive(Debug)]
#[ display(
"{next:?}, {real:?}" )]
struct VecMeansDifferent<Vec> {
next: our_alloc::Vec<i32>,
real: Vec,
}
#[ derive(Display)]
#[ derive(Debug)]
#[ display(
"{t:?}" )]
struct Array<T> {
t: [T;
10 ],
}
mod parens {
#! [allow(unused_parens)]
// test that type is found even in parentheses
use derive_more::Display;
#[ derive(Display)]
struct Paren<T> {
t: (T),
}
}
#[ derive(Display)]
struct ParenthesizedGenericArgumentsInput<T> {
t:
dyn Fn (T) -> i32,
}
#[ derive(Display)]
struct ParenthesizedGenericArgumentsOutput<T> {
t:
dyn Fn (i32) -> T,
}
#[ derive(Display)]
struct Ptr<T> {
t: *
const T,
}
#[ derive(Display)]
struct Reference<
'a, T> {
t: &
'a T,
}
#[ derive(Display)]
struct Slice<
'a, T> {
t: &
'a [T],
}
#[ derive(Display)]
struct BareFn<T> {
t:
Box <
fn (T) -> T>,
}
#[ derive(Display)]
struct Tuple<T> {
t:
Box <(T, T)>,
}
trait MyTrait<T> {}
#[ derive(Display)]
struct TraitObject<T> {
t:
Box <
dyn MyTrait<T>>,
}
#[ derive(Display)]
#[ display(
"{iter:?} with {elem:?}" )]
struct AssocType<I: Iterator> {
iter: I,
elem: Option<I::Item>,
}
#[ derive(Display)]
#[ display(
"{item:?} with {elem:?}" )]
struct CollidedPathName<Item> {
item: Item,
elem: Option<some_path::Item>,
}
mod some_path {
#[ derive(Debug)]
pub struct Item;
}
#[ test]
fn assert() {
assert_eq!(
format!(
"{}" ,
ItemStruct {
next: OptionalBox {
inner: Some(
Box ::new(ItemStruct {
next: OptionalBox { inner: None },
})),
},
},
),
"Some(ItemStruct { next: OptionalBox { inner: None } })" ,
);
assert_eq!(
format!(
"{}" ,
ItemTuple(OptionalBox {
inner: Some(
Box ::new(ItemTuple(OptionalBox { inner: None }))),
}),
),
"Some(ItemTuple(OptionalBox { inner: None }))" ,
);
assert_eq!(
format!(
"{}" ,
ItemTupleContainerFmt(OptionalBox {
inner: Some(
Box ::new(ItemTupleContainerFmt(OptionalBox {
inner: None,
}))),
}),
),
"Item(Some(ItemTupleContainerFmt(OptionalBox { inner: None })))" ,
);
let item = ItemEnumOuterFormat::Variant1 {
next: OptionalBox {
inner: Some(
Box ::new(ItemEnumOuterFormat::Variant2 {
next: OptionalBox { inner: None },
})),
},
};
assert_eq!(
format!(
"{item}" ),
"Some(Variant2 { next: OptionalBox { inner: None } })" ,
);
assert_eq!(
format!(
"{}" ,
AssocType {
iter: iter::empty::<bool>(),
elem: None,
},
),
"Empty with None" ,
);
assert_eq!(
format!(
"{}" ,
CollidedPathName {
item:
false ,
elem: Some(some_path::Item),
},
),
"false with Some(Item)" ,
);
}
}
Messung V0.5 in Prozent C=99 H=95 G=96
¤ Dauer der Verarbeitung: 0.73 Sekunden
(vorverarbeitet am 2026-08-25)
¤ *© Formatika GbR, Deutschland
