test: tests for exchange_columns

src/lib.rs

@@ -1333,4 +1333,175 @@ mod tests {
             new_col
         );
     }
+
+    #[test]
+    fn test_exchange_rows_basic() {
+        let mut m = Matrix {
+            rows: 2,
+            columns: 2,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(4),
+            ],
+        };
+
+        m.exchange_rows(0, 1).unwrap();
+
+        assert_eq!(
+            m.data,
+            vec![
+                Fraction::from(3),
+                Fraction::from(4),
+                Fraction::from(1),
+                Fraction::from(2),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_exchange_rows_same_row() {
+        let mut m = Matrix::new(3, 3, Fraction::from(5)).unwrap();
+
+        let before = m.data.clone();
+
+        m.exchange_rows(1, 1).unwrap();
+
+        assert_eq!(m.data, before);
+    }
+
+    #[test]
+    fn test_exchange_rows_first_last() {
+        let mut m = Matrix {
+            rows: 3,
+            columns: 2,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2), // row 0
+                Fraction::from(3),
+                Fraction::from(4), // row 1
+                Fraction::from(5),
+                Fraction::from(6), // row 2
+            ],
+        };
+
+        m.exchange_rows(0, 2).unwrap();
+
+        assert_eq!(
+            m.get_row(0).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(5), Fraction::from(6)]
+        );
+
+        assert_eq!(
+            m.get_row(2).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(1), Fraction::from(2)]
+        );
+    }
+
+    #[test]
+    fn test_exchange_rows_out_of_bounds_row1() {
+        let mut m = Matrix::new(2, 2, Fraction::from(0)).unwrap();
+
+        let result = m.exchange_rows(2, 0);
+
+        assert!(matches!(result, Err(MatrixError::RowOutOfRange)));
+    }
+
+    #[test]
+    fn test_exchange_rows_out_of_bounds_row2() {
+        let mut m = Matrix::new(2, 2, Fraction::from(0)).unwrap();
+
+        let result = m.exchange_rows(0, 2);
+
+        assert!(matches!(result, Err(MatrixError::RowOutOfRange)));
+    }
+
+    #[test]
+    fn test_exchange_rows_does_not_affect_other_rows() {
+        let mut m = Matrix {
+            rows: 3,
+            columns: 2,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(3),
+            ],
+        };
+
+        m.exchange_rows(0, 1).unwrap();
+
+        // fila 2 intacta
+        assert_eq!(
+            m.get_row(2).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(3), Fraction::from(3)]
+        );
+    }
+
+    #[test]
+    fn test_exchange_rows_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_rows(0, 1).unwrap();
+        m.exchange_rows(0, 1).unwrap();
+
+        assert_eq!(m.data, original);
+    }
+
+    #[test]
+    fn test_exchange_rows_consistency_with_get() {
+        let mut m = Matrix {
+            rows: 2,
+            columns: 2,
+            data: vec![
+                Fraction::from(10),
+                Fraction::from(20),
+                Fraction::from(30),
+                Fraction::from(40),
+            ],
+        };
+
+        let row0_before: Vec<_> = m.get_row(0).unwrap().cloned().collect();
+        let row1_before: Vec<_> = m.get_row(1).unwrap().cloned().collect();
+
+        m.exchange_rows(0, 1).unwrap();
+
+        let row0_after: Vec<_> = m.get_row(0).unwrap().cloned().collect();
+        let row1_after: Vec<_> = m.get_row(1).unwrap().cloned().collect();
+
+        assert_eq!(row0_after, row1_before);
+        assert_eq!(row1_after, row0_before);
+    }
+
+    #[test]
+    fn test_exchange_rows_single_column_matrix() {
+        let mut m = Matrix {
+            rows: 3,
+            columns: 1,
+            data: vec![Fraction::from(1), Fraction::from(2), Fraction::from(3)],
+        };
+
+        m.exchange_rows(0, 2).unwrap();
+
+        assert_eq!(
+            m.data,
+            vec![Fraction::from(3), Fraction::from(2), Fraction::from(1),]
+        );
+    }
 }