170 lines
3.3 KiB
Rust
170 lines
3.3 KiB
Rust
use smart_default::SmartDefault;
|
|
|
|
#[test]
|
|
fn test_unit() {
|
|
#[derive(PartialEq, SmartDefault)]
|
|
struct Foo;
|
|
|
|
assert!(Foo::default() == Foo);
|
|
}
|
|
|
|
#[test]
|
|
fn test_tuple() {
|
|
#[derive(PartialEq, SmartDefault)]
|
|
struct Foo(
|
|
#[default = 10] i32,
|
|
#[default = 20] i32,
|
|
// No default
|
|
i32,
|
|
);
|
|
|
|
assert!(Foo::default() == Foo(10, 20, 0));
|
|
}
|
|
|
|
#[test]
|
|
fn test_struct() {
|
|
#[derive(PartialEq, SmartDefault)]
|
|
struct Foo {
|
|
#[default = 10]
|
|
x: i32,
|
|
#[default = 20]
|
|
y: i32,
|
|
// No default
|
|
z: i32,
|
|
}
|
|
|
|
assert!(Foo::default() == Foo { x: 10, y: 20, z: 0 });
|
|
}
|
|
|
|
#[test]
|
|
fn test_enum_of_units() {
|
|
#[derive(PartialEq, SmartDefault)]
|
|
pub enum Foo {
|
|
#[allow(dead_code)]
|
|
Bar,
|
|
#[default]
|
|
Baz,
|
|
#[allow(dead_code)]
|
|
Qux,
|
|
}
|
|
|
|
assert!(Foo::default() == Foo::Baz);
|
|
}
|
|
|
|
#[test]
|
|
fn test_enum_of_tuples() {
|
|
#[derive(PartialEq, SmartDefault)]
|
|
pub enum Foo {
|
|
#[allow(dead_code)]
|
|
Bar(i32),
|
|
#[default]
|
|
Baz(#[default = 10] i32, i32),
|
|
#[allow(dead_code)]
|
|
Qux(i32),
|
|
}
|
|
|
|
assert!(Foo::default() == Foo::Baz(10, 0));
|
|
}
|
|
|
|
#[test]
|
|
fn test_enum_of_structs() {
|
|
#[derive(PartialEq, SmartDefault)]
|
|
pub enum Foo {
|
|
#[allow(dead_code)]
|
|
Bar { x: i32 },
|
|
#[default]
|
|
Baz {
|
|
#[default = 10]
|
|
y: i32,
|
|
z: i32,
|
|
},
|
|
#[allow(dead_code)]
|
|
Qux { w: i32 },
|
|
}
|
|
|
|
assert!(Foo::default() == Foo::Baz { y: 10, z: 0 });
|
|
}
|
|
|
|
#[test]
|
|
fn test_enum_mixed() {
|
|
#[derive(PartialEq, SmartDefault)]
|
|
enum Foo {
|
|
#[allow(dead_code)]
|
|
Bar,
|
|
#[default]
|
|
Baz(#[default = 10] i32),
|
|
#[allow(dead_code)]
|
|
Qux { w: i32 },
|
|
}
|
|
|
|
assert!(Foo::default() == Foo::Baz(10));
|
|
}
|
|
|
|
#[test]
|
|
fn test_generics_type_parameters() {
|
|
#[derive(PartialEq, SmartDefault)]
|
|
struct Foo<T>
|
|
where
|
|
T: Default,
|
|
{
|
|
#[default(Some(Default::default()))]
|
|
x: Option<T>,
|
|
}
|
|
|
|
assert!(Foo::default() == Foo { x: Some(0) });
|
|
}
|
|
|
|
#[test]
|
|
fn test_generics_lifetime_parameters() {
|
|
// NOTE: A default value makes no sense with lifetime parameters, since ::default() receives no
|
|
// paramters and therefore can receive no lifetimes. But it does make sense if you make a variant
|
|
// without ref fields the default.
|
|
|
|
#[derive(PartialEq, SmartDefault)]
|
|
enum Foo<'a> {
|
|
#[default]
|
|
Bar(i32),
|
|
#[allow(dead_code)]
|
|
Baz(&'a str),
|
|
}
|
|
|
|
assert!(Foo::default() == Foo::Bar(0));
|
|
}
|
|
|
|
#[test]
|
|
fn test_code_hack() {
|
|
#[derive(PartialEq, SmartDefault)]
|
|
struct Foo {
|
|
#[default(_code = "vec![1, 2, 3]")]
|
|
v: Vec<u32>,
|
|
}
|
|
|
|
assert!(Foo::default().v == [1, 2, 3]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_string_conversion() {
|
|
#[derive(PartialEq, SmartDefault)]
|
|
struct Foo(#[default = "one"] &'static str, #[default("two")] String);
|
|
|
|
assert!(Foo::default() == Foo("one", "two".to_owned()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_non_code_hack_valid_meta() {
|
|
#[derive(Debug, PartialEq, SmartDefault)]
|
|
struct Foo {
|
|
#[default(true)]
|
|
bar: bool,
|
|
#[default(Option::None)]
|
|
baz: Option<()>,
|
|
}
|
|
|
|
assert_eq!(
|
|
Foo::default(),
|
|
Foo {
|
|
bar: true,
|
|
baz: None
|
|
}
|
|
);
|
|
}
|