278 lines
7.1 KiB
Rust
278 lines
7.1 KiB
Rust
#![cfg_attr(not(feature = "std"), no_std)]
|
|
|
|
use derive_more::{
|
|
Add, AddAssign, Binary, BitAnd, BitOr, BitXor, Constructor, Deref, DerefMut,
|
|
Display, Div, From, FromStr, Index, IndexMut, Into, IntoIterator, Mul, MulAssign,
|
|
Neg, Not, Octal, Product, Rem, Shl, Shr, Sub, Sum,
|
|
};
|
|
|
|
#[derive(From)]
|
|
#[derive(Into)]
|
|
#[derive(Constructor)]
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
#[derive(Add)]
|
|
#[derive(Mul)]
|
|
#[derive(Neg)]
|
|
#[derive(AddAssign)]
|
|
#[derive(MulAssign)]
|
|
#[derive(FromStr)]
|
|
#[derive(Display)]
|
|
#[derive(Octal)]
|
|
#[derive(Binary)]
|
|
#[derive(Deref, DerefMut)]
|
|
#[into(owned, ref, ref_mut)]
|
|
struct MyInt(i32);
|
|
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
#[derive(Add)]
|
|
#[derive(Sum)]
|
|
#[derive(Mul)]
|
|
#[derive(MulAssign)]
|
|
#[derive(Product)]
|
|
#[mul(forward)]
|
|
#[mul_assign(forward)]
|
|
struct MyInt2(i32);
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(Index, IndexMut)]
|
|
#[derive(Deref, DerefMut)]
|
|
#[derive(IntoIterator)]
|
|
#[deref(forward)]
|
|
#[deref_mut(forward)]
|
|
#[into_iterator(owned, ref, ref_mut)]
|
|
struct MyVec(Vec<i32>);
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(Deref, DerefMut)]
|
|
#[deref(forward)]
|
|
#[deref_mut(forward)]
|
|
struct MyBoxedInt(Box<i32>);
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(Not)]
|
|
#[derive(From)]
|
|
struct MyBool(bool);
|
|
|
|
#[derive(From)]
|
|
#[derive(Into)]
|
|
#[derive(Constructor)]
|
|
#[derive(Add)]
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(Mul)]
|
|
#[derive(AddAssign)]
|
|
struct MyUInt(u64, u64);
|
|
|
|
#[derive(From)]
|
|
#[derive(Into)]
|
|
#[derive(Constructor)]
|
|
#[derive(FromStr)]
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(Display)]
|
|
struct SimpleStruct {
|
|
int1: u64,
|
|
}
|
|
|
|
#[derive(From)]
|
|
#[derive(Constructor)]
|
|
#[derive(Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shr, Shl)]
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
#[derive(Into)]
|
|
#[derive(AddAssign)]
|
|
#[into(owned, ref, ref_mut)]
|
|
struct NormalStruct {
|
|
int1: u64,
|
|
int2: u64,
|
|
}
|
|
|
|
#[derive(From)]
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
struct NestedInt(MyInt);
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(From)]
|
|
#[derive(Add, Sub)]
|
|
enum SimpleMyIntEnum {
|
|
Int(i32),
|
|
#[from(ignore)]
|
|
_UnsignedOne(u32),
|
|
_UnsignedTwo(u32),
|
|
}
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(From)]
|
|
#[derive(Neg)]
|
|
enum SimpleSignedIntEnum {
|
|
Int(i32),
|
|
Int2(i16),
|
|
}
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(From)]
|
|
#[derive(Add, Sub)]
|
|
#[derive(Neg)]
|
|
enum SimpleEnum {
|
|
Int(i32),
|
|
#[from(ignore)]
|
|
_Ints(i32, i32),
|
|
LabeledInts {
|
|
a: i32,
|
|
b: i32,
|
|
},
|
|
_SomeUnit,
|
|
}
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(From)]
|
|
#[derive(Add, Sub)]
|
|
enum MyIntEnum {
|
|
SmallInt(i32),
|
|
BigInt(i64),
|
|
TwoInts(i32, i32),
|
|
Point2D {
|
|
x: i64,
|
|
y: i64,
|
|
},
|
|
#[from(ignore)]
|
|
_UnsignedOne(u32),
|
|
_UnsignedTwo(u32),
|
|
#[from(ignore)]
|
|
_Uints1(u64, u64),
|
|
_Uints2 {
|
|
x: u64,
|
|
y: u64,
|
|
},
|
|
}
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(Add, Mul)]
|
|
struct DoubleUInt(u32, u32);
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(Add, Mul)]
|
|
struct DoubleUIntStruct {
|
|
x: u32,
|
|
y: u32,
|
|
}
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
#[derive(From, Into, Constructor)]
|
|
struct Unit;
|
|
|
|
// Tests that we can forward to a path
|
|
// containing `$crate`
|
|
macro_rules! use_dollar_crate {
|
|
() => {
|
|
struct Foo;
|
|
#[derive(From)]
|
|
enum Bar {
|
|
First(#[from(forward)] $crate::Foo),
|
|
}
|
|
};
|
|
}
|
|
|
|
use_dollar_crate!();
|
|
|
|
#[test]
|
|
fn main() {
|
|
let mut myint: MyInt = 5.into();
|
|
let _: SimpleMyIntEnum = 5i32.into();
|
|
let _: MyIntEnum = 5i32.into();
|
|
let _: MyIntEnum = 6i64.into();
|
|
let _: MyIntEnum = (5i32, 8i32).into();
|
|
let _: MyIntEnum = (5i64, 8i64).into();
|
|
|
|
let int_ref: &i32 = (&myint).into();
|
|
assert_eq!(int_ref, &5);
|
|
|
|
let int_ref_mut: &mut i32 = (&mut myint).into();
|
|
assert_eq!(int_ref_mut, &mut 5);
|
|
|
|
let mut myint: MyInt = 5.into();
|
|
let _: Unit = ().into();
|
|
assert_eq!((), Unit.into());
|
|
assert_eq!(Unit, Unit::new());
|
|
assert_eq!(MyInt(5), 5.into());
|
|
assert_eq!(Ok(MyInt(5)), "5".parse());
|
|
assert_eq!(5, MyInt(5).into());
|
|
assert_eq!(MyInt(5), MyInt::new(5));
|
|
assert_eq!(-MyInt(5), (-5).into());
|
|
assert_eq!("30", MyInt(30).to_string());
|
|
assert_eq!("36", format!("{:o}", MyInt(30)));
|
|
assert_eq!("100", format!("{:b}", MyInt(4)));
|
|
assert_eq!(!MyBool(true), false.into());
|
|
assert_eq!(MyIntEnum::SmallInt(5), 5.into());
|
|
|
|
assert_eq!(SimpleStruct { int1: 5 }, 5.into());
|
|
assert_eq!(5u64, SimpleStruct { int1: 5 }.into());
|
|
assert_eq!(Ok(SimpleStruct { int1: 5 }), "5".parse());
|
|
assert_eq!("5", SimpleStruct { int1: 5 }.to_string());
|
|
assert_eq!(NormalStruct { int1: 5, int2: 6 }, (5, 6).into());
|
|
assert_eq!(SimpleStruct { int1: 5 }, SimpleStruct::new(5));
|
|
assert_eq!(NormalStruct { int1: 5, int2: 6 }, NormalStruct::new(5, 6));
|
|
assert_eq!((5, 6), NormalStruct::new(5, 6).into());
|
|
let mut norm_struct = NormalStruct::new(5, 6);
|
|
let uints_ref: (&u64, &u64) = (&norm_struct).into();
|
|
assert_eq!((&5, &6), uints_ref);
|
|
let uints_ref_mut: (&mut u64, &mut u64) = (&mut norm_struct).into();
|
|
assert_eq!((&mut 5, &mut 6), uints_ref_mut);
|
|
|
|
assert_eq!(MyInt(4) + MyInt(1), 5.into());
|
|
myint += MyInt(3);
|
|
assert_eq!(myint, 8.into());
|
|
myint *= 5;
|
|
assert_eq!(myint, 40.into());
|
|
assert_eq!(MyInt(4) + MyInt(1), 5.into());
|
|
assert_eq!(MyUInt(4, 5) + MyUInt(1, 2), MyUInt(5, 7));
|
|
assert_eq!(MyUInt(4, 5), MyUInt::new(4, 5));
|
|
assert_eq!((4, 5), MyUInt(4, 5).into());
|
|
let mut s1 = NormalStruct { int1: 1, int2: 2 };
|
|
let s2 = NormalStruct { int1: 2, int2: 3 };
|
|
let s3 = NormalStruct { int1: 3, int2: 5 };
|
|
assert_eq!(s1 + s2, s3);
|
|
assert_eq!(s3 - s2, s1);
|
|
s1 += s2;
|
|
assert_eq!(s1, s3);
|
|
|
|
assert_eq!((SimpleMyIntEnum::Int(6) + 5.into()).unwrap(), 11.into());
|
|
assert_eq!((SimpleMyIntEnum::Int(6) - 5.into()).unwrap(), 1.into());
|
|
assert_eq!((SimpleMyIntEnum::Int(6) - 5.into()).unwrap(), 1.into());
|
|
assert_eq!(-SimpleSignedIntEnum::Int(6), (-6i32).into());
|
|
assert_eq!(
|
|
(SimpleEnum::LabeledInts { a: 6, b: 5 }
|
|
+ SimpleEnum::LabeledInts { a: 1, b: 4 })
|
|
.unwrap(),
|
|
SimpleEnum::LabeledInts { a: 7, b: 9 }
|
|
);
|
|
|
|
let _ = (MyIntEnum::SmallInt(5) + 6.into()).unwrap();
|
|
assert_eq!((-SimpleEnum::Int(5)).unwrap(), (-5).into());
|
|
|
|
assert_eq!(MyInt(50), MyInt(5) * 10);
|
|
assert_eq!(DoubleUInt(5, 6) * 10, DoubleUInt(50, 60));
|
|
// assert_eq!(DoubleUIntStruct{x:5, y:6} * 10, DoubleUIntStruct{x:50, y:60});
|
|
|
|
let mut myint = MyInt(5);
|
|
assert_eq!(5, *myint);
|
|
*myint = 7;
|
|
assert_eq!(MyInt(7), myint);
|
|
|
|
let mut my_vec = MyVec(vec![5, 8]);
|
|
assert_eq!(5, my_vec[0]);
|
|
assert_eq!(8, my_vec[1]);
|
|
my_vec[0] = 20;
|
|
assert_eq!(20, my_vec[0]);
|
|
assert_eq!((&my_vec).into_iter().next(), Some(&20));
|
|
assert_eq!((&mut my_vec).into_iter().next(), Some(&mut 20));
|
|
assert_eq!(my_vec.into_iter().next(), Some(20));
|
|
|
|
let int_vec = vec![MyInt2(2), MyInt2(3)];
|
|
assert_eq!(MyInt2(5), int_vec.clone().into_iter().sum());
|
|
assert_eq!(MyInt2(6), int_vec.clone().into_iter().product());
|
|
let mut myint2 = MyInt2(8);
|
|
myint2 *= MyInt2(4);
|
|
assert_eq!(MyInt2(32), myint2);
|
|
|
|
let mut boxed = MyBoxedInt(Box::new(5));
|
|
assert_eq!(5, *boxed);
|
|
*boxed = 7;
|
|
assert_eq!(MyBoxedInt(Box::new(7)), boxed)
|
|
}
|