From cb130f5d86830272e110cc388651f9abae189f56 Mon Sep 17 00:00:00 2001
From: laentropia <aadrian887mh@gmail.com>
Date: Wed, 29 Apr 2026 15:42:33 -0600
Subject: [PATCH] test: tests for get

---
 src/lib.rs | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 104 insertions(+), 3 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index d3f9743..86a166b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -50,9 +50,9 @@ 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;
+
         return Ok(&self.data[index]);
     }
 
@@ -595,4 +595,105 @@ mod tests {
 
         assert_ne!(m1.data[0], m2.data[0]);
     }
+
+    #[test]
+    fn test_get_valid_positions() {
+        let 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),
+            ],
+        };
+
+        assert_eq!(*m.get(0, 0).unwrap(), Fraction::from(1));
+        assert_eq!(*m.get(0, 2).unwrap(), Fraction::from(3));
+        assert_eq!(*m.get(1, 0).unwrap(), Fraction::from(4));
+        assert_eq!(*m.get(1, 2).unwrap(), Fraction::from(6));
+    }
+
+    #[test]
+    fn test_get_middle_element() {
+        let 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),
+            ],
+        };
+
+        assert_eq!(*m.get(1, 1).unwrap(), Fraction::from(5));
+    }
+
+    #[test]
+    fn test_get_out_of_bounds_row() {
+        let m = Matrix::new(2, 2, Fraction::from(0)).unwrap();
+
+        let result = m.get(2, 0);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), MatrixError::IndexOutOfRange);
+    }
+
+    #[test]
+    fn test_get_out_of_bounds_column() {
+        let m = Matrix::new(2, 2, Fraction::from(0)).unwrap();
+
+        let result = m.get(0, 2);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), MatrixError::IndexOutOfRange);
+    }
+
+    #[test]
+    fn test_get_last_element() {
+        let m = Matrix {
+            rows: 2,
+            columns: 2,
+            data: vec![
+                Fraction::from(10),
+                Fraction::from(20),
+                Fraction::from(30),
+                Fraction::from(40),
+            ],
+        };
+
+        assert_eq!(*m.get(1, 1).unwrap(), Fraction::from(40));
+    }
+
+    #[test]
+    fn test_get_first_element() {
+        let m = Matrix::new(3, 3, Fraction::from(7)).unwrap();
+
+        assert_eq!(*m.get(0, 0).unwrap(), Fraction::from(7));
+    }
+
+    #[test]
+    fn test_get_consistency_with_manual_index() {
+        let m = Matrix {
+            rows: 3,
+            columns: 4,
+            data: (0..12).map(|x| Fraction::from(x as i64)).collect(),
+        };
+
+        for r in 0..3 {
+            for c in 0..4 {
+                let expected_index = r * 4 + c;
+                assert_eq!(*m.get(r, c).unwrap(), Fraction::from(expected_index as i64));
+            }
+        }
+    }
 }