1155 lines
33 KiB
Rust
1155 lines
33 KiB
Rust
#![cfg_attr(not(feature = "std"), no_std)]
|
|
#![allow(dead_code)]
|
|
|
|
#[cfg(not(feature = "std"))]
|
|
extern crate alloc;
|
|
|
|
mod structs {
|
|
mod unit {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Unit;
|
|
|
|
#[derive(Debug)]
|
|
struct Tuple();
|
|
|
|
#[derive(Debug)]
|
|
struct Struct {}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Unit), "Unit");
|
|
assert_eq!(format!("{:#?}", Unit), "Unit");
|
|
assert_eq!(format!("{:?}", Tuple()), "Tuple");
|
|
assert_eq!(format!("{:#?}", Tuple()), "Tuple");
|
|
assert_eq!(format!("{:?}", Struct {}), "Struct");
|
|
assert_eq!(format!("{:#?}", Struct {}), "Struct");
|
|
}
|
|
}
|
|
|
|
mod single_field {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Tuple(i32);
|
|
|
|
#[derive(Debug)]
|
|
struct Struct {
|
|
field: i32,
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Tuple(0)), "Tuple(0)");
|
|
assert_eq!(format!("{:#?}", Tuple(0)), "Tuple(\n 0,\n)");
|
|
assert_eq!(format!("{:?}", Struct { field: 0 }), "Struct { field: 0 }");
|
|
assert_eq!(
|
|
format!("{:#?}", Struct { field: 0 }),
|
|
"Struct {\n field: 0,\n}",
|
|
);
|
|
}
|
|
|
|
mod str_field {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Tuple(#[debug("i32")] i32);
|
|
|
|
#[derive(Debug)]
|
|
struct Struct {
|
|
#[debug("i32")]
|
|
field: i32,
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Tuple(0)), "Tuple(i32)");
|
|
assert_eq!(format!("{:#?}", Tuple(0)), "Tuple(\n i32,\n)");
|
|
assert_eq!(
|
|
format!("{:?}", Struct { field: 0 }),
|
|
"Struct { field: i32 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Struct { field: 0 }),
|
|
"Struct {\n field: i32,\n}",
|
|
);
|
|
}
|
|
}
|
|
|
|
mod interpolated_field {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Tuple(#[debug("{_0}.{}", _0)] i32);
|
|
|
|
#[derive(Debug)]
|
|
struct Struct {
|
|
#[debug("{field}.{}", field)]
|
|
field: i32,
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Tuple(0)), "Tuple(0.0)");
|
|
assert_eq!(format!("{:#?}", Tuple(0)), "Tuple(\n 0.0,\n)");
|
|
assert_eq!(
|
|
format!("{:?}", Struct { field: 0 }),
|
|
"Struct { field: 0.0 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Struct { field: 0 }),
|
|
"Struct {\n field: 0.0,\n}",
|
|
);
|
|
}
|
|
}
|
|
|
|
mod ignore {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Tuple(#[debug(ignore)] i32);
|
|
|
|
#[derive(Debug)]
|
|
struct Struct {
|
|
#[debug(skip)]
|
|
field: i32,
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Tuple(0)), "Tuple(..)");
|
|
assert_eq!(format!("{:#?}", Tuple(0)), "Tuple(..)");
|
|
assert_eq!(format!("{:?}", Struct { field: 0 }), "Struct { .. }");
|
|
assert_eq!(format!("{:#?}", Struct { field: 0 }), "Struct { .. }");
|
|
}
|
|
}
|
|
}
|
|
|
|
mod multi_field {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Tuple(i32, i32);
|
|
|
|
#[derive(Debug)]
|
|
struct Struct {
|
|
field1: i32,
|
|
field2: i32,
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Tuple(1, 2)), "Tuple(1, 2)");
|
|
assert_eq!(format!("{:#?}", Tuple(1, 2)), "Tuple(\n 1,\n 2,\n)");
|
|
assert_eq!(
|
|
format!(
|
|
"{:?}",
|
|
Struct {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"Struct { field1: 1, field2: 2 }",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:#?}",
|
|
Struct {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"Struct {\n field1: 1,\n field2: 2,\n}",
|
|
);
|
|
}
|
|
|
|
mod str_field {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Tuple(i32, #[debug("i32")] i32);
|
|
|
|
#[derive(Debug)]
|
|
struct Struct {
|
|
#[debug("i32")]
|
|
field1: i32,
|
|
field2: i32,
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Tuple(1, 2)), "Tuple(1, i32)");
|
|
assert_eq!(
|
|
format!("{:#?}", Tuple(1, 2)),
|
|
"Tuple(\n 1,\n i32,\n)",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:?}",
|
|
Struct {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"Struct { field1: i32, field2: 2 }",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:#?}",
|
|
Struct {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"Struct {\n field1: i32,\n field2: 2,\n}",
|
|
);
|
|
}
|
|
}
|
|
|
|
mod interpolated_field {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Tuple(i32, #[debug("{_0}.{}", _1)] i32);
|
|
|
|
#[derive(Debug)]
|
|
struct Struct {
|
|
#[debug("{field1}.{}", field2)]
|
|
field1: i32,
|
|
field2: i32,
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Tuple(1, 2)), "Tuple(1, 1.2)");
|
|
assert_eq!(
|
|
format!("{:#?}", Tuple(1, 2)),
|
|
"Tuple(\n 1,\n 1.2,\n)",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:?}",
|
|
Struct {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"Struct { field1: 1.2, field2: 2 }",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:#?}",
|
|
Struct {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"Struct {\n field1: 1.2,\n field2: 2,\n}",
|
|
);
|
|
}
|
|
}
|
|
|
|
mod ignore {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Tuple(#[debug(ignore)] i32, i32);
|
|
|
|
#[derive(Debug)]
|
|
struct Struct {
|
|
field1: i32,
|
|
#[debug(skip)]
|
|
field2: i32,
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Tuple(1, 2)), "Tuple(2, ..)");
|
|
assert_eq!(format!("{:#?}", Tuple(1, 2)), "Tuple(\n 2,\n ..\n)",);
|
|
assert_eq!(
|
|
format!(
|
|
"{:?}",
|
|
Struct {
|
|
field1: 1,
|
|
field2: 2
|
|
}
|
|
),
|
|
"Struct { field1: 1, .. }",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:#?}",
|
|
Struct {
|
|
field1: 1,
|
|
field2: 2
|
|
}
|
|
),
|
|
"Struct {\n field1: 1,\n ..\n}",
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mod enums {
|
|
mod no_variants {
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
enum Void {}
|
|
|
|
const fn assert<T: core::fmt::Debug>() {}
|
|
const _: () = assert::<Void>();
|
|
}
|
|
|
|
mod unit_variant {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
enum Enum {
|
|
Unit,
|
|
Unnamed(),
|
|
Named {},
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Enum::Unit), "Unit");
|
|
assert_eq!(format!("{:#?}", Enum::Unit), "Unit");
|
|
assert_eq!(format!("{:?}", Enum::Unnamed()), "Unnamed");
|
|
assert_eq!(format!("{:#?}", Enum::Unnamed()), "Unnamed");
|
|
assert_eq!(format!("{:?}", Enum::Named {}), "Named");
|
|
assert_eq!(format!("{:#?}", Enum::Named {}), "Named");
|
|
}
|
|
}
|
|
|
|
mod single_field_variant {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
enum Enum {
|
|
Unnamed(i32),
|
|
Named {
|
|
field: i32,
|
|
},
|
|
StrUnnamed(#[debug("i32")] i32),
|
|
StrNamed {
|
|
#[debug("i32")]
|
|
field: i32,
|
|
},
|
|
InterpolatedUnnamed(#[debug("{_0}.{}", _0)] i32),
|
|
InterpolatedNamed {
|
|
#[debug("{field}.{}", field)]
|
|
field: i32,
|
|
},
|
|
SkippedUnnamed(#[debug(skip)] i32),
|
|
SkippedNamed {
|
|
#[debug(skip)]
|
|
field: i32,
|
|
},
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Enum::Unnamed(1)), "Unnamed(1)");
|
|
assert_eq!(format!("{:#?}", Enum::Unnamed(1)), "Unnamed(\n 1,\n)");
|
|
assert_eq!(
|
|
format!("{:?}", Enum::Named { field: 1 }),
|
|
"Named { field: 1 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::Named { field: 1 }),
|
|
"Named {\n field: 1,\n}",
|
|
);
|
|
assert_eq!(format!("{:?}", Enum::StrUnnamed(1)), "StrUnnamed(i32)");
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::StrUnnamed(1)),
|
|
"StrUnnamed(\n i32,\n)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", Enum::StrNamed { field: 1 }),
|
|
"StrNamed { field: i32 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::StrNamed { field: 1 }),
|
|
"StrNamed {\n field: i32,\n}",
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", Enum::InterpolatedUnnamed(1)),
|
|
"InterpolatedUnnamed(1.1)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::InterpolatedUnnamed(1)),
|
|
"InterpolatedUnnamed(\n 1.1,\n)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", Enum::InterpolatedNamed { field: 1 }),
|
|
"InterpolatedNamed { field: 1.1 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::InterpolatedNamed { field: 1 }),
|
|
"InterpolatedNamed {\n field: 1.1,\n}",
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", Enum::SkippedUnnamed(1)),
|
|
"SkippedUnnamed(..)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::SkippedUnnamed(1)),
|
|
"SkippedUnnamed(..)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", Enum::SkippedNamed { field: 1 }),
|
|
"SkippedNamed { .. }",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::SkippedNamed { field: 1 }),
|
|
"SkippedNamed { .. }",
|
|
);
|
|
}
|
|
}
|
|
|
|
mod multi_field_variant {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
enum Enum {
|
|
Unnamed(i32, i32),
|
|
Named {
|
|
field1: i32,
|
|
field2: i32,
|
|
},
|
|
StrUnnamed(#[debug("i32")] i32, i32),
|
|
StrNamed {
|
|
field1: i32,
|
|
#[debug("i32")]
|
|
field2: i32,
|
|
},
|
|
InterpolatedUnnamed(i32, #[debug("{_0}.{}", _1)] i32),
|
|
InterpolatedNamed {
|
|
#[debug("{field1}.{}", field2)]
|
|
field1: i32,
|
|
field2: i32,
|
|
},
|
|
SkippedUnnamed(i32, #[debug(skip)] i32),
|
|
SkippedNamed {
|
|
#[debug(skip)]
|
|
field1: i32,
|
|
field2: i32,
|
|
},
|
|
}
|
|
|
|
#[test]
|
|
fn assert() {
|
|
assert_eq!(format!("{:?}", Enum::Unnamed(1, 2)), "Unnamed(1, 2)");
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::Unnamed(1, 2)),
|
|
"Unnamed(\n 1,\n 2,\n)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", Enum::StrUnnamed(1, 2)),
|
|
"StrUnnamed(i32, 2)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::StrUnnamed(1, 2)),
|
|
"StrUnnamed(\n i32,\n 2,\n)",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:?}",
|
|
Enum::StrNamed {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"StrNamed { field1: 1, field2: i32 }",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:#?}",
|
|
Enum::StrNamed {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"StrNamed {\n field1: 1,\n field2: i32,\n}",
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", Enum::InterpolatedUnnamed(1, 2)),
|
|
"InterpolatedUnnamed(1, 1.2)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::InterpolatedUnnamed(1, 2)),
|
|
"InterpolatedUnnamed(\n 1,\n 1.2,\n)",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:?}",
|
|
Enum::InterpolatedNamed {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"InterpolatedNamed { field1: 1.2, field2: 2 }",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:#?}",
|
|
Enum::InterpolatedNamed {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"InterpolatedNamed {\n field1: 1.2,\n field2: 2,\n}",
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", Enum::SkippedUnnamed(1, 2)),
|
|
"SkippedUnnamed(1, ..)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", Enum::SkippedUnnamed(1, 2)),
|
|
"SkippedUnnamed(\n 1,\n ..\n)",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:?}",
|
|
Enum::SkippedNamed {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"SkippedNamed { field2: 2, .. }",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:#?}",
|
|
Enum::SkippedNamed {
|
|
field1: 1,
|
|
field2: 2,
|
|
}
|
|
),
|
|
"SkippedNamed {\n field2: 2,\n ..\n}",
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
mod generic {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
struct NotDebug;
|
|
|
|
trait Bound {}
|
|
|
|
impl Bound for () {}
|
|
|
|
fn display_bound<T: Bound>(_: &T) -> &'static str {
|
|
"()"
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct NamedGenericStruct<T> {
|
|
field: T,
|
|
}
|
|
#[test]
|
|
fn named_generic_struct() {
|
|
assert_eq!(
|
|
format!("{:?}", NamedGenericStruct { field: 1 }),
|
|
"NamedGenericStruct { field: 1 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", NamedGenericStruct { field: 1 }),
|
|
"NamedGenericStruct {\n field: 1,\n}",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct InterpolatedNamedGenericStruct<T> {
|
|
#[debug("{field}.{}", field)]
|
|
field: T,
|
|
}
|
|
#[test]
|
|
fn interpolated_named_generic_struct() {
|
|
assert_eq!(
|
|
format!("{:?}", InterpolatedNamedGenericStruct { field: 1 }),
|
|
"InterpolatedNamedGenericStruct { field: 1.1 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", InterpolatedNamedGenericStruct { field: 1 }),
|
|
"InterpolatedNamedGenericStruct {\n field: 1.1,\n}",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct InterpolatedNamedGenericStructWidthPrecision<T> {
|
|
#[debug("{field:<>width$.prec$}.{field}")]
|
|
field: T,
|
|
width: usize,
|
|
prec: usize,
|
|
}
|
|
#[test]
|
|
fn interpolated_named_generic_struct_width_precision() {
|
|
assert_eq!(
|
|
format!(
|
|
"{:?}",
|
|
InterpolatedNamedGenericStructWidthPrecision {
|
|
field: 1.2345,
|
|
width: 9,
|
|
prec: 2,
|
|
}
|
|
),
|
|
"InterpolatedNamedGenericStructWidthPrecision { \
|
|
field: <<<<<1.23.1.2345, \
|
|
width: 9, \
|
|
prec: 2 \
|
|
}",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:#?}",
|
|
InterpolatedNamedGenericStructWidthPrecision {
|
|
field: 1.2345,
|
|
width: 9,
|
|
prec: 2,
|
|
}
|
|
),
|
|
"InterpolatedNamedGenericStructWidthPrecision {\n \
|
|
field: <<<<<1.23.1.2345,\n \
|
|
width: 9,\n \
|
|
prec: 2,\n\
|
|
}",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct AliasedNamedGenericStruct<T> {
|
|
#[debug("{alias}", alias = field)]
|
|
field: T,
|
|
}
|
|
#[test]
|
|
fn aliased_named_generic_struct() {
|
|
assert_eq!(
|
|
format!("{:?}", AliasedNamedGenericStruct { field: 1 }),
|
|
"AliasedNamedGenericStruct { field: 1 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", AliasedNamedGenericStruct { field: 1 }),
|
|
"AliasedNamedGenericStruct {\n field: 1,\n}",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct AliasedFieldNamedGenericStruct<T> {
|
|
#[debug("{field1}", field1 = field2)]
|
|
field1: T,
|
|
field2: i32,
|
|
}
|
|
#[test]
|
|
fn aliased_field_named_generic_struct() {
|
|
assert_eq!(
|
|
format!(
|
|
"{:?}",
|
|
AliasedFieldNamedGenericStruct {
|
|
field1: NotDebug,
|
|
field2: 1,
|
|
},
|
|
),
|
|
"AliasedFieldNamedGenericStruct { field1: 1, field2: 1 }",
|
|
);
|
|
assert_eq!(
|
|
format!(
|
|
"{:#?}",
|
|
AliasedFieldNamedGenericStruct {
|
|
field1: NotDebug,
|
|
field2: 1,
|
|
},
|
|
),
|
|
"AliasedFieldNamedGenericStruct {\n field1: 1,\n field2: 1,\n}",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct UnnamedGenericStruct<T>(T);
|
|
#[test]
|
|
fn unnamed_generic_struct() {
|
|
assert_eq!(
|
|
format!("{:?}", UnnamedGenericStruct(2)),
|
|
"UnnamedGenericStruct(2)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", UnnamedGenericStruct(2)),
|
|
"UnnamedGenericStruct(\n 2,\n)",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct InterpolatedUnnamedGenericStruct<T>(#[debug("{}.{_0}", _0)] T);
|
|
#[test]
|
|
fn interpolated_unnamed_generic_struct() {
|
|
assert_eq!(
|
|
format!("{:?}", InterpolatedUnnamedGenericStruct(2)),
|
|
"InterpolatedUnnamedGenericStruct(2.2)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", InterpolatedUnnamedGenericStruct(2)),
|
|
"InterpolatedUnnamedGenericStruct(\n 2.2,\n)",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct AliasedUnnamedGenericStruct<T>(#[debug("{alias}", alias = _0)] T);
|
|
#[test]
|
|
fn aliased_unnamed_generic_struct() {
|
|
assert_eq!(
|
|
format!("{:?}", AliasedUnnamedGenericStruct(2)),
|
|
"AliasedUnnamedGenericStruct(2)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", AliasedUnnamedGenericStruct(2)),
|
|
"AliasedUnnamedGenericStruct(\n 2,\n)",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct AliasedFieldUnnamedGenericStruct<T>(#[debug("{_0}", _0 = _1)] T, i32);
|
|
#[test]
|
|
fn aliased_field_unnamed_generic_struct() {
|
|
assert_eq!(
|
|
format!("{:?}", AliasedFieldUnnamedGenericStruct(NotDebug, 2)),
|
|
"AliasedFieldUnnamedGenericStruct(2, 2)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", AliasedFieldUnnamedGenericStruct(NotDebug, 2)),
|
|
"AliasedFieldUnnamedGenericStruct(\n 2,\n 2,\n)",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
enum GenericEnum<A, B> {
|
|
A { field: A },
|
|
B(B),
|
|
}
|
|
#[test]
|
|
fn generic_enum() {
|
|
assert_eq!(
|
|
format!("{:?}", GenericEnum::A::<_, u8> { field: 1 }),
|
|
"A { field: 1 }"
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", GenericEnum::A::<_, u8> { field: 1 }),
|
|
"A {\n field: 1,\n}"
|
|
);
|
|
assert_eq!(format!("{:?}", GenericEnum::B::<u8, _>(2)), "B(2)");
|
|
assert_eq!(
|
|
format!("{:#?}", GenericEnum::B::<u8, _>(2)),
|
|
"B(\n 2,\n)",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
enum InterpolatedGenericEnum<A, B> {
|
|
A {
|
|
#[debug("{}.{field}", field)]
|
|
field: A,
|
|
},
|
|
B(#[debug("{}.{_0}", _0)] B),
|
|
}
|
|
#[test]
|
|
fn interpolated_generic_enum() {
|
|
assert_eq!(
|
|
format!("{:?}", InterpolatedGenericEnum::A::<_, u8> { field: 1 }),
|
|
"A { field: 1.1 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", InterpolatedGenericEnum::A::<_, u8> { field: 1 }),
|
|
"A {\n field: 1.1,\n}",
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", InterpolatedGenericEnum::B::<u8, _>(2)),
|
|
"B(2.2)",
|
|
);
|
|
assert_eq!(
|
|
format!("{:#?}", InterpolatedGenericEnum::B::<u8, _>(2)),
|
|
"B(\n 2.2,\n)",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct MultiTraitNamedGenericStruct<A, B> {
|
|
#[debug("{}.{}<->{0:o}.{1:#x}<->{0:?}.{1:X?}", a, b)]
|
|
a: A,
|
|
b: B,
|
|
}
|
|
#[test]
|
|
fn multi_trait_named_generic_struct() {
|
|
let s = MultiTraitNamedGenericStruct { a: 8u8, b: 255 };
|
|
assert_eq!(
|
|
format!("{s:?}"),
|
|
"MultiTraitNamedGenericStruct { a: 8.255<->10.0xff<->8.FF, b: 255 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{s:#?}"),
|
|
"MultiTraitNamedGenericStruct {\n a: 8.255<->10.0xff<->8.FF,\n b: 255,\n}",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct MultiTraitUnnamedGenericStruct<A, B>(
|
|
#[debug("{}.{}.{{}}.{0:o}.{1:#x}-{0:>4?}.{1:^4X?}", _0, _1)] A,
|
|
B,
|
|
);
|
|
#[test]
|
|
fn multi_trait_unnamed_generic_struct() {
|
|
let s = MultiTraitUnnamedGenericStruct(8u8, 255);
|
|
assert_eq!(
|
|
format!("{s:?}"),
|
|
"MultiTraitUnnamedGenericStruct(8.255.{}.10.0xff- 8. FF , 255)",
|
|
);
|
|
assert_eq!(
|
|
format!("{s:#?}"),
|
|
"MultiTraitUnnamedGenericStruct(\n 8.255.{}.10.0xff- 8. FF ,\n 255,\n)",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct UnusedGenericStruct<T>(#[debug("{}", 3 * 4)] T);
|
|
#[test]
|
|
fn unused_generic_struct() {
|
|
let s = UnusedGenericStruct(NotDebug);
|
|
assert_eq!(format!("{s:?}"), "UnusedGenericStruct(12)");
|
|
assert_eq!(format!("{s:#?}"), "UnusedGenericStruct(\n 12,\n)");
|
|
}
|
|
|
|
mod associated_type_field_enumerator {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
trait Trait {
|
|
type Type;
|
|
}
|
|
|
|
struct Struct;
|
|
|
|
impl Trait for Struct {
|
|
type Type = i32;
|
|
}
|
|
|
|
#[test]
|
|
fn auto_generic_named_struct_associated() {
|
|
#[derive(Debug)]
|
|
struct AutoGenericNamedStructAssociated<T: Trait> {
|
|
field: <T as Trait>::Type,
|
|
}
|
|
|
|
let s = AutoGenericNamedStructAssociated::<Struct> { field: 10 };
|
|
assert_eq!(
|
|
format!("{s:?}"),
|
|
"AutoGenericNamedStructAssociated { field: 10 }",
|
|
);
|
|
assert_eq!(
|
|
format!("{s:#?}"),
|
|
"AutoGenericNamedStructAssociated {\n field: 10,\n}",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn auto_generic_unnamed_struct_associated() {
|
|
#[derive(Debug)]
|
|
struct AutoGenericUnnamedStructAssociated<T: Trait>(<T as Trait>::Type);
|
|
|
|
let s = AutoGenericUnnamedStructAssociated::<Struct>(10);
|
|
assert_eq!(format!("{s:?}"), "AutoGenericUnnamedStructAssociated(10)",);
|
|
assert_eq!(
|
|
format!("{s:#?}"),
|
|
"AutoGenericUnnamedStructAssociated(\n 10,\n)",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn auto_generic_enum_associated() {
|
|
#[derive(Debug)]
|
|
enum AutoGenericEnumAssociated<T: Trait> {
|
|
Enumerator(<T as Trait>::Type),
|
|
}
|
|
|
|
let e = AutoGenericEnumAssociated::<Struct>::Enumerator(10);
|
|
assert_eq!(format!("{:?}", e), "Enumerator(10)");
|
|
assert_eq!(format!("{:#?}", e), "Enumerator(\n 10,\n)");
|
|
}
|
|
}
|
|
|
|
mod complex_type_field_enumerator {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Struct<T>(T);
|
|
|
|
#[test]
|
|
fn auto_generic_named_struct_complex() {
|
|
#[derive(Debug)]
|
|
struct AutoGenericNamedStructComplex<T> {
|
|
field: Struct<T>,
|
|
}
|
|
|
|
let s = AutoGenericNamedStructComplex { field: Struct(10) };
|
|
assert_eq!(
|
|
format!("{s:?}"),
|
|
"AutoGenericNamedStructComplex { field: Struct(10) }",
|
|
);
|
|
assert_eq!(
|
|
format!("{s:#?}"),
|
|
"AutoGenericNamedStructComplex {\n field: Struct(\n 10,\n ),\n}",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn auto_generic_unnamed_struct_complex() {
|
|
#[derive(Debug)]
|
|
struct AutoGenericUnnamedStructComplex<T>(Struct<T>);
|
|
|
|
let s = AutoGenericUnnamedStructComplex(Struct(10));
|
|
assert_eq!(
|
|
format!("{s:?}"),
|
|
"AutoGenericUnnamedStructComplex(Struct(10))",
|
|
);
|
|
assert_eq!(
|
|
format!("{s:#?}"),
|
|
"AutoGenericUnnamedStructComplex(\n Struct(\n 10,\n ),\n)",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn auto_generic_enum_complex() {
|
|
#[derive(Debug)]
|
|
enum AutoGenericEnumComplex<T> {
|
|
Enumerator(Struct<T>),
|
|
}
|
|
|
|
let e = AutoGenericEnumComplex::Enumerator(Struct(10));
|
|
assert_eq!(format!("{:?}", e), "Enumerator(Struct(10))");
|
|
assert_eq!(
|
|
format!("{:#?}", e),
|
|
"Enumerator(\n Struct(\n 10,\n ),\n)",
|
|
)
|
|
}
|
|
}
|
|
|
|
mod reference {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[test]
|
|
fn auto_generic_reference() {
|
|
#[derive(Debug)]
|
|
struct AutoGenericReference<'a, T>(&'a T);
|
|
|
|
let s = AutoGenericReference(&10);
|
|
assert_eq!(format!("{s:?}"), "AutoGenericReference(10)");
|
|
assert_eq!(format!("{s:#?}"), "AutoGenericReference(\n 10,\n)");
|
|
}
|
|
|
|
#[test]
|
|
fn auto_generic_static_reference() {
|
|
#[derive(Debug)]
|
|
struct AutoGenericStaticReference<T: 'static>(&'static T);
|
|
|
|
let s = AutoGenericStaticReference(&10);
|
|
assert_eq!(format!("{s:?}"), "AutoGenericStaticReference(10)");
|
|
assert_eq!(format!("{s:#?}"), "AutoGenericStaticReference(\n 10,\n)",);
|
|
}
|
|
}
|
|
|
|
mod indirect {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[derive(Debug)]
|
|
struct Struct<T>(T);
|
|
|
|
#[test]
|
|
fn auto_generic_indirect() {
|
|
#[derive(Debug)]
|
|
struct AutoGenericIndirect<T: 'static>(Struct<&'static T>);
|
|
|
|
const V: i32 = 10;
|
|
let s = AutoGenericIndirect(Struct(&V));
|
|
assert_eq!(format!("{s:?}"), "AutoGenericIndirect(Struct(10))");
|
|
assert_eq!(
|
|
format!("{s:#?}"),
|
|
"AutoGenericIndirect(\n Struct(\n 10,\n ),\n)",
|
|
);
|
|
}
|
|
}
|
|
|
|
mod bound {
|
|
#[cfg(not(feature = "std"))]
|
|
use alloc::format;
|
|
|
|
use derive_more::Debug;
|
|
|
|
#[test]
|
|
fn simple() {
|
|
#[derive(Debug)]
|
|
struct Struct<T1, T2>(#[debug("{}.{}", _0, _1)] T1, #[debug(skip)] T2);
|
|
|
|
let s = Struct(10, 20);
|
|
assert_eq!(format!("{s:?}"), "Struct(10.20, ..)");
|
|
assert_eq!(format!("{s:#?}"), "Struct(\n 10.20,\n ..\n)");
|
|
}
|
|
|
|
#[test]
|
|
fn underscored_simple() {
|
|
#[derive(Debug)]
|
|
struct Struct<T1, T2>(#[debug("{_0}.{_1}")] T1, #[debug(skip)] T2);
|
|
|
|
let s = Struct(10, 20);
|
|
assert_eq!(format!("{s:?}"), "Struct(10.20, ..)");
|
|
assert_eq!(format!("{s:#?}"), "Struct(\n 10.20,\n ..\n)");
|
|
}
|
|
|
|
#[test]
|
|
fn redundant() {
|
|
#[derive(Debug)]
|
|
#[debug(bound(T1: ::core::fmt::Display, T2: ::core::fmt::Display))]
|
|
struct Struct<T1, T2>(#[debug("{}.{}", _0, _1)] T1, #[debug(skip)] T2);
|
|
|
|
let s = Struct(10, 20);
|
|
assert_eq!(format!("{s:?}"), "Struct(10.20, ..)");
|
|
assert_eq!(format!("{s:#?}"), "Struct(\n 10.20,\n ..\n)");
|
|
}
|
|
|
|
#[test]
|
|
fn underscored_redundant() {
|
|
#[derive(Debug)]
|
|
#[debug(bound(T1: ::core::fmt::Display, T2: ::core::fmt::Display))]
|
|
struct Struct<T1, T2>(#[debug("{_0}.{_1}")] T1, #[debug(ignore)] T2);
|
|
|
|
let s = Struct(10, 20);
|
|
assert_eq!(format!("{s:?}"), "Struct(10.20, ..)");
|
|
assert_eq!(format!("{s:#?}"), "Struct(\n 10.20,\n ..\n)");
|
|
}
|
|
|
|
#[test]
|
|
fn complex() {
|
|
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"
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[debug(bound(T1: Trait1 + Trait2, T2: Trait1 + Trait2))]
|
|
struct Struct<T1, T2>(
|
|
#[debug("{}_{}_{}_{}", _0.function1(), _0, _1.function2(), _1)] T1,
|
|
T2,
|
|
);
|
|
|
|
let s = Struct(10, 20);
|
|
assert_eq!(format!("{s:?}"), "Struct(WHAT_10_EVER_20, 20)");
|
|
assert_eq!(
|
|
format!("{s:#?}"),
|
|
"Struct(\n WHAT_10_EVER_20,\n 20,\n)",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn underscored_complex() {
|
|
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"
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
#[debug(bound(T1: Trait1 + Trait2, T2: Trait1 + Trait2))]
|
|
struct Struct<T1, T2>(
|
|
#[debug("{}_{_0}_{}_{_1}", _0.function1(), _1.function2())] T1,
|
|
T2,
|
|
);
|
|
|
|
let s = Struct(10, 20);
|
|
assert_eq!(format!("{s:?}"), "Struct(WHAT_10_EVER_20, 20)");
|
|
assert_eq!(
|
|
format!("{s:#?}"),
|
|
"Struct(\n WHAT_10_EVER_20,\n 20,\n)",
|
|
);
|
|
}
|
|
}
|
|
}
|