#[cfg(test)]
mod tests {
    use ferrix::{FloatRandom, IntRandom, Matrix, RowVector, Vector};

    #[test]
    fn test_default() {
        let matrix = Matrix::<i32, 2, 3>::default();
        assert_eq!(matrix[(0, 0)], 0);
        assert_eq!(matrix[(0, 1)], 0);
        assert_eq!(matrix[(0, 2)], 0);
        assert_eq!(matrix[(1, 0)], 0);
        assert_eq!(matrix[(1, 1)], 0);
        assert_eq!(matrix[(1, 2)], 0);
    }

    #[test]
    fn test_eye() {
        let eye_matrix = Matrix::<i32, 2, 2>::eye();
        assert_eq!(eye_matrix[(0, 0)], 1);
        assert_eq!(eye_matrix[(0, 1)], 0);
        assert_eq!(eye_matrix[(1, 0)], 0);
        assert_eq!(eye_matrix[(1, 1)], 1);
    }

    #[test]
    fn test_zeros() {
        let zeros_matrix = Matrix::<i32, 2, 3>::zeros();
        assert_eq!(zeros_matrix[(0, 0)], 0);
        assert_eq!(zeros_matrix[(0, 1)], 0);
        assert_eq!(zeros_matrix[(0, 2)], 0);
        assert_eq!(zeros_matrix[(1, 0)], 0);
        assert_eq!(zeros_matrix[(1, 1)], 0);
        assert_eq!(zeros_matrix[(1, 2)], 0);
    }

    #[test]
    fn test_ones() {
        let ones_matrix = Matrix::<i32, 3, 2>::ones();
        assert_eq!(ones_matrix[(0, 0)], 1);
        assert_eq!(ones_matrix[(0, 1)], 1);
        assert_eq!(ones_matrix[(1, 0)], 1);
        assert_eq!(ones_matrix[(1, 1)], 1);
        assert_eq!(ones_matrix[(2, 0)], 1);
        assert_eq!(ones_matrix[(2, 1)], 1);
    }

    #[test]
    fn test_new() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        assert_eq!(matrix[(0, 0)], 1);
        assert_eq!(matrix[(0, 1)], 2);
        assert_eq!(matrix[(0, 2)], 3);
        assert_eq!(matrix[(1, 0)], 4);
        assert_eq!(matrix[(1, 1)], 5);
        assert_eq!(matrix[(1, 2)], 6);
    }

    #[test]
    fn test_fill() {
        let matrix = Matrix::<i32, 2, 3>::fill(1);
        assert_eq!(matrix[(0, 0)], 1);
        assert_eq!(matrix[(0, 1)], 1);
        assert_eq!(matrix[(0, 2)], 1);
        assert_eq!(matrix[(1, 0)], 1);
        assert_eq!(matrix[(1, 1)], 1);
        assert_eq!(matrix[(1, 2)], 1);
    }

    #[test]
    fn test_random_float() {
        let matrix = Matrix::<f64, 2, 3>::random();
        assert!(-1.0 <= matrix[(0, 0)] && matrix[(0, 0)] <= 1.0);
        assert!(-1.0 <= matrix[(0, 1)] && matrix[(0, 1)] <= 1.0);
        assert!(-1.0 <= matrix[(0, 2)] && matrix[(0, 2)] <= 1.0);
        assert!(-1.0 <= matrix[(1, 0)] && matrix[(1, 0)] <= 1.0);
        assert!(-1.0 <= matrix[(1, 1)] && matrix[(1, 1)] <= 1.0);
        assert!(-1.0 <= matrix[(1, 2)] && matrix[(1, 2)] <= 1.0);
    }

    #[test]
    fn test_random_int() {
        let matrix = Matrix::<i32, 2, 3>::random();
        assert!(i32::MIN <= matrix[(0, 0)] && matrix[(0, 0)] <= i32::MAX);
        assert!(i32::MIN <= matrix[(0, 1)] && matrix[(0, 1)] <= i32::MAX);
        assert!(i32::MIN <= matrix[(0, 2)] && matrix[(0, 2)] <= i32::MAX);
        assert!(i32::MIN <= matrix[(1, 0)] && matrix[(1, 0)] <= i32::MAX);
        assert!(i32::MIN <= matrix[(1, 1)] && matrix[(1, 1)] <= i32::MAX);
        assert!(i32::MIN <= matrix[(1, 2)] && matrix[(1, 2)] <= i32::MAX);
    }

    #[test]
    fn test_shape() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        assert_eq!(matrix.shape(), (2, 3));
    }

    #[test]
    fn test_t() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let transposed = matrix.t();

        assert_eq!(transposed.shape(), (3, 2));
        assert_eq!(transposed[(0, 0)], 1);
        assert_eq!(transposed[(0, 1)], 4);
        assert_eq!(transposed[(1, 0)], 2);
        assert_eq!(transposed[(1, 1)], 5);
        assert_eq!(transposed[(2, 0)], 3);
        assert_eq!(transposed[(2, 1)], 6);
    }

    #[test]
    fn test_t_mut() {
        let mut matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let mut transposed = matrix.t_mut();

        transposed[(0, 1)] = 10;
        transposed[(2, 0)] = 20;

        assert_eq!(transposed.shape(), (3, 2));
        assert_eq!(matrix[(0, 0)], 1);
        assert_eq!(matrix[(0, 1)], 2);
        assert_eq!(matrix[(0, 2)], 20);
        assert_eq!(matrix[(1, 0)], 10);
        assert_eq!(matrix[(1, 1)], 5);
        assert_eq!(matrix[(1, 2)], 6);
    }

    #[test]
    fn test_view() {
        let matrix = Matrix::from([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]);
        let view = matrix.view::<2, 2>((1, 1)).unwrap();

        assert_eq!(view.shape(), (2, 2));
        assert_eq!(view[(0, 0)], 6);
        assert_eq!(view[(0, 1)], 7);
        assert_eq!(view[(1, 0)], 10);
        assert_eq!(view[(1, 1)], 11);
    }

    #[test]
    fn test_view_out_of_bounds() {
        let matrix = Matrix::from([[1, 2], [3, 4]]);
        assert!(matrix.view::<2, 2>((1, 1)).is_none());
    }

    #[test]
    #[should_panic(expected = "Index out of bounds")]
    fn test_view_index_out_of_bounds() {
        let matrix = Matrix::from([[1, 2, 3], [5, 6, 7], [9, 10, 11]]);
        let view = matrix.view::<2, 2>((1, 1)).unwrap();
        let _ = view[(2, 3)];
    }

    #[test]
    fn test_view_mut() {
        let mut matrix = Matrix::from([[1, 2], [5, 6], [9, 10]]);

        {
            let mut view = matrix.view_mut::<2, 2>((1, 0)).unwrap();
            assert_eq!(view.shape(), (2, 2));
            view[(0, 0)] = 20;
            view[(1, 1)] = 30;
        }

        assert_eq!(matrix[(0, 0)], 1);
        assert_eq!(matrix[(0, 1)], 2);
        assert_eq!(matrix[(1, 0)], 20);
        assert_eq!(matrix[(1, 1)], 6);
        assert_eq!(matrix[(2, 0)], 9);
        assert_eq!(matrix[(2, 1)], 30);
    }

    #[test]
    fn test_view_mut_out_of_bounds() {
        let mut matrix = Matrix::from([[1, 2], [3, 4]]);
        assert!(matrix.view_mut::<2, 2>((1, 1)).is_none());
    }

    #[test]
    #[should_panic(expected = "Index out of bounds")]
    fn test_view_mut_index_out_of_bounds() {
        let matrix = Matrix::from([[1, 2, 3], [5, 6, 7], [9, 10, 11]]);
        let view = matrix.view::<2, 2>((1, 1)).unwrap();
        let _ = view[(2, 3)];
    }

    #[test]
    fn test_rot() {
        use std::f64::consts::PI;
        let rot_matrix = Matrix::<f64, 2, 2>::rot(PI / 2.0);
        let expected = Matrix::from([[0.0, -1.0], [1.0, 0.0]]);
        assert!((rot_matrix[(0, 0)] - expected[(0, 0)]).abs() < f64::EPSILON);
        assert!((rot_matrix[(0, 1)] - expected[(0, 1)]).abs() < f64::EPSILON);
        assert!((rot_matrix[(1, 0)] - expected[(1, 0)]).abs() < f64::EPSILON);
        assert!((rot_matrix[(1, 1)] - expected[(1, 1)]).abs() < f64::EPSILON);
    }

    #[test]
    fn test_rotx() {
        use std::f64::consts::PI;
        let rotx_matrix = Matrix::<f64, 3, 3>::rotx(PI / 2.0);
        let expected = Matrix::from([
            [1.0, 0.0, 0.0],
            [0.0, 0.0, -1.0],
            [0.0, 1.0, 0.0],
        ]);
        assert!((rotx_matrix[(0, 0)] - expected[(0, 0)]).abs() < f64::EPSILON);
        assert!((rotx_matrix[(0, 1)] - expected[(0, 1)]).abs() < f64::EPSILON);
        assert!((rotx_matrix[(0, 2)] - expected[(0, 2)]).abs() < f64::EPSILON);
        assert!((rotx_matrix[(1, 0)] - expected[(1, 0)]).abs() < f64::EPSILON);
        assert!((rotx_matrix[(1, 1)] - expected[(1, 1)]).abs() < f64::EPSILON);
        assert!((rotx_matrix[(1, 2)] - expected[(1, 2)]).abs() < f64::EPSILON);
        assert!((rotx_matrix[(2, 0)] - expected[(2, 0)]).abs() < f64::EPSILON);
        assert!((rotx_matrix[(2, 1)] - expected[(2, 1)]).abs() < f64::EPSILON);
        assert!((rotx_matrix[(2, 2)] - expected[(2, 2)]).abs() < f64::EPSILON);
    }

    #[test]
    fn test_roty() {
        use std::f64::consts::PI;
        let roty_matrix = Matrix::<f64, 3, 3>::roty(PI / 2.0);
        let expected = Matrix::from([
            [0.0, 0.0, 1.0],
            [0.0, 1.0, 0.0],
            [-1.0, 0.0, 0.0],
        ]);
        assert!((roty_matrix[(0, 0)] - expected[(0, 0)]).abs() < f64::EPSILON);
        assert!((roty_matrix[(0, 1)] - expected[(0, 1)]).abs() < f64::EPSILON);
        assert!((roty_matrix[(0, 2)] - expected[(0, 2)]).abs() < f64::EPSILON);
        assert!((roty_matrix[(1, 0)] - expected[(1, 0)]).abs() < f64::EPSILON);
        assert!((roty_matrix[(1, 1)] - expected[(1, 1)]).abs() < f64::EPSILON);
        assert!((roty_matrix[(1, 2)] - expected[(1, 2)]).abs() < f64::EPSILON);
        assert!((roty_matrix[(2, 0)] - expected[(2, 0)]).abs() < f64::EPSILON);
        assert!((roty_matrix[(2, 1)] - expected[(2, 1)]).abs() < f64::EPSILON);
        assert!((roty_matrix[(2, 2)] - expected[(2, 2)]).abs() < f64::EPSILON);
    }

    #[test]
    fn test_rotz() {
        use std::f64::consts::PI;
        let rotz_matrix = Matrix::<f64, 3, 3>::rotz(PI / 2.0);
        let expected = Matrix::from([
            [0.0, -1.0, 0.0],
            [1.0, 0.0, 0.0],
            [0.0, 0.0, 1.0],
        ]);
        assert!((rotz_matrix[(0, 0)] - expected[(0, 0)]).abs() < f64::EPSILON);
        assert!((rotz_matrix[(0, 1)] - expected[(0, 1)]).abs() < f64::EPSILON);
        assert!((rotz_matrix[(0, 2)] - expected[(0, 2)]).abs() < f64::EPSILON);
        assert!((rotz_matrix[(1, 0)] - expected[(1, 0)]).abs() < f64::EPSILON);
        assert!((rotz_matrix[(1, 1)] - expected[(1, 1)]).abs() < f64::EPSILON);
        assert!((rotz_matrix[(1, 2)] - expected[(1, 2)]).abs() < f64::EPSILON);
        assert!((rotz_matrix[(2, 0)] - expected[(2, 0)]).abs() < f64::EPSILON);
        assert!((rotz_matrix[(2, 1)] - expected[(2, 1)]).abs() < f64::EPSILON);
        assert!((rotz_matrix[(2, 2)] - expected[(2, 2)]).abs() < f64::EPSILON);
    }

    #[test]
    fn test_eq() {
        let m1 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let m2 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        assert_eq!(m1, m2);
    }

    #[test]
    fn test_ne() {
        let m1 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let m2 = Matrix::from([[1, 2, 3], [4, 5, 7]]);
        assert_ne!(m1, m2);
    }

    #[test]
    fn test_eq_view() {
        let m1 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let m2 = Matrix::from([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
        let view2 = m2.view::<2, 3>((0, 0)).unwrap();
        assert_eq!(m1, view2);
    }

    #[test]
    fn test_ne_view() {
        let m1 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let m2 = Matrix::from([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
        let view2 = m2.view::<2, 3>((1, 0)).unwrap();
        assert_ne!(m1, view2);
    }

    #[test]
    fn test_eq_view_mut() {
        let m1 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let mut m2 = Matrix::from([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
        let view2 = m2.view_mut::<2, 3>((0, 0)).unwrap();
        assert_eq!(m1, view2);
    }

    #[test]
    fn test_ne_view_mut() {
        let m1 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let mut m2 = Matrix::from([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
        let view2 = m2.view_mut::<2, 3>((1, 0)).unwrap();
        assert_ne!(m1, view2);
    }

    #[test]
    fn test_eq_transpose_view() {
        let m1 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let m2 = Matrix::from([[1, 4], [2, 5], [3, 6]]);
        let t_view2 = m2.t();
        assert_eq!(m1, t_view2);
    }

    #[test]
    fn test_ne_transpose_view() {
        let m1 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let m2 = Matrix::from([[1, 4], [2, 5], [3, 8]]);
        let t_view2 = m2.t();
        assert_ne!(m1, t_view2);
    }

    #[test]
    fn test_eq_transpose_view_mut() {
        let m1 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let mut m2 = Matrix::from([[1, 4], [2, 5], [3, 6]]);
        let t_view2 = m2.t_mut();
        assert_eq!(m1, t_view2);
    }

    #[test]
    fn test_ne_transpose_view_mut() {
        let m1 = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let mut m2 = Matrix::from([[1, 4], [2, 5], [3, 8]]);
        let t_view2 = m2.t_mut();
        assert_ne!(m1, t_view2);
    }

    #[test]
    fn test_display() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        assert_eq!(format!("{}", matrix), "[[1, 2, 3]\n [4, 5, 6]]");
    }

    #[test]
    fn test_display_alternate() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        assert_eq!(
            format!("{:#}", matrix),
            "Matrix([[1, 2, 3]\n        [4, 5, 6]], dtype=i32)"
        );
    }

    #[test]
    fn test_index_single() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        assert_eq!(matrix[0], 1);
        assert_eq!(matrix[1], 2);
        assert_eq!(matrix[2], 3);
        assert_eq!(matrix[3], 4);
        assert_eq!(matrix[4], 5);
        assert_eq!(matrix[5], 6);
    }

    #[test]
    #[should_panic(expected = "Index out of bounds")]
    fn test_index_single_out_of_bounds() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let _ = matrix[6];
    }

    #[test]
    fn test_index_mut_single() {
        let mut matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        matrix[1] = 10;
        matrix[4] = 20;
        assert_eq!(matrix[0], 1);
        assert_eq!(matrix[1], 10);
        assert_eq!(matrix[2], 3);
        assert_eq!(matrix[3], 4);
        assert_eq!(matrix[4], 20);
        assert_eq!(matrix[5], 6);
    }

    #[test]
    #[should_panic(expected = "Index out of bounds")]
    fn test_index_mut_single_out_of_bounds() {
        let mut matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        matrix[6] = 10;
    }

    #[test]
    fn test_index() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        assert_eq!(matrix[(0, 0)], 1);
        assert_eq!(matrix[(0, 1)], 2);
        assert_eq!(matrix[(0, 2)], 3);
        assert_eq!(matrix[(1, 0)], 4);
        assert_eq!(matrix[(1, 1)], 5);
        assert_eq!(matrix[(1, 2)], 6);
    }

    #[test]
    #[should_panic(expected = "Index out of bounds")]
    fn test_index_out_of_bounds() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let _ = matrix[(2, 0)];
    }

    #[test]
    fn test_index_mut() {
        let mut matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        matrix[(0, 1)] = 10;
        matrix[(1, 2)] = 20;
        assert_eq!(matrix[(0, 0)], 1);
        assert_eq!(matrix[(0, 1)], 10);
        assert_eq!(matrix[(0, 2)], 3);
        assert_eq!(matrix[(1, 0)], 4);
        assert_eq!(matrix[(1, 1)], 5);
        assert_eq!(matrix[(1, 2)], 20);
    }

    #[test]
    #[should_panic(expected = "Index out of bounds")]
    fn test_index_mut_out_of_bounds() {
        let mut matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        matrix[(0, 3)] = 10;
    }

    #[test]
    fn test_from_array() {
        let array = [[1, 2, 3], [4, 5, 6]];
        let matrix: Matrix<_, 2, 3> = Matrix::from(array);
        assert_eq!(matrix, Matrix::from([[1, 2, 3], [4, 5, 6]]));
    }

    #[test]
    fn test_from_vector() {
        let vector = Vector::from([1, 2, 3, 4]);
        let matrix: Matrix<_, 4, 1> = Matrix::from(vector);
        assert_eq!(matrix, Matrix::from([[1], [2], [3], [4]]));
    }

    #[test]
    fn test_from_row_vector() {
        let vector = RowVector::from([1, 2, 3, 4]);
        let matrix: Matrix<_, 1, 4> = Matrix::from(vector);
        assert_eq!(matrix, Matrix::from([[1, 2, 3, 4]]));
    }

    #[test]
    fn test_from_vector_view() {
        let vector = Vector::from([1, 2, 3, 4]);
        let view = vector.view::<2>(1).unwrap();
        let matrix: Matrix<_, 2, 1> = Matrix::from(view);
        assert_eq!(matrix, Matrix::from([[2], [3]]));
    }

    #[test]
    fn test_from_vector_view_mut() {
        let mut vector = Vector::from([1, 2, 3, 4]);
        let view = vector.view_mut::<2>(1).unwrap();
        let matrix: Matrix<_, 2, 1> = Matrix::from(view);
        assert_eq!(matrix, Matrix::from([[2], [3]]));
    }

    #[test]
    fn test_from_row_vector_view() {
        let vector = RowVector::from([1, 2, 3, 4]);
        let view = vector.view::<2>(1).unwrap();
        let matrix: Matrix<_, 1, 2> = Matrix::from(view);
        assert_eq!(matrix, Matrix::from([[2, 3]]));
    }

    #[test]
    fn test_from_row_vector_view_mut() {
        let mut vector = RowVector::from([1, 2, 3, 4]);
        let view = vector.view_mut::<2>(1).unwrap();
        let matrix: Matrix<_, 1, 2> = Matrix::from(view);
        assert_eq!(matrix, Matrix::from([[2, 3]]));
    }

    #[test]
    fn test_from_matrix_view() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let view = matrix.view::<2, 2>((0, 1)).unwrap();
        let new_matrix: Matrix<_, 2, 2> = Matrix::from(view);
        assert_eq!(new_matrix, Matrix::from([[2, 3], [5, 6]]));
    }

    #[test]
    fn test_from_matrix_view_mut() {
        let mut matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let view = matrix.view_mut::<2, 2>((0, 1)).unwrap();
        let new_matrix: Matrix<_, 2, 2> = Matrix::from(view);
        assert_eq!(new_matrix, Matrix::from([[2, 3], [5, 6]]));
    }

    #[test]
    fn test_from_matrix_transpose_view() {
        let matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let t_view = matrix.t();
        let new_matrix: Matrix<_, 3, 2> = Matrix::from(t_view);
        assert_eq!(new_matrix, Matrix::from([[1, 4], [2, 5], [3, 6]]));
    }

    #[test]
    fn test_from_matrix_transpose_view_mut() {
        let mut matrix = Matrix::from([[1, 2, 3], [4, 5, 6]]);
        let t_view = matrix.t_mut();
        let new_matrix: Matrix<_, 3, 2> = Matrix::from(t_view);
        assert_eq!(new_matrix, Matrix::from([[1, 4], [2, 5], [3, 6]]));
    }

    #[test]
    fn test_matrix_send() {
        fn assert_send<T: Send>() {}
        assert_send::<Matrix<i32, 3, 3>>();
    }

    #[test]
    fn test_matrix_sync() {
        fn assert_sync<T: Sync>() {}
        assert_sync::<Matrix<i32, 3, 3>>();
    }
}