chore(memtrack): use snapshots for c tests

Author: not-matthias

crates/memtrack/src/ebpf/events.rs

@@ -1,5 +1,4 @@
 use runner_shared::artifacts::{MemtrackEvent, MemtrackEventKind};
-use serde::{Deserialize, Serialize};
 
 // Include the bindings for event.h
 pub mod bindings {
@@ -12,55 +11,6 @@ pub mod bindings {
 }
 use bindings::*;
 
-#[repr(u8)]
-#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)]
-pub enum EventType {
-    Malloc = EVENT_TYPE_MALLOC as u8,
-    Free = EVENT_TYPE_FREE as u8,
-    Calloc = EVENT_TYPE_CALLOC as u8,
-    Realloc = EVENT_TYPE_REALLOC as u8,
-    AlignedAlloc = EVENT_TYPE_ALIGNED_ALLOC as u8,
-    Mmap = EVENT_TYPE_MMAP as u8,
-    Munmap = EVENT_TYPE_MUNMAP as u8,
-    Brk = EVENT_TYPE_BRK as u8,
-}
-
-impl From<u8> for EventType {
-    fn from(val: u8) -> Self {
-        match val as u32 {
-            bindings::EVENT_TYPE_MALLOC => EventType::Malloc,
-            bindings::EVENT_TYPE_FREE => EventType::Free,
-            bindings::EVENT_TYPE_CALLOC => EventType::Calloc,
-            bindings::EVENT_TYPE_REALLOC => EventType::Realloc,
-            bindings::EVENT_TYPE_ALIGNED_ALLOC => EventType::AlignedAlloc,
-            bindings::EVENT_TYPE_MMAP => EventType::Mmap,
-            bindings::EVENT_TYPE_MUNMAP => EventType::Munmap,
-            bindings::EVENT_TYPE_BRK => EventType::Brk,
-            _ => panic!("Unknown event type: {val}"),
-        }
-    }
-}
-
-/// Extension trait for MemtrackEvent to get the EventType
-pub trait MemtrackEventExt {
-    fn event_type(&self) -> EventType;
-}
-
-impl MemtrackEventExt for MemtrackEvent {
-    fn event_type(&self) -> EventType {
-        match self.kind {
-            MemtrackEventKind::Malloc { .. } => EventType::Malloc,
-            MemtrackEventKind::Free => EventType::Free,
-            MemtrackEventKind::Calloc { .. } => EventType::Calloc,
-            MemtrackEventKind::Realloc { .. } => EventType::Realloc,
-            MemtrackEventKind::AlignedAlloc { .. } => EventType::AlignedAlloc,
-            MemtrackEventKind::Mmap { .. } => EventType::Mmap,
-            MemtrackEventKind::Munmap { .. } => EventType::Munmap,
-            MemtrackEventKind::Brk { .. } => EventType::Brk,
-        }
-    }
-}
-
 /// Parse an event from raw bytes into MemtrackEvent
 ///
 /// SAFETY: The data must be a valid `bindings::event`
@@ -70,7 +20,6 @@ pub fn parse_event(data: &[u8]) -> Option<MemtrackEvent> {
     }
 
     let event = unsafe { &*(data.as_ptr() as *const bindings::event) };
-    let event_type = EventType::from(event.header.event_type);
 
     // Common fields from header
     let pid = event.header.pid as i32;
@@ -80,51 +29,54 @@ pub fn parse_event(data: &[u8]) -> Option<MemtrackEvent> {
     // Parse event data based on type
     // SAFETY: The fields must be properly initialized in eBPF
     let (addr, kind) = unsafe {
-        match event_type {
-            EventType::Malloc => (
+        match event.header.event_type as u32 {
+            EVENT_TYPE_MALLOC => (
                 event.data.alloc.addr,
                 MemtrackEventKind::Malloc {
                     size: event.data.alloc.size,
                 },
             ),
-            EventType::Free => (event.data.free.addr, MemtrackEventKind::Free),
-            EventType::Calloc => (
+            EVENT_TYPE_FREE => (event.data.free.addr, MemtrackEventKind::Free),
+            EVENT_TYPE_CALLOC => (
                 event.data.alloc.addr,
                 MemtrackEventKind::Calloc {
                     size: event.data.alloc.size,
                 },
             ),
-            EventType::Realloc => (
+            EVENT_TYPE_REALLOC => (
                 event.data.realloc.new_addr,
                 MemtrackEventKind::Realloc {
                     old_addr: Some(event.data.realloc.old_addr),
                     size: event.data.realloc.size,
                 },
             ),
-            EventType::AlignedAlloc => (
+            EVENT_TYPE_ALIGNED_ALLOC => (
                 event.data.alloc.addr,
                 MemtrackEventKind::AlignedAlloc {
                     size: event.data.alloc.size,
                 },
             ),
-            EventType::Mmap => (
+            EVENT_TYPE_MMAP => (
                 event.data.mmap.addr,
                 MemtrackEventKind::Mmap {
                     size: event.data.mmap.size,
                 },
             ),
-            EventType::Munmap => (
+            EVENT_TYPE_MUNMAP => (
                 event.data.mmap.addr,
                 MemtrackEventKind::Munmap {
                     size: event.data.mmap.size,
                 },
             ),
-            EventType::Brk => (
+            EVENT_TYPE_BRK => (
                 event.data.mmap.addr,
                 MemtrackEventKind::Brk {
                     size: event.data.mmap.size,
                 },
             ),
+            unknown => {
+                panic!("Unknown event type: {unknown}");
+            }
         }
     };
 

crates/memtrack/src/ebpf/mod.rs

@@ -3,6 +3,5 @@ mod memtrack;
 mod poller;
 mod tracker;
 
-pub use events::{EventType, MemtrackEventExt};
 pub use memtrack::MemtrackBpf;
 pub use tracker::Tracker;

crates/memtrack/tests/c_tests.rs

@@ -1,8 +1,7 @@
+#[macro_use]
 mod shared;
 
-use memtrack::EventType;
 use rstest::rstest;
-use runner_shared::artifacts::MemtrackEventKind;
 use std::fs;
 use std::path::Path;
 use std::process::Command;
@@ -32,58 +31,43 @@ fn compile_c_source(
     Ok(binary_path)
 }
 
-// ============================================================================
-// PARAMETERIZED ALLOCATION TESTS
-// ============================================================================
-
-/// Test case definition for allocation tracking tests
 struct AllocationTestCase {
     name: &'static str,
     source: &'static str,
-    assertions: &'static [(EventType, usize)],
-    allow_excess: bool, // Whether to allow >= instead of exact == for expected counts
 }
 
 const ALLOCATION_TEST_CASES: &[AllocationTestCase] = &[
     AllocationTestCase {
         name: "double_malloc",
         source: include_str!("../testdata/double_malloc.c"),
-        assertions: &[(EventType::Malloc, 2)],
-        allow_excess: false,
     },
     AllocationTestCase {
         name: "malloc_free",
         source: include_str!("../testdata/malloc_free.c"),
-        assertions: &[(EventType::Malloc, 1), (EventType::Free, 1)],
-        allow_excess: false,
     },
     AllocationTestCase {
         name: "calloc_test",
         source: include_str!("../testdata/calloc_test.c"),
-        assertions: &[(EventType::Calloc, 1), (EventType::Free, 1)],
-        allow_excess: false,
     },
     AllocationTestCase {
         name: "realloc_test",
         source: include_str!("../testdata/realloc_test.c"),
-        assertions: &[
-            (EventType::Malloc, 1),
-            (EventType::Realloc, 1),
-            (EventType::Free, 1),
-        ],
-        allow_excess: false,
     },
     AllocationTestCase {
         name: "aligned_alloc_test",
         source: include_str!("../testdata/aligned_alloc_test.c"),
-        assertions: &[(EventType::AlignedAlloc, 1), (EventType::Free, 1)],
-        allow_excess: false,
     },
     AllocationTestCase {
         name: "many_allocs",
         source: include_str!("../testdata/many_allocs.c"),
-        assertions: &[(EventType::Malloc, 100), (EventType::Free, 100)],
-        allow_excess: true, // Allow >= because we allocate ptrs array + 100 allocations
+    },
+    AllocationTestCase {
+        name: "fork_test",
+        source: include_str!("../testdata/fork_test.c"),
+    },
+    AllocationTestCase {
+        name: "alloc_size",
+        source: include_str!("../testdata/alloc_size.c"),
     },
 ];
 
@@ -95,6 +79,8 @@ const ALLOCATION_TEST_CASES: &[AllocationTestCase] = &[
 #[case(&ALLOCATION_TEST_CASES[3])]
 #[case(&ALLOCATION_TEST_CASES[4])]
 #[case(&ALLOCATION_TEST_CASES[5])]
+#[case(&ALLOCATION_TEST_CASES[6])]
+#[case(&ALLOCATION_TEST_CASES[7])]
 #[test_log::test]
 fn test_allocation_tracking(
     #[case] test_case: &AllocationTestCase,
@@ -104,108 +90,7 @@ fn test_allocation_tracking(
 
     let (events, thread_handle) = shared::track_binary(&binary)?;
 
-    for (event_type, expected_count) in test_case.assertions {
-        let actual_count = shared::count_events_by_type(&events, *event_type);
-
-        if test_case.allow_excess {
-            assert!(
-                actual_count >= *expected_count,
-                "Test '{}': Expected at least {} {:?} events, got {}",
-                test_case.name,
-                expected_count,
-                event_type,
-                actual_count
-            );
-        } else {
-            assert_eq!(
-                actual_count, *expected_count,
-                "Test '{}': Expected {} {:?} events, got {}",
-                test_case.name, expected_count, event_type, actual_count
-            );
-        }
-    }
-
-    thread_handle.join().unwrap();
-
-    Ok(())
-}
-
-#[test]
-#[test_with::env(GITHUB_ACTIONS)]
-fn test_fork_tracking() -> Result<(), Box<dyn std::error::Error>> {
-    let temp_dir = TempDir::new()?;
-    let source = include_str!("../testdata/fork_test.c");
-    let binary = compile_c_source(source, "fork_test", temp_dir.path())?;
-
-    let (events, thread_handle) = shared::track_binary(&binary)?;
-
-    let malloc_count = shared::count_events_by_type(&events, EventType::Malloc);
-    let free_count = shared::count_events_by_type(&events, EventType::Free);
-
-    // Should have at least 2 mallocs (parent + child)
-    assert!(
-        malloc_count >= 2,
-        "Expected at least 2 malloc events (parent + child), got {malloc_count}"
-    );
-
-    // Should have at least 2 frees (parent + child)
-    assert!(
-        free_count >= 2,
-        "Expected at least 2 free events (parent + child), got {free_count}"
-    );
-
-    // Verify we have events from different PIDs (parent and child)
-    let pids: std::collections::HashSet<u32> = events.iter().map(|e| e.pid as u32).collect();
-    assert!(
-        !pids.is_empty(),
-        "Expected to track at least parent process"
-    );
-
-    thread_handle.join().unwrap();
-
-    Ok(())
-}
-
-#[test]
-#[test_with::env(GITHUB_ACTIONS)]
-fn test_allocation_sizes() -> Result<(), Box<dyn std::error::Error>> {
-    let temp_dir = TempDir::new()?;
-    let source = include_str!("../testdata/alloc_size.c");
-    let binary = compile_c_source(source, "alloc_size", temp_dir.path())?;
-
-    let (events, thread_handle) = shared::track_binary(&binary)?;
-
-    // Filter malloc events and collect their sizes
-    let malloc_events: Vec<u64> = events
-        .iter()
-        .filter_map(|e| match e.kind {
-            MemtrackEventKind::Malloc { size } => Some(size),
-            _ => None,
-        })
-        .collect();
-
-    // Expected sizes from alloc_size.c: 1024, 2048, 512, 4096
-    let expected_sizes = vec![1024u64, 2048, 512, 4096];
-
-    // Check that we have exactly 4 malloc events
-    assert_eq!(
-        malloc_events.len(),
-        4,
-        "Expected 4 malloc events, got {}",
-        malloc_events.len()
-    );
-
-    // Check that all expected sizes are present
-    for expected_size in &expected_sizes {
-        assert!(
-            malloc_events.contains(expected_size),
-            "Expected allocation size {expected_size} not found in malloc events: {malloc_events:?}"
-        );
-    }
-
-    // Check that we have 4 free events
-    let free_count = shared::count_events_by_type(&events, EventType::Free);
-    assert_eq!(free_count, 4, "Expected 4 free events, got {free_count}");
+    assert_events_snapshot!(test_case.name, events);
 
     thread_handle.join().unwrap();