test: test for insert_column

src/lib.rs

@@ -1504,4 +1504,370 @@ mod tests {
             vec![Fraction::from(3), Fraction::from(2), Fraction::from(1),]
         );
     }
+
+    #[test]
+    fn test_exchange_columns_basic() {
+        let mut m = Matrix {
+            rows: 2,
+            columns: 3,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(4),
+                Fraction::from(5),
+                Fraction::from(6),
+            ],
+        };
+
+        m.exchange_columns(0, 2).unwrap();
+
+        assert_eq!(
+            m.data,
+            vec![
+                Fraction::from(3),
+                Fraction::from(2),
+                Fraction::from(1),
+                Fraction::from(6),
+                Fraction::from(5),
+                Fraction::from(4),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_exchange_columns_same_column() {
+        let mut m = Matrix::new(3, 3, Fraction::from(7)).unwrap();
+
+        let before = m.data.clone();
+
+        m.exchange_columns(1, 1).unwrap();
+
+        assert_eq!(m.data, before);
+    }
+
+    #[test]
+    fn test_exchange_columns_first_last() {
+        let mut m = Matrix {
+            rows: 3,
+            columns: 3,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(4),
+                Fraction::from(5),
+                Fraction::from(6),
+                Fraction::from(7),
+                Fraction::from(8),
+                Fraction::from(9),
+            ],
+        };
+
+        m.exchange_columns(0, 2).unwrap();
+
+        assert_eq!(
+            m.get_column(0).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(3), Fraction::from(6), Fraction::from(9)]
+        );
+
+        assert_eq!(
+            m.get_column(2).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(1), Fraction::from(4), Fraction::from(7)]
+        );
+    }
+
+    #[test]
+    fn test_exchange_columns_out_of_bounds_col1() {
+        let mut m = Matrix::new(2, 2, Fraction::from(0)).unwrap();
+
+        let result = m.exchange_columns(2, 0);
+
+        assert!(matches!(result, Err(MatrixError::ColumnOutOfRange)));
+    }
+
+    #[test]
+    fn test_exchange_columns_out_of_bounds_col2() {
+        let mut m = Matrix::new(2, 2, Fraction::from(0)).unwrap();
+
+        let result = m.exchange_columns(0, 2);
+
+        assert!(matches!(result, Err(MatrixError::ColumnOutOfRange)));
+    }
+
+    #[test]
+    fn test_exchange_columns_does_not_affect_other_columns() {
+        let mut m = Matrix {
+            rows: 3,
+            columns: 3,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(1),
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(2),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(3),
+                Fraction::from(3),
+            ],
+        };
+
+        m.exchange_columns(0, 1).unwrap();
+
+        // columna 2 intacta
+        assert_eq!(
+            m.get_column(2).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(1), Fraction::from(2), Fraction::from(3)]
+        );
+    }
+
+    #[test]
+    fn test_exchange_columns_twice_returns_original() {
+        let mut m = Matrix {
+            rows: 2,
+            columns: 3,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(4),
+                Fraction::from(5),
+                Fraction::from(6),
+            ],
+        };
+
+        let original = m.data.clone();
+
+        m.exchange_columns(0, 2).unwrap();
+        m.exchange_columns(0, 2).unwrap();
+
+        assert_eq!(m.data, original);
+    }
+
+    #[test]
+    fn test_exchange_columns_consistency_with_get() {
+        let mut m = Matrix {
+            rows: 3,
+            columns: 2,
+            data: vec![
+                Fraction::from(10),
+                Fraction::from(20),
+                Fraction::from(30),
+                Fraction::from(40),
+                Fraction::from(50),
+                Fraction::from(60),
+            ],
+        };
+
+        let col0_before: Vec<_> = m.get_column(0).unwrap().cloned().collect();
+        let col1_before: Vec<_> = m.get_column(1).unwrap().cloned().collect();
+
+        m.exchange_columns(0, 1).unwrap();
+
+        let col0_after: Vec<_> = m.get_column(0).unwrap().cloned().collect();
+        let col1_after: Vec<_> = m.get_column(1).unwrap().cloned().collect();
+
+        assert_eq!(col0_after, col1_before);
+        assert_eq!(col1_after, col0_before);
+    }
+
+    #[test]
+    fn test_exchange_columns_single_row_matrix() {
+        let mut m = Matrix {
+            rows: 1,
+            columns: 3,
+            data: vec![Fraction::from(1), Fraction::from(2), Fraction::from(3)],
+        };
+
+        m.exchange_columns(0, 2).unwrap();
+
+        assert_eq!(
+            m.data,
+            vec![Fraction::from(3), Fraction::from(2), Fraction::from(1),]
+        );
+    }
+
+    #[test]
+    fn test_insert_column_basic_middle() {
+        let mut m = Matrix {
+            rows: 2,
+            columns: 2,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(4),
+            ],
+        };
+
+        let new_col = vec![Fraction::from(9), Fraction::from(9)];
+
+        m.insert_column(1, new_col.clone()).unwrap();
+
+        assert_eq!(m.columns, 3);
+
+        assert_eq!(
+            m.data,
+            vec![
+                Fraction::from(1),
+                Fraction::from(9),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(9),
+                Fraction::from(4),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_insert_column_at_start() {
+        let mut m = Matrix {
+            rows: 2,
+            columns: 2,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(4),
+            ],
+        };
+
+        let new_col = vec![Fraction::from(7), Fraction::from(8)];
+
+        m.insert_column(0, new_col.clone()).unwrap();
+
+        assert_eq!(
+            m.data,
+            vec![
+                Fraction::from(7),
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(8),
+                Fraction::from(3),
+                Fraction::from(4),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_insert_column_at_end_minus_one() {
+        let mut m = Matrix {
+            rows: 2,
+            columns: 3,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(4),
+                Fraction::from(5),
+                Fraction::from(6),
+            ],
+        };
+
+        let new_col = vec![Fraction::from(9), Fraction::from(9)];
+
+        m.insert_column(2, new_col.clone()).unwrap();
+
+        assert_eq!(
+            m.get_column(2).unwrap().cloned().collect::<Vec<_>>(),
+            new_col
+        );
+    }
+
+    #[test]
+    fn test_insert_column_invalid_index() {
+        let mut m = Matrix::new(2, 2, Fraction::from(0)).unwrap();
+
+        let data = vec![Fraction::from(1), Fraction::from(2)];
+
+        let result = m.insert_column(2, data);
+
+        assert!(matches!(result, Err(MatrixError::ColumnOutOfRange)));
+    }
+
+    #[test]
+    fn test_insert_column_invalid_size() {
+        let mut m = Matrix::new(3, 2, Fraction::from(0)).unwrap();
+
+        let data = vec![Fraction::from(1), Fraction::from(2)];
+
+        let result = m.insert_column(1, data);
+
+        assert!(matches!(result, Err(MatrixError::InvalidDataSize)));
+    }
+
+    #[test]
+    fn test_insert_column_preserves_other_data() {
+        let mut m = Matrix {
+            rows: 3,
+            columns: 2,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(4),
+                Fraction::from(5),
+                Fraction::from(6),
+            ],
+        };
+
+        let new_col = vec![Fraction::from(9), Fraction::from(9), Fraction::from(9)];
+
+        m.insert_column(1, new_col).unwrap();
+
+        assert_eq!(
+            m.get_column(0).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(1), Fraction::from(3), Fraction::from(5)]
+        );
+
+        assert_eq!(
+            m.get_column(2).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(2), Fraction::from(4), Fraction::from(6)]
+        );
+    }
+
+    #[test]
+    fn test_insert_column_multiple_times() {
+        let mut m = Matrix::new(2, 2, Fraction::from(1)).unwrap();
+
+        let col1 = vec![Fraction::from(2), Fraction::from(2)];
+        let col2 = vec![Fraction::from(3), Fraction::from(3)];
+
+        m.insert_column(1, col1).unwrap();
+        m.insert_column(2, col2.clone()).unwrap();
+
+        assert_eq!(m.get_column(2).unwrap().cloned().collect::<Vec<_>>(), col2);
+    }
+
+    #[test]
+    fn test_insert_column_consistency_with_get() {
+        let mut m = Matrix::new(3, 2, Fraction::from(0)).unwrap();
+
+        let new_col = vec![Fraction::from(10), Fraction::from(20), Fraction::from(30)];
+
+        m.insert_column(1, new_col.clone()).unwrap();
+
+        for (i, val) in new_col.iter().enumerate() {
+            assert_eq!(*m.get(i, 1).unwrap(), *val);
+        }
+    }
+
+    #[test]
+    fn test_insert_column_single_row() {
+        let mut m = Matrix {
+            rows: 1,
+            columns: 2,
+            data: vec![Fraction::from(1), Fraction::from(2)],
+        };
+
+        let new_col = vec![Fraction::from(9)];
+
+        m.insert_column(1, new_col).unwrap();
+
+        assert_eq!(
+            m.data,
+            vec![Fraction::from(1), Fraction::from(9), Fraction::from(2),]
+        );
+    }
 }