test: tests for set_column

src/lib.rs

@@ -104,9 +104,10 @@ impl Matrix {
             return Err(MatrixError::InvalidDataSize);
         }
 
-        for i in 0..data.len() {
-            self.set(row, i, data[i])?;
-        }
+        let start = row * self.columns;
+        let end = start + self.columns;
+
+        self.data[start..end].clone_from_slice(&data);
 
         Ok(())
     }
@@ -119,8 +120,8 @@ impl Matrix {
             return Err(MatrixError::InvalidDataSize);
         }
 
-        for i in 0..data.len() {
-            self.set(i, column, data[i])?;
+        for (i, val) in data.into_iter().enumerate() {
+            self.data[i * self.columns + column] = val;
         }
 
         Ok(())
@@ -1208,4 +1209,128 @@ mod tests {
             assert_eq!(*m.get(2, i).unwrap(), *val);
         }
     }
+
+    #[test]
+    fn test_set_column_valid() {
+        let mut m = Matrix::new(3, 3, Fraction::from(0)).unwrap();
+
+        let new_col = vec![Fraction::from(1), Fraction::from(2), Fraction::from(3)];
+
+        m.set_column(1, new_col.clone()).unwrap();
+
+        let col: Vec<Fraction> = m.get_column(1).unwrap().cloned().collect();
+
+        assert_eq!(col, new_col);
+    }
+
+    #[test]
+    fn test_set_first_column() {
+        let mut m = Matrix::new(2, 2, Fraction::from(0)).unwrap();
+
+        let new_col = vec![Fraction::from(5), Fraction::from(6)];
+
+        m.set_column(0, new_col.clone()).unwrap();
+
+        assert_eq!(
+            m.get_column(0).unwrap().cloned().collect::<Vec<_>>(),
+            new_col
+        );
+    }
+
+    #[test]
+    fn test_set_last_column() {
+        let mut m = Matrix::new(2, 3, Fraction::from(0)).unwrap();
+
+        let new_col = vec![Fraction::from(7), Fraction::from(8)];
+
+        m.set_column(2, new_col.clone()).unwrap();
+
+        assert_eq!(
+            m.get_column(2).unwrap().cloned().collect::<Vec<_>>(),
+            new_col
+        );
+    }
+
+    #[test]
+    fn test_set_column_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_column(2, data);
+
+        assert!(matches!(result, Err(MatrixError::ColumnOutOfRange)));
+    }
+
+    #[test]
+    fn test_set_column_invalid_size() {
+        let mut m = Matrix::new(3, 2, Fraction::from(0)).unwrap();
+
+        let data = vec![Fraction::from(1), Fraction::from(2)]; // tamaño incorrecto
+
+        let result = m.set_column(1, data);
+
+        assert!(matches!(result, Err(MatrixError::InvalidDataSize)));
+    }
+
+    #[test]
+    fn test_set_column_does_not_affect_other_columns() {
+        let mut m = Matrix::new(3, 3, Fraction::from(1)).unwrap();
+
+        let new_col = vec![Fraction::from(9), Fraction::from(9), Fraction::from(9)];
+
+        m.set_column(1, new_col).unwrap();
+
+        // columna 0 intacta
+        assert_eq!(
+            m.get_column(0).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(1); 3]
+        );
+
+        // columna 2 intacta
+        assert_eq!(
+            m.get_column(2).unwrap().cloned().collect::<Vec<_>>(),
+            vec![Fraction::from(1); 3]
+        );
+    }
+
+    #[test]
+    fn test_set_column_overwrite() {
+        let mut m = Matrix::new(2, 2, Fraction::from(3)).unwrap();
+
+        let col1 = vec![Fraction::from(4), Fraction::from(5)];
+        let col2 = vec![Fraction::from(8), Fraction::from(9)];
+
+        m.set_column(1, col1).unwrap();
+        m.set_column(1, col2.clone()).unwrap();
+
+        assert_eq!(m.get_column(1).unwrap().cloned().collect::<Vec<_>>(), col2);
+    }
+
+    #[test]
+    fn test_set_column_consistency_with_set() {
+        let mut m = Matrix::new(3, 3, Fraction::from(0)).unwrap();
+
+        let new_col = vec![Fraction::from(10), Fraction::from(20), Fraction::from(30)];
+
+        m.set_column(2, new_col.clone()).unwrap();
+
+        for (i, val) in new_col.iter().enumerate() {
+            assert_eq!(*m.get(i, 2).unwrap(), *val);
+        }
+    }
+
+    #[test]
+    fn test_set_column_mixed_values() {
+        let mut m = Matrix::new(3, 3, Fraction::from(0)).unwrap();
+
+        let new_col = vec![Fraction::from(1), Fraction::from(100), Fraction::from(-5)];
+
+        m.set_column(0, new_col.clone()).unwrap();
+
+        assert_eq!(
+            m.get_column(0).unwrap().cloned().collect::<Vec<_>>(),
+            new_col
+        );
+    }
 }