netmap-rs 0.3.1

#![cfg(all(unix, feature = "sys"))]

// Helper module for VALE setup and common test functions
mod test_helpers {
    use netmap_rs::prelude::*;
    use std::time::{Duration, Instant};

    // VALE interface names for testing. Each test uses its own port pair so
    // that tests can run in parallel without interfering on the same switch
    // ports (VALE ports are shared kernel resources).
    // e.g., using `vale-ctl -n vale_test_switch -a vale_a -a vale_b`
    // or similar commands to create a VALE switch and attach ports.
    pub const DEFAULT_TIMEOUT: Duration = Duration::from_millis(1000); // Generous: parallel runs can steal CPU from the polling test threads

    // Build a unique pair of VALE port names for a given test tag.
    // VALE port names must be at most 15 characters, so derive them from
    // "a<tag>" / "b<tag>" rather than embedding the full switch name twice.
    pub fn vale_port_name(side: char, tag: &str) -> String {
        format!("vale0:{}{}", side, tag)
    }

    pub fn setup_vale_pair(tag: &str, num_rings: usize) -> Result<(Netmap, Netmap), Error> {
        let nm_a = setup_vale_interface(&vale_port_name('a', tag), num_rings)?;
        let nm_b = setup_vale_interface(&vale_port_name('b', tag), num_rings)?;
        Ok((nm_a, nm_b))
    }

    pub fn setup_vale_interface(if_name: &str, num_rings: usize) -> Result<Netmap, Error> {
        NetmapBuilder::new(if_name)
            .num_tx_rings(num_rings)
            .num_rx_rings(num_rings)
            .build()
    }

    // Helper to send a packet and sync
    pub fn send_packet_and_sync(tx_ring: &mut TxRing, payload: &[u8]) -> Result<(), Error> {
        tx_ring.send(payload)?;
        tx_ring.sync();
        Ok(())
    }

    // Helper to receive a packet with timeout and optional payload check
    pub fn receive_packet_timeout(
        rx_ring: &mut RxRing,
        expected_payload: Option<&[u8]>,
        timeout: Duration,
    ) -> Result<Option<Vec<u8>>, String> {
        let start_time = Instant::now();
        loop {
            if start_time.elapsed() > timeout {
                return Ok(None); // Timeout
            }

            rx_ring.sync(); // Sync before attempting to receive
            if let Some(frame) = rx_ring.recv() {
                let received_payload = frame.payload().to_vec();
                if let Some(expected) = expected_payload {
                    if received_payload != expected {
                        return Err(format!(
                            "Payload mismatch. Expected: {:?}, Got: {:?}",
                            expected, received_payload
                        ));
                    }
                }
                return Ok(Some(received_payload));
            }
            // Small sleep to avoid pegging CPU if nothing is received immediately
            std::thread::sleep(Duration::from_micros(50));
        }
    }

    // Host-stack rings on a real interface are intentionally NOT exercised by
    // default: registering `netmap:lo^` attaches the kernel host path to the
    // loopback and can disrupt networking on the machine running the tests.
    // Opt in explicitly by setting NETMAP_TEST_HOST_RINGS=1, and only when you
    // are OK with the loopback traffic being attached to netmap temporarily.
    #[test]
    fn test_open_host_rings_loopback() {
        if std::env::var("NETMAP_TEST_HOST_RINGS")
            .map(|v| v != "1")
            .unwrap_or(true)
        {
            eprintln!(
                "Skipping host-ring test: set NETMAP_TEST_HOST_RINGS=1 to run it \
                (it attaches the loopback host path to netmap)."
            );
            return;
        }
        // Use "lo" (loopback) interface with '^' suffix for host stack rings.
        // This requires appropriate permissions to run.
        const LOOPBACK_HOST_IF: &str = "netmap:lo^";

        match NetmapBuilder::new(LOOPBACK_HOST_IF)
            .num_tx_rings(1) // Request at least one host TX ring
            .num_rx_rings(1) // Request at least one host RX ring
            .build()
        {
            Ok(nm) => {
                assert!(
                    nm.is_host_if(),
                    "Netmap interface opened with '{}' should be identified as a host interface.",
                    LOOPBACK_HOST_IF
                );

                // Loopback interface usually has 1 TX and 1 RX ring for the host stack.
                // However, this can vary. We check if it's > 0.
                let num_tx = nm.num_tx_rings();
                let num_rx = nm.num_rx_rings();
                println!(
                    "Interface {}: Host TX rings = {}, Host RX rings = {}",
                    LOOPBACK_HOST_IF, num_tx, num_rx
                );

                assert!(
                    num_tx > 0,
                    "Expected at least one host TX ring on {}.",
                    LOOPBACK_HOST_IF
                );
                assert!(
                    num_rx > 0,
                    "Expected at least one host RX ring on {}.",
                    LOOPBACK_HOST_IF
                );

                // Try to get the first host TX and RX rings
                assert!(
                    nm.tx_ring(0).is_ok(),
                    "Failed to get host TX ring 0 from {}.",
                    LOOPBACK_HOST_IF
                );
                assert!(
                    nm.rx_ring(0).is_ok(),
                    "Failed to get host RX ring 0 from {}.",
                    LOOPBACK_HOST_IF
                );

                // Test invalid ring index for host rings
                assert!(
                    matches!(nm.tx_ring(num_tx), Err(Error::InvalidRingIndex(_))),
                    "Accessing out-of-bounds host TX ring did not return InvalidRingIndex."
                );
                assert!(
                    matches!(nm.rx_ring(num_rx), Err(Error::InvalidRingIndex(_))),
                    "Accessing out-of-bounds host RX ring did not return InvalidRingIndex."
                );
            }
            Err(e) => {
                // This test might fail due to permissions or if netmap cannot attach to lo^.
                // We print the error and don't panic to allow CI to pass if it's a setup issue.
                // However, for local testing with root, this should ideally pass.
                println!("Warning: Failed to open host rings on '{}': {:?}. This test requires appropriate permissions and netmap support for loopback host stack.", LOOPBACK_HOST_IF, e);
                // To make this a strict test, uncomment the panic:
                // panic!("Failed to open host rings on '{}': {:?}", LOOPBACK_HOST_IF, e);
            }
        }
    }
}

mod netmap_tests {
    use super::test_helpers::*;
    use netmap_rs::prelude::*;
    use std::time::Duration; // Keep for other specific timeouts if needed

    // Test to ensure VALE interfaces can be opened.
    // This acts as a basic check that the test environment (VALE ports) is somewhat sane.
    #[test]
    fn test_vale_interface_availability() {
        let (nm_a, nm_b) = setup_vale_pair("avail", 1).expect("Failed to open VALE port pair");
        assert!(
            nm_a.num_tx_rings() >= 1,
            "Interface A ({}) should expose TX rings.",
            vale_port_name('a', "avail")
        );
        assert!(
            nm_b.num_rx_rings() >= 1,
            "Interface B ({}) should expose RX rings.",
            vale_port_name('b', "avail")
        );
    }

    #[test]
    fn test_original_netmap_creation_on_vale() {
        // Renamed from test_netmap_creation
        let result = setup_vale_pair("create", 1);
        assert!(
            result.is_ok(),
            "Failed to create Netmap instance on a VALE port"
        );
    }

    #[test]
    fn test_single_packet_vale_loopback() {
        // Replaces test_ring_operations
        let (nm_a, nm_b) = setup_vale_pair("single", 1)
            .expect("Failed to setup VALE interfaces for single packet test");

        let mut tx_ring_a = nm_a
            .tx_ring(0)
            .expect("Failed to get TX ring from VALE_IF_A");
        let mut rx_ring_b = nm_b
            .rx_ring(0)
            .expect("Failed to get RX ring from VALE_IF_B");

        let packet_payload = b"hello_vale_single";
        send_packet_and_sync(&mut tx_ring_a, packet_payload).expect("Send failed on VALE_IF_A");

        match receive_packet_timeout(&mut rx_ring_b, Some(packet_payload), DEFAULT_TIMEOUT) {
            Ok(Some(payload)) => {
                assert_eq!(payload, packet_payload, "Received payload does not match")
            }
            Ok(None) => panic!("Timeout: Did not receive packet on VALE_IF_B"),
            Err(e) => panic!("Receive error: {}", e),
        }
    }

    #[test]
    fn test_batch_vale_loopback() {
        // Replaces test_batch_operations
        let (nm_a, nm_b) =
            setup_vale_pair("batch", 1).expect("Failed to setup VALE interfaces for batch test");

        let mut tx_ring_a = nm_a
            .tx_ring(0)
            .expect("Failed to get TX ring from VALE_IF_A");
        let mut rx_ring_b = nm_b
            .rx_ring(0)
            .expect("Failed to get RX ring from VALE_IF_B");

        let batch_size = 8;
        // VALE is an Ethernet switch and drops frames shorter than the minimum
        // Ethernet header (14 bytes). Keep packets above that threshold.
        let packet_len = 16; // Length of each packet in the batch

        // Send batch
        let mut reservation = tx_ring_a
            .reserve_batch(batch_size)
            .expect("Batch reservation failed on VALE_IF_A");

        let mut sent_payloads = Vec::new();

        for i in 0..batch_size {
            // Nonzero padding so VALE keeps the frame: an all-zero Ethernet
            // header (zero source MAC) is discarded by the switch.
            let mut payload_data = vec![0xAAu8; packet_len];
            payload_data[0] = 0x30 + i as u8; // Unique, nonzero identifier for the packet
                                              // Fill rest of payload_data if needed, e.g. payload_data.fill(i as u8);

            let slot = reservation
                .packet(i, payload_data.len())
                .expect("Failed to get packet slot in batch reservation");
            slot.copy_from_slice(&payload_data);
            sent_payloads.push(payload_data);
        }
        reservation.commit();
        tx_ring_a.sync();

        // Receive batch
        let mut received_frames_data = Vec::new();
        let mut total_received_count = 0;
        let start_time = std::time::Instant::now();

        // Buffer for recv_batch. Initialize with empty frames.
        let mut frame_buffer: Vec<Frame> =
            (0..batch_size).map(|_| Frame::new_borrowed(&[])).collect();

        while total_received_count < batch_size && start_time.elapsed() < DEFAULT_TIMEOUT * 2 {
            // Give a bit more time for batch
            rx_ring_b.sync(); // Sync before each recv_batch attempt
            let count = rx_ring_b.recv_batch(&mut frame_buffer[total_received_count..]);
            if count > 0 {
                for i in 0..count {
                    received_frames_data
                        .push(frame_buffer[total_received_count + i].payload().to_vec());
                }
                total_received_count += count;
            }
            if total_received_count < batch_size {
                std::thread::sleep(Duration::from_micros(50)); // Avoid busy loop if not all received at once
            }
        }

        assert_eq!(
            total_received_count, batch_size,
            "Did not receive the full batch. Received {} out of {}",
            total_received_count, batch_size
        );

        // Verify payloads (order might not be guaranteed by VALE, but often is for simple cases)
        // For robust checking, sort or use a set if order is not guaranteed.
        // Assuming order is preserved for this simple test:
        for i in 0..batch_size {
            assert_eq!(
                received_frames_data
                    .get(i)
                    .expect("Missing received frame data"),
                sent_payloads
                    .get(i)
                    .expect("Missing sent payload data for comparison"),
                "Mismatch in packet {} of the batch",
                i
            );
        }
    }

    #[test]
    fn test_multi_ring_independent_loopback() {
        let num_rings = 2;
        let (nm_a, nm_b) = setup_vale_pair("multi", num_rings)
            .expect("Failed to setup VALE interfaces for multi-ring test");

        assert!(
            nm_a.num_tx_rings() >= num_rings,
            "Interface A should expose at least {} TX rings",
            num_rings
        );
        assert!(
            nm_b.num_rx_rings() >= num_rings,
            "Interface B should expose at least {} RX rings",
            num_rings
        );

        // Send one packet per TX ring on A. VALE is a switch: it does not
        // guarantee that a packet sent on TX ring i arrives on RX ring i of the
        // peer, so we drain every RX ring and collect all the payloads.
        let mut expected = Vec::new();
        for i in 0..num_rings {
            let mut tx_ring_a = nm_a
                .tx_ring(i)
                .unwrap_or_else(|_| panic!("Failed to get TX ring {} from VALE_IF_A", i));
            let payload = format!("packet_on_ring_{}", i).into_bytes();
            send_packet_and_sync(&mut tx_ring_a, &payload)
                .unwrap_or_else(|_| panic!("Send failed on VALE_IF_A, ring {}", i));
            expected.push(payload);
        }

        let start_time = std::time::Instant::now();
        let mut received: Vec<Vec<u8>> = Vec::new();
        while received.len() < expected.len() && start_time.elapsed() < DEFAULT_TIMEOUT * 2 {
            for i in 0..num_rings {
                let mut rx_ring_b = nm_b
                    .rx_ring(i)
                    .unwrap_or_else(|_| panic!("Failed to get RX ring {} from VALE_IF_B", i));
                rx_ring_b.sync();
                while let Some(frame) = rx_ring_b.recv() {
                    received.push(frame.payload().to_vec());
                }
            }
            if received.len() < expected.len() {
                std::thread::sleep(Duration::from_micros(50));
            }
        }

        assert_eq!(
            received.len(),
            expected.len(),
            "Did not receive all multi-ring packets. Got {} out of {}",
            received.len(),
            expected.len()
        );

        // Order is not guaranteed across rings/switch, so compare as sets.
        for payload in &expected {
            assert!(
                received.contains(payload),
                "Missing payload {:?} in received {:?}",
                payload,
                received
            );
        }
    }

    #[test]
    fn test_tx_ring_error_packet_too_large() {
        let (nm_a, _nm_b) = setup_vale_pair("toolarge", 1)
            .expect("Failed to setup VALE interfaces for packet_too_large test");

        let mut tx_ring = nm_a.tx_ring(0).expect("Failed to get TX ring");

        // Get max_payload_size from the ring itself.
        // Assuming TxRing will have a method like max_payload_size() or similar.
        // From src/ring.rs, TxRing has max_payload_size().
        let max_size = tx_ring.max_payload_size();
        assert!(
            max_size > 0,
            "max_payload_size returned 0 or less, cannot run test meaningfully."
        );

        let large_payload = vec![0u8; max_size + 1];
        let result = tx_ring.send(&large_payload);

        match result {
            Err(Error::PacketTooLarge(size)) => {
                assert_eq!(
                    size,
                    large_payload.len(),
                    "Error::PacketTooLarge reported incorrect size."
                );
            }
            Err(e) => panic!("Expected Error::PacketTooLarge, got {:?}", e),
            Ok(_) => panic!("Send succeeded with a too-large packet, which is an error."),
        }
    }

    #[test]
    fn test_tx_ring_error_reserve_batch_insufficient_space() {
        let (nm_a, _nm_b) = setup_vale_pair("nospace", 1)
            .expect("Failed to setup VALE interfaces for insufficient_space test");
        let mut tx_ring = nm_a.tx_ring(0).expect("Failed to get TX ring");

        // num_slots() gives total slots. Max usable is num_slots - 1 for netmap.
        let num_total_slots = tx_ring.num_slots();
        assert!(num_total_slots > 0, "Ring reported 0 slots.");

        // Attempt to reserve more slots than physically possible (num_slots itself, since num_slots-1 is max usable)
        // Or, more directly, num_total_slots + 1 if the check is against total_slots.
        // The current reserve_batch logic checks against `available_slots = (num_slots - 1).saturating_sub(current_used_slots)`
        // So, requesting `num_total_slots` when the ring is empty should fail if `num_total_slots > 0`.
        // If num_total_slots is 1 (unlikely for real rings), then num_slots-1 = 0, so any request > 0 fails.
        // Let's try to reserve exactly `num_total_slots`. This should be more than `num_total_slots - 1`.
        let result = tx_ring.reserve_batch(num_total_slots);

        match result {
            Err(Error::InsufficientSpace) => {
                // This is the expected outcome
            }
            Err(e) => panic!("Expected Error::InsufficientSpace, got {:?}", e),
            Ok(_) => panic!(
                "Batch reservation succeeded when it should have failed due to insufficient space."
            ),
        }

        // Another test: fill the ring almost up, then request more than 1.
        // This requires knowing how many slots are available, which reserve_batch calculates internally.
        // For simplicity, the above test (requesting total_num_slots) is a good first check.
    }

    #[test]
    fn test_netmap_error_invalid_ring_index() {
        let num_rings = 1;
        let nm_a = setup_vale_interface(&vale_port_name('a', "badidx"), num_rings)
            .expect("Failed to setup a VALE interface for invalid_ring_index test");

        // Attempt to get rings with index equal to num_rings (which is out of bounds, max index is num_rings - 1)
        let result_tx = nm_a.tx_ring(num_rings);
        match result_tx {
            Err(Error::InvalidRingIndex(idx)) => {
                assert_eq!(
                    idx, num_rings,
                    "Error::InvalidRingIndex reported incorrect index for TX ring."
                );
            }
            Err(e) => panic!("Expected Error::InvalidRingIndex for TX ring, got {:?}", e),
            Ok(_) => panic!("Getting TX ring with invalid index succeeded, which is an error."),
        }

        let result_rx = nm_a.rx_ring(num_rings);
        match result_rx {
            Err(Error::InvalidRingIndex(idx)) => {
                assert_eq!(
                    idx, num_rings,
                    "Error::InvalidRingIndex reported incorrect index for RX ring."
                );
            }
            Err(e) => panic!("Expected Error::InvalidRingIndex for RX ring, got {:?}", e),
            Ok(_) => panic!("Getting RX ring with invalid index succeeded, which is an error."),
        }
    }

    const TEST_PIPE_MASTER: &str = "netmap:pipe{7";
    const TEST_PIPE_SLAVE: &str = "netmap:pipe}7";
    // test_pipe_open only probes the API on its own pipe so it never
    // contends with test_pipe_intra_process_send_recv (which uses pipe{7).
    const PROBE_PIPE_MASTER: &str = "netmap:pipe{9";

    #[test]
    fn test_pipe_open() {
        match NetmapBuilder::new(PROBE_PIPE_MASTER).build() {
            Ok(nm_pipe_master) => {
                assert!(
                    !nm_pipe_master.is_host_if(),
                    "Pipe interface should not be identified as host interface."
                );
                // Pipes typically default to 1 TX and 1 RX ring.
                assert_eq!(
                    nm_pipe_master.num_tx_rings(),
                    1,
                    "Pipe master endpoint should have 1 TX ring by default."
                );
                assert_eq!(
                    nm_pipe_master.num_rx_rings(),
                    1,
                    "Pipe master endpoint should have 1 RX ring by default."
                );
                // The master is now open. We can drop it here or use it.
            }
            Err(e) => {
                panic!(
                    "Failed to open first endpoint (master) of pipe '{}': {:?}",
                    PROBE_PIPE_MASTER, e
                );
            }
        }
        // Note: Netmap pipe might persist if not all descriptors are closed.
        // For this test, we just check if open works. Proper cleanup is by dropping.
    }

    #[test]
    fn test_pipe_intra_process_send_recv() {
        // Open master endpoint
        let nm_master = NetmapBuilder::new(TEST_PIPE_MASTER)
            .num_tx_rings(1) // Explicitly 1, though default for pipe
            .num_rx_rings(1)
            .build()
            .unwrap_or_else(|_| {
                panic!("Failed to open pipe master endpoint: {}", TEST_PIPE_MASTER)
            });

        // Open slave endpoint
        let nm_slave = NetmapBuilder::new(TEST_PIPE_SLAVE)
            .num_tx_rings(1)
            .num_rx_rings(1)
            .build()
            .unwrap_or_else(|_| panic!("Failed to open pipe slave endpoint: {}", TEST_PIPE_SLAVE));

        let mut master_tx_ring = nm_master.tx_ring(0).expect("Master: failed to get TX ring");
        let mut master_rx_ring = nm_master.rx_ring(0).expect("Master: failed to get RX ring");
        let mut slave_tx_ring = nm_slave.tx_ring(0).expect("Slave: failed to get TX ring");
        let mut slave_rx_ring = nm_slave.rx_ring(0).expect("Slave: failed to get RX ring");

        let payload_m_to_s = b"master_to_slave_pipe_test";
        let payload_s_to_m = b"slave_to_master_pipe_test";

        // Master sends to Slave
        send_packet_and_sync(&mut master_tx_ring, payload_m_to_s).expect("Master: send failed");

        match receive_packet_timeout(&mut slave_rx_ring, Some(payload_m_to_s), DEFAULT_TIMEOUT) {
            Ok(Some(p)) => assert_eq!(p, payload_m_to_s, "Slave: payload mismatch from master"),
            Ok(None) => panic!("Slave: timeout receiving from master"),
            Err(e) => panic!("Slave: receive error from master: {}", e),
        }
        println!("Pipe: Master to Slave communication successful.");

        // Slave sends to Master
        send_packet_and_sync(&mut slave_tx_ring, payload_s_to_m).expect("Slave: send failed");

        match receive_packet_timeout(&mut master_rx_ring, Some(payload_s_to_m), DEFAULT_TIMEOUT) {
            Ok(Some(p)) => assert_eq!(p, payload_s_to_m, "Master: payload mismatch from slave"),
            Ok(None) => panic!("Master: timeout receiving from slave"),
            Err(e) => panic!("Master: receive error from slave: {}", e),
        }
        println!("Pipe: Slave to Master communication successful.");
    }
}

#[cfg(feature = "tokio-async")]
mod tokio_async_tests {
    use super::test_helpers::*; // For DEFAULT_TIMEOUT, though may need async-specific timeout handling
    use netmap_rs::tokio_async::TokioNetmap;
    use netmap_rs::NetmapBuilder;
    use tokio::io::{AsyncReadExt, AsyncWriteExt};

    const ASYNC_TEST_PIPE_MASTER: &str = "netmap:pipe{8";
    const ASYNC_TEST_PIPE_SLAVE: &str = "netmap:pipe}8";
    const ASYNC_TEST_PAYLOAD: &[u8] = b"tokio_async_pipe_payload_test_data";
    const ASYNC_TEST_PACKET_SIZE: usize = 64; // Padded size

    #[tokio::test]
    #[cfg(all(unix, feature = "sys"))] // Ensure sys is also active for NetmapBuilder etc.
    async fn test_tokio_pipe_async_send_recv() {
        // 1. Setup Netmap instances for the pipe
        let netmap_a = NetmapBuilder::new(ASYNC_TEST_PIPE_MASTER)
            .build()
            .expect("Failed to open pipe master endpoint for tokio test");
        let netmap_b = NetmapBuilder::new(ASYNC_TEST_PIPE_SLAVE)
            .build()
            .expect("Failed to open pipe slave endpoint for tokio test");

        // 2. Wrap in TokioNetmap
        let tokio_nm_a =
            TokioNetmap::new(netmap_a).expect("Failed to create TokioNetmap for endpoint A");
        let tokio_nm_b =
            TokioNetmap::new(netmap_b).expect("Failed to create TokioNetmap for endpoint B");

        // 3. Get async rings
        let mut tx_ring_a = tokio_nm_a
            .tx_ring(0)
            .expect("Tokio A: Failed to get async TX ring");
        let mut rx_ring_b = tokio_nm_b
            .rx_ring(0)
            .expect("Tokio B: Failed to get async RX ring");

        // 4. Prepare payload
        let mut payload_to_send = ASYNC_TEST_PAYLOAD.to_vec();
        payload_to_send.resize(ASYNC_TEST_PACKET_SIZE, 0); // Pad

        // 5. Send the packet from A
        let send_future = async {
            tx_ring_a.write_all(&payload_to_send).await?;
            tx_ring_a.flush().await?;
            Result::<_, std::io::Error>::Ok(())
        };

        // 6. Receive the packet on B
        let mut receive_buffer = vec![0u8; ASYNC_TEST_PACKET_SIZE * 2];
        let recv_future = async {
            // Add a timeout to the receive operation to prevent test hangs
            match tokio::time::timeout(DEFAULT_TIMEOUT * 5, rx_ring_b.read(&mut receive_buffer))
                .await
            {
                Ok(Ok(n)) => Ok((n, receive_buffer)), // n is number of bytes read
                Ok(Err(e)) => Err(e),
                Err(_timeout_elapsed) => Err(std::io::Error::new(
                    std::io::ErrorKind::TimedOut,
                    "Receive operation timed out",
                )),
            }
        };

        // Run send and receive, potentially concurrently or sequentially for simplicity here
        let (send_result, recv_result) = tokio::join!(send_future, recv_future);

        send_result.expect("Sending packet failed");

        match recv_result {
            Ok((n, buffer)) => {
                assert_eq!(
                    n, ASYNC_TEST_PACKET_SIZE,
                    "Received incorrect number of bytes"
                );
                assert_eq!(
                    &buffer[..n],
                    payload_to_send.as_slice(),
                    "Received payload does not match sent payload"
                );
                println!("Tokio async pipe test: Successfully sent and received packet.");
            }
            Err(e) => {
                panic!("Receiving packet failed: {}", e);
            }
        }
    }
}

#[cfg(not(all(unix, feature = "sys")))]
mod fallback_tests {
    use netmap_rs::prelude::*; // Ensure Frame can be found for example
    #[test]
    fn test_fallback_mode() {
        // this just confirms the tests compile in fallback mode
        // let _frame = Frame::new_borrowed(&[]); // Example of using a type to check compilation
        assert!(true);
    }
}