#[cfg(test)]
mod tests {
    use fts_units::ops::*;
    use fts_units::quantity::*;
    use fts_units::si_system::quantities::*;
    use fts_units::si_system::*;
    use typenum::consts::*;

    macro_rules! convert_into_eq {
        ($x:expr, $y:ty, $z:expr) => {
            let temp: $y = $x.convert_into();
            assert_eq!(temp.amount(), $z);
        };
    }

    #[test]
    fn length_new() {
        assert_eq!(Kilometers::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Meters::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Centimeters::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Millimeters::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Micrometers::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Nanometers::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Picometers::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Femtometers::<f32>::new(5.0).amount(), 5.0);
    }

    #[test]
    fn mass_new() {
        assert_eq!(Kilograms::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Grams::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Centigrams::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Milligrams::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Micrograms::<f32>::new(5.0).amount(), 5.0);
        assert_eq!(Nanograms::<f32>::new(5.0).amount(), 5.0);
    }

    #[test]
    fn basic_add() {
        let m1 = Meters::<f32>::new(6.0);
        let m2 = Meters::<f32>::new(8.5);
        assert_eq!(Meters::<f32>::new(14.5), m1 + m2);

        let m3 = Meters::<f32>::new(-2.4);
        assert_eq!(Meters::<f32>::new(6.1), m2 + m3);
    }

    #[test]
    fn basic_sub() {
        let m1 = Meters::<f32>::new(6.0);
        let m2 = Meters::<f32>::new(8.5);
        assert_eq!(Meters::<f32>::new(-2.5), m1 - m2);

        let m3 = Meters::<f32>::new(-2.4);
        assert_eq!(Meters::<f32>::new(10.9), m2 - m3);
    }

    #[test]
    fn basic_mul() {
        let _l1 = Meters::<f32>::new(3.0);
        let _l2 = Meters::<f32>::new(5.0);

        //type MetersSquared = QuantityT<f32, SIUnitsT<LengthRatiosT<Unit>, AddOutput<LengthExponentsT, LengthExponentsT>>>;
        //let a : MetersSquared = l1 * l2;
        //let a /*: impl Area*/ = l1 * l2;
        //assert_eq!(MetersSquared::new(15.0), a);

        //assert_eq!(l1 * l2, QuantityT::<f32, SquaredUnits<MetersUnits>>::new(15.0));
        //assert_eq!(l1 * l2, AreaT::<f32, Unit>::new(15.0));
    }

    #[test]
    fn basic_cast() {
        let _f32 = Meters::<f32>::new(42.5);
        let _i8: Meters<i8> = _f32.cast_into();
        let _i16: Meters<i16> = _f32.cast_into();
        let _i32: Meters<i32> = _f32.cast_into();
        let _i64: Meters<i64> = _f32.cast_into();
        let _i128: Meters<i128> = _f32.cast_into();

        assert_eq!(_i8.amount(), 42);
        assert_eq!(_i16.amount(), 42);
        assert_eq!(_i32.amount(), 42);
        assert_eq!(_i64.amount(), 42);
        assert_eq!(_i128.amount(), 42);
    }

    #[test]
    fn cast_truncate() {
        let m = Meters::<f32>::new(7.73);
        let i: Meters<i32> = m.cast_into();
        assert_eq!(i.amount(), 7);
    }

    #[test]
    fn convert_syntax() {
        let m = Meters::<f32>::new(7.73);
        let km: Kilometers<f32> = m.convert_into();
        assert_eq!(km.amount(), 0.00773);
    }

    #[test]
    fn length_convert() {
        let m = Meters::<f32>::new(7.73);
        convert_into_eq!(&m, Kilometers<f32>, 0.00773);
        convert_into_eq!(&m, Centimeters<f32>, 773.0);
        convert_into_eq!(&m, Millimeters<f32>, 7730.0);
        convert_into_eq!(&m, Micrometers<f32>, 7730000.0);
        convert_into_eq!(&m, Nanometers<f32>, 7730000000.0);
        convert_into_eq!(&m, Picometers<f32>, 7730000000000.0);
        convert_into_eq!(&m, Femtometers<f32>, 7730000000000000.0);
    }

    #[test]
    fn velocity_calc() {
        let d = Meters::<f32>::new(12.0);
        let t = Seconds::<f32>::new(8.0);
        let v = d / t;
        assert_eq!(v, MetersPerSecond::<f32>::new(1.5));
    }

    fn verify_velocity<T>(_value: T)
    where
        T: traits::Velocity,
    {
    }

    #[test]
    fn si_traits() {
        //let _ : Box<dyn traits::Velocity> = Box::new(7.0);
        let v = MetersPerSecond::<f32>::new(1.5);
        verify_velocity(v);
    }

    #[test]
    fn velocity_convert() {
        convert_into_eq!(
            &MetersPerSecond::<f32>::new(100.0),
            KilometersPerHour<f32>,
            360.0
        );
        convert_into_eq!(&Velocity::<f32, Milli, Second>::new(100.0), Velocity<f32, Kilo, Minute>, 0.006);
    }

    #[test]
    fn dimensionless() {
        let l = Meters::<f32>::new(12.0);
        let d = Dimensionless::<f32>::new(5.0);

        assert_eq!(l * d, Meters::<f32>::new(60.0));
        assert_eq!(l / d, Meters::<f32>::new(2.4));
    }

    #[test]
    fn invert() {
        let mps = MetersPerSecond::<f32>::new(5.0);
        let spm: QuantityT<_, SIUnitsT<_, SIExponentsT<N1, Z0, P1>>> = mps.invert();
        assert_eq!(spm.amount(), 0.2);
        assert_eq!(mps, spm.invert());
    }

    #[test]
    fn sqrt_simple() {
        let d = Meters::<f32>::new(7.0);
        let d2: QuantityT<_, SIUnitsT<_, SIExponentsT<P2, Z0, Z0>>> = d * d;
        assert_eq!(d2.amount(), 49.0);
        let d1: QuantityT<_, SIUnitsT<_, SIExponentsT<P1, Z0, Z0>>> = d2.sqrt();
        assert_eq!(d, d1);

        let s = Seconds::<f32>::new(4.0);
        let s4: QuantityT<_, SIUnitsT<_, SIExponentsT<Z0, Z0, P4>>> = s * s * s * s;
        let d2s4 = d2 * s4;
        let d1s2: QuantityT<_, SIUnitsT<_, SIExponentsT<P1, Z0, P2>>> = d2s4.sqrt();
        assert_eq!(d1s2.amount(), (7.0f32.powi(2) * 4.0f32.powi(4)).sqrt());
    }

    #[test]
    fn sqrt_inv() {
        let d = Meters::<f32>::new(4.0);
        let d2 = d * d;
        let di = d.invert();
        let di2 = di * di;

        assert_eq!(di, di2.sqrt());
        assert_eq!(d, di2.sqrt().invert());
        assert_eq!(d2, (di * di).invert());
    }

    #[test]
    fn reduce() {
        let m = Meters::<f32>::new(7.0);
        let s = Seconds::<f32>::new(0.8);
        let mps = m / s;
        let mps2 = mps / s;
        let s = Seconds::<f32>::new(1.5);
        let m: Meters<f32> = mps2 * s * s;
        let mph: QuantityT<f32, SIUnitsT<SIRatiosT<Unit, Zero, Hour>, SIExponentsT<P1, Z0, N1>>> =
            m / Hours::<f32>::new(0.5);
        assert_eq!(mph.amount(), 49.21875);
    }

    #[test]
    fn format() {
        assert_eq!(
            format!("{}", MetersPerSecond2::<f32>::new(9.8)),
            "9.8 m·s⁻²".to_string()
        );
        assert_eq!(
            format!("{}", KilometersPerHour::<f32>::new(65.5)),
            "65.5 km·h⁻¹".to_string()
        );
    }

    #[test]
    fn easy_from() {
        assert_eq!(Meters::<f32>::from(2.3).amount(), 2.3);
        assert_eq!(Kilometers::<f64>::new(42.4), 42.4.into());
    }

    #[test]
    fn size_check() {
        use std::mem::size_of;
        assert_eq!(size_of::<Meters::<u8>>(), size_of::<u8>());
        assert_eq!(size_of::<Meters::<u16>>(), size_of::<u16>());
        assert_eq!(size_of::<Meters::<u32>>(), size_of::<u32>());
        assert_eq!(size_of::<Meters::<u64>>(), size_of::<u64>());
        assert_eq!(size_of::<Meters::<u128>>(), size_of::<u128>());

        assert_eq!(size_of::<Meters::<i8>>(), size_of::<i8>());
        assert_eq!(size_of::<Meters::<i16>>(), size_of::<i16>());
        assert_eq!(size_of::<Meters::<i32>>(), size_of::<i32>());
        assert_eq!(size_of::<Meters::<i64>>(), size_of::<i64>());
        assert_eq!(size_of::<Meters::<i128>>(), size_of::<i128>());

        assert_eq!(size_of::<Meters::<f32>>(), size_of::<f32>());
        assert_eq!(size_of::<Meters::<f64>>(), size_of::<f64>());

        assert_eq!(size_of::<KilometersPerHour::<f32>>(), size_of::<f32>());
    }

    #[test]
    fn try_build() {
        let t = trybuild::TestCases::new();
        t.compile_fail("tests/compile_fail/*.rs");
    }
}