add memory tests

Author: tcoratger

crates/lean_vm/src/execution/memory.rs

@@ -69,7 +69,7 @@ impl Memory {
     }
 
     /// Gets the current size of allocated memory
-    pub fn size(&self) -> usize {
+    pub const fn size(&self) -> usize {
         self.0.len()
     }
 
@@ -157,3 +157,118 @@ impl Memory {
         (0..len).map(|i| self.get(start + i)).collect()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_basic_memory_operations() {
+        let mut memory = Memory::empty();
+
+        // Test setting and getting values
+        memory.set(0, F::ONE).unwrap();
+        memory.set(5, F::from_usize(42)).unwrap();
+
+        assert_eq!(memory.get(0).unwrap(), F::ONE);
+        assert_eq!(memory.get(5).unwrap(), F::from_usize(42));
+
+        // Test undefined memory access
+        assert!(matches!(memory.get(1), Err(RunnerError::UndefinedMemory)));
+    }
+
+    #[test]
+    fn test_memory_already_set_error() {
+        let mut memory = Memory::empty();
+
+        memory.set(0, F::ONE).unwrap();
+        // Setting same value should work
+        memory.set(0, F::ONE).unwrap();
+
+        // Setting different value should fail
+        assert!(matches!(
+            memory.set(0, F::ZERO),
+            Err(RunnerError::MemoryAlreadySet)
+        ));
+    }
+
+    #[test]
+    fn test_memory_slices() {
+        let mut memory = Memory::empty();
+        let values = vec![F::ONE, F::ZERO, F::from_usize(42), F::from_usize(100)];
+
+        memory.set_slice(10, &values).unwrap();
+        let retrieved = memory.get_slice(10, 4).unwrap();
+
+        assert_eq!(retrieved, values);
+    }
+
+    #[test]
+    fn test_memory_initialization_and_utilities() {
+        let public_data = vec![F::ONE, F::ZERO, F::from_usize(123)];
+        let memory = Memory::new(public_data.clone());
+
+        // All public data should be initialized
+        for (i, expected) in public_data.iter().enumerate() {
+            assert!(memory.is_initialized(i));
+            assert_eq!(memory.get(i).unwrap(), *expected);
+        }
+
+        assert_eq!(memory.size(), 3);
+
+        let entries = memory.initialized_entries();
+        assert_eq!(entries.len(), 3);
+        assert_eq!(entries[0], (0, F::ONE));
+        assert_eq!(entries[2], (2, F::from_usize(123)));
+    }
+
+    #[test]
+    fn test_vectorized_operations() {
+        let mut memory = Memory::empty();
+        let vector = [F::ONE; VECTOR_LEN];
+
+        memory.set_vector(0, vector).unwrap();
+        let retrieved = memory.get_vector(0).unwrap();
+
+        assert_eq!(retrieved, vector);
+
+        // Test vectorized slice
+        let slice_data = vec![F::from_usize(1); 2 * VECTOR_LEN];
+        memory.set_vectorized_slice(1, &slice_data).unwrap();
+        let retrieved_slice = memory.get_vectorized_slice(1, 2).unwrap();
+
+        assert_eq!(retrieved_slice, slice_data);
+    }
+
+    #[test]
+    fn test_extension_field_operations() {
+        let mut memory = Memory::empty();
+
+        // Create a simple extension field element with proper dimension
+        let mut coeffs = [F::ZERO; DIMENSION];
+        coeffs[0] = F::ONE;
+        let ef_value = EF::from_basis_coefficients_slice(&coeffs).unwrap();
+
+        memory.set_ef_element(0, ef_value).unwrap();
+        let retrieved = memory.get_ef_element(0).unwrap();
+
+        assert_eq!(retrieved, ef_value);
+
+        // Test continuous slice of EF elements
+        memory.set_ef_element(DIMENSION, ef_value).unwrap();
+        let ef_slice = memory.get_continuous_slice_of_ef_elements(0, 2).unwrap();
+
+        assert_eq!(ef_slice.len(), 2);
+        assert_eq!(ef_slice[0], ef_value);
+        assert_eq!(ef_slice[1], ef_value);
+    }
+
+    #[test]
+    fn test_memory_clear() {
+        let mut memory = Memory::new(vec![F::ONE, F::ZERO]);
+        assert_eq!(memory.size(), 2);
+
+        memory.clear();
+        assert_eq!(memory.size(), 0);
+    }
+}