test: tests for set_row

src/lib.rs

@@ -90,9 +90,8 @@ impl Matrix {
         if row >= self.rows || column >= self.columns {
             return Err(MatrixError::IndexOutOfRange);
         }
-        let mut index = 0;
-        index += row * self.columns;
-        index += column;
+        let index = row * self.columns + column;
+
         self.data[index] = data;
         Ok(())
     }
@@ -1105,4 +1104,108 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_set_row_valid() {
+        let mut m = Matrix::new(3, 3, Fraction::from(0)).unwrap();
+
+        let new_row = vec![Fraction::from(1), Fraction::from(2), Fraction::from(3)];
+
+        m.set_row(1, new_row.clone()).unwrap();
+
+        let row: Vec<Fraction> = m.get_row(1).unwrap().cloned().collect();
+
+        assert_eq!(row, new_row);
+    }
+
+    #[test]
+    fn test_set_first_row() {
+        let mut m = Matrix::new(2, 2, Fraction::from(0)).unwrap();
+
+        let new_row = vec![Fraction::from(5), Fraction::from(6)];
+
+        m.set_row(0, new_row.clone()).unwrap();
+
+        assert_eq!(m.get_row(0).unwrap().cloned().collect::<Vec<_>>(), new_row);
+    }
+
+    #[test]
+    fn test_set_last_row() {
+        let mut m = Matrix::new(2, 3, Fraction::from(0)).unwrap();
+
+        let new_row = vec![Fraction::from(7), Fraction::from(8), Fraction::from(9)];
+
+        m.set_row(1, new_row.clone()).unwrap();
+
+        assert_eq!(m.get_row(1).unwrap().cloned().collect::<Vec<_>>(), new_row);
+    }
+
+    #[test]
+    fn test_set_row_out_of_bounds() {
+        let mut m = Matrix::new(2, 2, Fraction::from(0)).unwrap();
+
+        let data = vec![Fraction::from(1), Fraction::from(2)];
+
+        let result = m.set_row(2, data);
+
+        assert!(matches!(result, Err(MatrixError::IndexOutOfRange)));
+    }
+
+    #[test]
+    fn test_set_row_invalid_size() {
+        let mut m = Matrix::new(2, 3, Fraction::from(0)).unwrap();
+
+        let data = vec![Fraction::from(1), Fraction::from(2)]; // tamaño incorrecto
+
+        let result = m.set_row(0, data);
+
+        assert!(matches!(result, Err(MatrixError::InvalidDataSize)));
+    }
+
+    #[test]
+    fn test_set_row_does_not_affect_other_rows() {
+        let mut m = Matrix::new(3, 2, Fraction::from(1)).unwrap();
+
+        let new_row = vec![Fraction::from(9), Fraction::from(9)];
+
+        m.set_row(1, new_row).unwrap();
+
+        // fila 0 intacta
+        assert_eq!(
+            m.get_row(0).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(1), Fraction::from(1)]
+        );
+
+        // fila 2 intacta
+        assert_eq!(
+            m.get_row(2).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(1), Fraction::from(1)]
+        );
+    }
+
+    #[test]
+    fn test_set_row_overwrite() {
+        let mut m = Matrix::new(2, 2, Fraction::from(3)).unwrap();
+
+        let row1 = vec![Fraction::from(4), Fraction::from(5)];
+        let row2 = vec![Fraction::from(8), Fraction::from(9)];
+
+        m.set_row(1, row1).unwrap();
+        m.set_row(1, row2.clone()).unwrap();
+
+        assert_eq!(m.get_row(1).unwrap().cloned().collect::<Vec<_>>(), row2);
+    }
+
+    #[test]
+    fn test_set_row_consistency_with_set() {
+        let mut m = Matrix::new(3, 3, Fraction::from(0)).unwrap();
+
+        let new_row = vec![Fraction::from(10), Fraction::from(20), Fraction::from(30)];
+
+        m.set_row(2, new_row.clone()).unwrap();
+
+        for (i, val) in new_row.iter().enumerate() {
+            assert_eq!(*m.get(2, i).unwrap(), *val);
+        }
+    }
 }