#![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)",
);
}
}
}
