pub mod active;

pub mod dead;

pub mod iterator;

pub mod offline;

use std::{

    any::Any,

    convert::TryInto,

    ffi::CString,

    fmt, mem,

    panic::{catch_unwind, resume_unwind, AssertUnwindSafe},

    path::Path,

    ptr::{self, NonNull},

    slice,

    sync::{Arc, Weak},

};

#[cfg(not(windows))]

use std::os::unix::io::RawFd;

use crate::{

    capture::{Activated, Capture, PcapHandle},

    codec::PacketCodec,

    linktype::Linktype,

    packet::{Packet, PacketHeader},

    raw, Error,

};

use iterator::PacketIter;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

/// Packet statistics for a capture

pub struct Stat {

    /// Number of packets received

    pub received: u32,

    /// Number of packets dropped because there was no room in the operating system's buffer when

    /// they arrived, because packets weren't being read fast enough

    pub dropped: u32,

    /// Number of packets dropped by the network interface or its driver

    pub if_dropped: u32,

}

impl Stat {

}

#[repr(u32)]

#[derive(Debug, PartialEq, Eq, Clone, Copy)]

/// The direction of packets to be captured. Use with `Capture::direction`.

pub enum Direction {

    /// Capture packets received by or sent by the device. This is the default.

    InOut = raw::PCAP_D_INOUT,

    /// Only capture packets received by the device.

    In = raw::PCAP_D_IN,

    /// Only capture packets sent by the device.

    Out = raw::PCAP_D_OUT,

}

///# Activated captures include `Capture<Active>` and `Capture<Offline>`.

impl<T: Activated + ?Sized> Capture<T> {

    /// List the datalink types that this captured device supports.

        unsafe {

                )

        }

    /// Set the datalink type for the current capture handle.

    /// Get the current datalink type for this capture handle.

    /// Create a `Savefile` context for recording captured packets using this `Capture`'s

    /// configurations.

        });

    /// Create a `Savefile` context for recording captured packets using this `Capture`'s

    /// configurations. The output is written to a raw file descriptor which is opened in `"w"`

    /// mode.

    ///

    /// # Safety

    ///

    /// Unsafe, because the returned Savefile assumes it is the sole owner of the file descriptor.

    #[cfg(not(windows))]

            ));

    /// Reopen a `Savefile` context for recording captured packets using this `Capture`'s

    /// configurations. This is similar to `savefile()` but does not create the file if it

    /// does  not exist and, if it does already exist, and is a pcap file with the same

    /// byte order as the host opening the file, and has the same time stamp precision,

    /// link-layer header type,  and  snapshot length as p, it will write new packets

    /// at the end of the file.

    #[cfg(libpcap_1_7_2)]

        });

    /// Set the direction of the capture

        })

    /// Blocks until a packet is returned from the capture handle or an error occurs.

    ///

    /// pcap captures packets and places them into a buffer which this function reads

    /// from.

    ///

    /// # Warning

    ///

    /// This buffer has a finite length, so if the buffer fills completely new

    /// packets will be discarded temporarily. This means that in realtime situations,

    /// you probably want to minimize the time between calls to next_packet() method.

    /// In high traffic situations, consider [`Self::dispatch()`] instead, which

    /// processes a whole batch of packets per call.

        unsafe {

                    // packet was read without issue

                }

                0 => {

                    // packets are being read from a live capture and the

                    // timeout expired

                }

                -1 => {

                    // an error occured while reading the packet

                }

                -2 => {

                    // packets are being read from a "savefile" and there are no

                    // more packets to read

                }

                // GRCOV_EXCL_START

                _ => {

                    // libpcap only defines codes >=1, 0, -1, and -2

                    unreachable!()

                } // GRCOV_EXCL_STOP

            }

        }

    /// Return an iterator that call [`Self::next_packet()`] forever. Require a [`PacketCodec`]

    {

            // Actually passing 0 down to pcap_loop would mean read forever.

            // We interpret it as "read nothing", so we just succeed immediately.

        };

            )

        };

    /// Process a batch of packets from the capture using `pcap_dispatch`.

    ///

    /// Unlike [`Self::next_packet()`], which performs a system call for every packet, this

    /// processes a whole buffer of packets in a single call, making packet loss less likely

    /// in high traffic situations. Packets are still dropped when the buffer fills up between

    /// calls, so a busy interface also wants a larger [`Capture::buffer_size()`].

    ///

    /// At most `count` packets are processed. `None` processes all the packets received in

    /// one buffer when reading a live capture, or all the packets in the file when reading

    /// a savefile.

    ///

    /// Unlike [`Self::for_each()`], this does not block until `count` packets have been

    /// processed: it returns the number of packets processed as soon as one buffer has been

    /// handled, which may be zero if there are no more packets to read. Note that on most

    /// platforms the read timeout only starts once the first packet arrives, so a quiet live

    /// capture can block instead of returning zero.

    {

            // What passing 0 down to pcap_dispatch means depends on the libpcap version.

            // We interpret it as "read nothing", so we just succeed immediately.

        };

            )

        };

        // A successful pcap_dispatch returns the number of packets processed, not 0 like

        // pcap_loop.

    /// Returns a thread-safe `BreakLoop` handle for calling pcap_breakloop() on an active capture.

    ///

    /// # Example

    ///

    /// ```no_run

    /// // Using an active capture

    /// use pcap::Device;

    ///

    /// let mut cap = Device::lookup().unwrap().unwrap().open().unwrap();

    ///

    /// let break_handle = cap.breakloop_handle();

    ///

    /// let capture_thread = std::thread::spawn(move || {

    ///     while let Ok(packet) = cap.next_packet() {

    ///         println!("received packet! {:?}", packet);

    ///     }

    /// });

    ///

    /// // Send break_handle to a separate thread (e.g. user input, signal handler, etc.)

    /// std::thread::spawn(move || {

    ///     std::thread::sleep(std::time::Duration::from_secs(1));

    ///     break_handle.breakloop();

    /// });

    ///

    /// capture_thread.join().unwrap();

    /// ```

    /// Compiles the string into a filter program using `pcap_compile`.

        unsafe {

                0,

            );

        }

    /// Sets the filter on the capture using the given BPF program string. Internally this is

    /// compiled using `pcap_compile()`. `optimize` controls whether optimization on the resulting

    /// code is performed

    ///

    /// See <http://biot.com/capstats/bpf.html> for more information about this syntax.

    /// Get capture statistics about this capture. The values represent packet statistics from the

    /// start of the run to the time of the call.

    ///

    /// See <https://www.tcpdump.org/manpages/pcap_stats.3pcap.html> for per-platform caveats about

    /// how packet statistics are calculated.

        unsafe {

        }

}

// Handler and its associated function let us create an extern "C" fn which dispatches to a normal

// Rust FnMut, which may be a closure with a captured environment. The *only* purpose of this

// generic parameter is to ensure that in Capture::pcap_loop that we pass the right function

// pointer and the right data pointer to pcap_loop.

struct HandlerFn<F> {

    func: F,

    panic_payload: Option<Box<dyn Any + Send>>,

    handle: Arc<PcapHandle>,

}

impl<F> HandlerFn<F>

where

    F: FnMut(Packet),

{

        unsafe {

            );

            // If our handler function panics, we need to prevent it from unwinding across the

            // FFI boundary. If the handler panics we catch the unwind here, break out of

            // pcap_loop, and resume the unwind outside.

        }

}

impl<T: Activated> From<Capture<T>> for Capture<dyn Activated> {

}

/// BreakLoop can safely be sent to other threads such as signal handlers to abort

/// blocking capture loops such as `Capture::next_packet` and `Capture::for_each`.

///

/// See <https://www.tcpdump.org/manpages/pcap_breakloop.3pcap.html> for per-platform caveats about

/// how breakloop can wake up blocked threads.

pub struct BreakLoop {

    handle: Weak<PcapHandle>,

}

unsafe impl Send for BreakLoop {}

unsafe impl Sync for BreakLoop {}

impl BreakLoop {

    /// Calls `pcap_breakloop` to make the blocking loop of a pcap capture return.

    /// The call is a no-op if the handle is invalid.

    ///

    /// # Safety

    ///

    /// Can be called from any thread, but **must not** be used inside a

    /// signal handler unless the owning `Capture` is guaranteed to still

    /// be alive.

    ///

    /// The signal handler should defer the execution of `BreakLoop::breakloop()`

    /// to a thread instead for safety.

}

/// Abstraction for writing pcap savefiles, which can be read afterwards via `Capture::from_file()`.

pub struct Savefile {

    handle: NonNull<raw::pcap_dumper_t>,

}

// Just like a Capture, a Savefile is safe to Send as it encapsulates the entire lifetime of

// `raw::pcap_dumper_t *`, but it is not safe to Sync as libpcap does not promise thread-safe access

// to the same `raw::pcap_dumper_t *` from multiple threads.

unsafe impl Send for Savefile {}

impl Savefile {

    /// Write a packet to a capture file

    /// Flushes all the packets that haven't been written to the savefile

}

impl From<NonNull<raw::pcap_dumper_t>> for Savefile {

}

impl Drop for Savefile {

}

#[repr(transparent)]

pub struct BpfInstruction(raw::bpf_insn);

#[repr(transparent)]

pub struct BpfProgram(raw::bpf_program);

impl BpfProgram {

    /// checks whether a filter matches a packet

        unsafe {

        }

}

impl Drop for BpfProgram {

}

impl fmt::Display for BpfInstruction {

            "{} {} {} {}",

            self.0.code, self.0.jt, self.0.jf, self.0.k

        )

}

unsafe impl Send for BpfProgram {}

#[cfg(not(windows))]

/// Open a raw file descriptor.

///

/// # Safety

///

/// Unsafe, because the returned FILE assumes it is the sole owner of the file descriptor.

// GRCOV_EXCL_START

#[cfg(test)]

mod testmod {

    use super::*;

    pub static TS: libc::timeval = libc::timeval {

        tv_sec: 5,

        tv_usec: 50,

    };

    pub static LEN: u32 = DATA.len() as u32;

    pub static CAPLEN: u32 = LEN;

    pub static mut PKTHDR: raw::pcap_pkthdr = raw::pcap_pkthdr {

        ts: TS,

        caplen: CAPLEN,

        len: LEN,

    };

    pub static PACKET_HEADER: PacketHeader = PacketHeader {

        ts: TS,

        caplen: CAPLEN,

        len: LEN,

    };

    pub static DATA: [u8; 4] = [4, 5, 6, 7];

    pub static PACKET: Packet = Packet {

        header: &PACKET_HEADER,

        data: &DATA,

    };

    pub struct NextExContext(raw::__pcap_next_ex::Context);

    pub fn next_ex_expect(pcap: *mut raw::pcap_t) -> NextExContext {

        let data_ptr: *const libc::c_uchar = DATA.as_ptr();

        #[allow(unused_unsafe)] // unsafe still needed to compile on MSRV

        let pkthdr_ptr: *mut raw::pcap_pkthdr = unsafe { std::ptr::addr_of_mut!(PKTHDR) };

        let ctx = raw::pcap_next_ex_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap)

            .return_once_st(move |_, arg2, arg3| {

                unsafe {

                    *arg2 = pkthdr_ptr;

                    *arg3 = data_ptr;

                }

                CAPLEN as i32

            });

        NextExContext(ctx)

    }

}

// GRCOV_EXCL_STOP

#[cfg(test)]

mod tests {

    use crate::{

        capture::{

            activated::testmod::{next_ex_expect, PACKET},

            testmod::test_capture,

            Active, Capture, Offline,

        },

        raw::testmod::{as_pcap_dumper_t, as_pcap_t, geterr_expect, RAWMTX},

    };

    use super::*;

    #[test]

    fn test_list_datalinks() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_list_datalinks_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once_st(|_, _| 0);

        let ctx = raw::pcap_free_datalinks_context();

        ctx.expect().return_once(|_| {});

        let _err = geterr_expect(pcap);

        let result = capture.list_datalinks();

        assert!(result.is_err());

        let mut datalinks: [i32; 4] = [0, 1, 2, 3];

        let links: *mut i32 = datalinks.as_mut_ptr();

        let len = datalinks.len();

        let ctx = raw::pcap_list_datalinks_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once_st(move |_, arg2| {

                unsafe { *arg2 = links };

                len as i32

            });

        let ctx = raw::pcap_free_datalinks_context();

        ctx.checkpoint();

        ctx.expect().return_once(|_| {});

        let pcap_datalinks = capture.list_datalinks().unwrap();

        assert_eq!(

            pcap_datalinks,

            datalinks.iter().cloned().map(Linktype).collect::<Vec<_>>()

        );

    }

    #[test]

    fn test_set_datalink() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_set_datalink_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let result = capture.set_datalink(Linktype::ETHERNET);

        assert!(result.is_ok());

        let ctx = raw::pcap_set_datalink_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| -1);

        let _err = geterr_expect(pcap);

        let result = capture.set_datalink(Linktype::ETHERNET);

        assert!(result.is_err());

    }

    #[test]

    fn test_get_datalink() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_datalink_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap)

            .return_once(|_| 1);

        let linktype = capture.get_datalink();

        assert_eq!(linktype, Linktype::ETHERNET);

    }

    #[test]

    fn unify_activated() {

        #![allow(dead_code)]

        fn test1() -> Capture<Active> {

            panic!();

        }

        fn test2() -> Capture<Offline> {

            panic!();

        }

        fn maybe(a: bool) -> Capture<dyn Activated> {

            if a {

                test1().into()

            } else {

                test2().into()

            }

        }

        fn also_maybe(a: &mut Capture<dyn Activated>) {

            a.filter("whatever filter string, this won't be run anyway", false)

                .unwrap();

        }

    }

    #[test]

    fn test_breakloop_capture_dropped() {

        let _m = RAWMTX.lock();

        let mut value: isize = 1234;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_breakloop_context();

        ctx.expect()

            .withf_st(move |h| *h == pcap)

            .return_const(())

            .times(1);

        let break_handle = capture.breakloop_handle();

        break_handle.breakloop();

        drop(capture);

        break_handle.breakloop(); // this call does not trigger mock after drop

    }

    #[test]

    fn test_savefile() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let mut value: isize = 888;

        let pcap_dumper = as_pcap_dumper_t(&mut value);

        let test_capture = test_capture::<Offline>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_dump_open_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once_st(move |_, _| pcap_dumper);

        let ctx = raw::pcap_dump_close_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| {});

        let result = capture.savefile("path/to/nowhere");

        assert!(result.is_ok());

    }

    #[test]

    #[cfg(libpcap_1_7_2)]

    fn test_savefile_append() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let mut value: isize = 888;

        let pcap_dumper = as_pcap_dumper_t(&mut value);

        let test_capture = test_capture::<Offline>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_dump_open_append_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once_st(move |_, _| pcap_dumper);

        let ctx = raw::pcap_dump_close_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| {});

        let result = capture.savefile_append("path/to/nowhere");

        assert!(result.is_ok());

    }

    #[test]

    fn test_savefile_error() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Offline>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_dump_open_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| std::ptr::null_mut());

        let _err = geterr_expect(pcap);

        let result = capture.savefile("path/to/nowhere");

        assert!(result.is_err());

    }

    #[test]

    #[cfg(libpcap_1_7_2)]

    fn test_savefile_append_error() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Offline>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_dump_open_append_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| std::ptr::null_mut());

        let _err = geterr_expect(pcap);

        let result = capture.savefile_append("path/to/nowhere");

        assert!(result.is_err());

    }

    #[test]

    fn test_savefile_ops() {

        let _m = RAWMTX.lock();

        let mut value: isize = 888;

        let pcap_dumper = as_pcap_dumper_t(&mut value);

        let ctx = raw::pcap_dump_close_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| {});

        let mut savefile = Savefile {

            handle: NonNull::new(pcap_dumper).unwrap(),

        };

        let ctx = raw::pcap_dump_context();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap_dumper as _)

            .return_once(|_, _, _| {});

        savefile.write(&PACKET);

        let ctx = raw::pcap_dump_flush_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| 0);

        let result = savefile.flush();

        assert!(result.is_ok());

        let ctx = raw::pcap_dump_flush_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| -1);

        let result = savefile.flush();

        assert!(result.is_err());

    }

    #[test]

    fn test_direction() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_setdirection_context();

        ctx.expect()

            .withf_st(move |arg1, arg2| (*arg1 == pcap) && (*arg2 == raw::PCAP_D_OUT))

            .return_once(|_, _| 0);

        let result = capture.direction(Direction::Out);

        assert!(result.is_ok());

        let ctx = raw::pcap_setdirection_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, arg2| (*arg1 == pcap) && (*arg2 == raw::PCAP_D_OUT))

            .return_once(|_, _| -1);

        let _err = geterr_expect(pcap);

        let result = capture.direction(Direction::Out);

        assert!(result.is_err());

        // For code coverage of the derive line.

        assert_ne!(Direction::In, Direction::InOut);

        assert_ne!(Direction::In, Direction::Out);

        assert_ne!(Direction::InOut, Direction::Out);

    }

    #[test]

    fn test_next_packet() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let _nxt = next_ex_expect(pcap);

        let next_packet = capture.next_packet().unwrap();

        assert_eq!(next_packet, PACKET);

    }

    #[test]

    fn test_next_packet_timeout() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let ctx = raw::pcap_next_ex_context();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap)

            .return_once_st(move |_, _, _| 0);

        let err = capture.next_packet().unwrap_err();

        assert_eq!(err, Error::TimeoutExpired);

    }

    #[test]

    fn test_next_packet_read_error() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let ctx = raw::pcap_next_ex_context();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap)

            .return_once_st(move |_, _, _| -1);

        let _err = geterr_expect(pcap);

        let result = capture.next_packet();

        assert!(result.is_err());

    }

    #[test]

    fn test_next_packet_no_more_packets() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Offline>(pcap);

        let mut capture = test_capture.capture;

        let ctx = raw::pcap_next_ex_context();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap)

            .return_once_st(move |_, _, _| -2);

        let err = capture.next_packet().unwrap_err();

        assert_eq!(err, Error::NoMorePackets);

    }

    #[test]

    fn test_compile() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_compile_context();

        ctx.expect()

            .withf_st(move |arg1, _, _, _, _| *arg1 == pcap)

            .return_once(|_, _, _, _, _| -1);

        let _err = geterr_expect(pcap);

        let ctx = raw::pcap_freecode_context();

        ctx.expect().return_once(|_| {});

        let result = capture.compile("some bpf program", false);

        assert!(result.is_err());

        let ctx = raw::pcap_compile_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _, _, _, _| *arg1 == pcap)

            .return_once(|_, _, _, _, _| 0);

        let ctx = raw::pcap_freecode_context();

        ctx.checkpoint();

        ctx.expect().return_once(|_| {});

        let result = capture.compile("some bpf program", false);

        assert!(result.is_ok());

    }

    #[test]

    fn test_filter() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let ctx = raw::pcap_compile_context();

        ctx.expect()

            .withf_st(move |arg1, _, _, _, _| *arg1 == pcap)

            .return_once(|_, _, _, _, _| 0);

        let ctx = raw::pcap_setfilter_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| -1);

        let _err = geterr_expect(pcap);

        let ctx = raw::pcap_freecode_context();

        ctx.expect().return_once(|_| {});

        let result = capture.filter("some bpf program", false);

        assert!(result.is_err());

        let ctx = raw::pcap_compile_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _, _, _, _| *arg1 == pcap)

            .return_once(|_, _, _, _, _| 0);

        let ctx = raw::pcap_setfilter_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let ctx = raw::pcap_freecode_context();

        ctx.checkpoint();

        ctx.expect().return_once(|_| {});

        let result = capture.compile("some bpf program", false);

        assert!(result.is_ok());

    }

    #[test]

    fn test_stats() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let stat = raw::pcap_stat {

            ps_recv: 1,

            ps_drop: 2,

            ps_ifdrop: 3,

        };

        let ctx = raw::pcap_stats_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once_st(move |_, arg2| {

                unsafe { *arg2 = stat };

                0

            });

        let stats = capture.stats().unwrap();

        assert_eq!(stats, Stat::new(stat.ps_recv, stat.ps_drop, stat.ps_ifdrop));

        let ctx = raw::pcap_stats_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once_st(move |_, _| -1);

        let _err = geterr_expect(pcap);

        let result = capture.stats();

        assert!(result.is_err());

    }

    #[test]

    fn test_bpf_instruction_display() {

        let instr = BpfInstruction(raw::bpf_insn {

            code: 1,

            jt: 2,

            jf: 3,

            k: 4,

        });

        assert_eq!(format!("{instr}"), "1 2 3 4");

    }

    #[test]

    fn read_packet_via_pcap_loop() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_loop_context();

        ctx.expect()

            .withf_st(move |arg1, cnt, _, _| *arg1 == pcap && *cnt == -1)

            .return_once_st(move |_, _, func, data| {

                let header = raw::pcap_pkthdr {

                    ts: libc::timeval {

                        tv_sec: 0,

                        tv_usec: 0,

                    },

                    caplen: 0,

                    len: 0,

                };

                let packet_data = &[];

                func(data, &header, packet_data.as_ptr());

                0

            });

        let mut packets = 0;

        capture

            .for_each(None, |_| {

                packets += 1;

            })

            .unwrap();

        assert_eq!(packets, 1);

    }

    #[test]

    #[should_panic = "panic in callback"]

    fn panic_in_pcap_loop() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_loop_context();

        ctx.expect()

            .withf_st(move |arg1, cnt, _, _| *arg1 == pcap && *cnt == -1)

            .return_once_st(move |_, _, func, data| {

                let header = raw::pcap_pkthdr {

                    ts: libc::timeval {

                        tv_sec: 0,

                        tv_usec: 0,

                    },

                    caplen: 0,

                    len: 0,

                };

                let packet_data = &[];

                func(data, &header, packet_data.as_ptr());

                0

            });

        let ctx = raw::pcap_breakloop_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap)

            .return_once_st(move |_| {});

        capture

            .for_each(None, |_| panic!("panic in callback"))

            .unwrap();

    }

    #[test]

    fn for_each_with_count() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_loop_context();

        ctx.expect()

            .withf_st(move |arg1, cnt, _, _| *arg1 == pcap && *cnt == 2)

            .return_once_st(move |_, _, func, data| {

                let header = raw::pcap_pkthdr {

                    ts: libc::timeval {

                        tv_sec: 0,

                        tv_usec: 0,

                    },

                    caplen: 0,

                    len: 0,

                };

                let packet_data = &[];

                func(data, &header, packet_data.as_ptr());

                func(data, &header, packet_data.as_ptr());

                0

            });

        let mut packets = 0;

        capture

            .for_each(Some(2), |_| {

                packets += 1;

            })

            .unwrap();

        assert_eq!(packets, 2);

    }

    #[test]

    fn for_each_with_count_0() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture: Capture<dyn Activated> = test_capture.capture.into();

        let mut packets = 0;

        capture

            .for_each(Some(0), |_| {

                packets += 1;

            })

            .unwrap();

        assert_eq!(packets, 0);

    }

    #[test]

    fn read_packets_via_pcap_dispatch() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_dispatch_context();

        ctx.expect()

            .withf_st(move |arg1, cnt, _, _| *arg1 == pcap && *cnt == -1)

            .return_once_st(move |_, _, func, data| {

                let header = raw::pcap_pkthdr {

                    ts: libc::timeval {

                        tv_sec: 0,

                        tv_usec: 0,

                    },

                    caplen: 0,

                    len: 0,

                };

                let packet_data = &[];

                func(data, &header, packet_data.as_ptr());

                func(data, &header, packet_data.as_ptr());

                2

            });

        let mut packets = 0;

        let processed = capture

            .dispatch(None, |_| {

                packets += 1;

            })

            .unwrap();

        assert_eq!(packets, 2);

        assert_eq!(processed, 2);

    }

    #[test]

    #[should_panic = "panic in callback"]

    fn panic_in_pcap_dispatch() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_dispatch_context();

        ctx.expect()

            .withf_st(move |arg1, cnt, _, _| *arg1 == pcap && *cnt == -1)

            .return_once_st(move |_, _, func, data| {

                let header = raw::pcap_pkthdr {

                    ts: libc::timeval {

                        tv_sec: 0,

                        tv_usec: 0,

                    },

                    caplen: 0,

                    len: 0,