diff --git a/src/capture/activated/active.rs b/src/capture/activated/active.rs index ede87a6e..a1916250 100644 --- a/src/capture/activated/active.rs +++ b/src/capture/activated/active.rs @@ -40,106 +40,106 @@ impl AsRawFd for Capture { } } -#[cfg(test)] -mod tests { - use crate::{ - capture::testmod::test_capture, - raw::{ - mock_ffi::*, - testmod::{as_pcap_t, geterr_expect, RAWMTX}, - }, - }; +// #[cfg(test)] +// mod tests { +// use crate::{ +// capture::testmod::test_capture, +// raw::{ +// mock_ffi::*, +// testmod::{as_pcap_t, geterr_expect, RAWMTX}, +// }, +// }; - use super::*; +// use super::*; - #[test] - fn test_sendpacket() { - let _m = RAWMTX.lock(); +// #[test] +// fn test_sendpacket() { +// let _m = RAWMTX.lock(); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let buffer: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; +// let buffer: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; - let test_capture = test_capture::(pcap); - let mut capture = test_capture.capture; +// let test_capture = test_capture::(pcap); +// let mut capture = test_capture.capture; - let ctx = pcap_sendpacket_context(); - ctx.expect() - .withf_st(move |arg1, _, _| *arg1 == pcap) - .return_once(|_, _, _| 0); +// let ctx = pcap_sendpacket_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap) +// .return_once(|_, _, _| 0); - let result = capture.sendpacket(buffer); - assert!(result.is_ok()); +// let result = capture.sendpacket(buffer); +// assert!(result.is_ok()); - let ctx = pcap_sendpacket_context(); - ctx.checkpoint(); - ctx.expect() - .withf_st(move |arg1, _, _| *arg1 == pcap) - .return_once(|_, _, _| -1); +// let ctx = pcap_sendpacket_context(); +// ctx.checkpoint(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap) +// .return_once(|_, _, _| -1); - let _err = geterr_expect(pcap); +// let _err = geterr_expect(pcap); - let result = capture.sendpacket(buffer); - assert!(result.is_err()); - } +// let result = capture.sendpacket(buffer); +// assert!(result.is_err()); +// } - #[test] - fn test_setnonblock() { - let _m = RAWMTX.lock(); +// #[test] +// fn test_setnonblock() { +// let _m = RAWMTX.lock(); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - assert!(!capture.is_nonblock()); +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; +// assert!(!capture.is_nonblock()); - let ctx = pcap_setnonblock_context(); - ctx.expect() - .withf_st(move |arg1, arg2, _| (*arg1 == pcap) && (*arg2 == 1)) - .return_once(|_, _, _| 0); +// let ctx = pcap_setnonblock_context(); +// ctx.expect() +// .withf_st(move |arg1, arg2, _| (*arg1 == pcap) && (*arg2 == 1)) +// .return_once(|_, _, _| 0); - let capture = capture.setnonblock().unwrap(); - assert!(capture.is_nonblock()); - } +// let capture = capture.setnonblock().unwrap(); +// assert!(capture.is_nonblock()); +// } - #[test] - fn test_setnonblock_error() { - let _m = RAWMTX.lock(); +// #[test] +// fn test_setnonblock_error() { +// let _m = RAWMTX.lock(); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - assert!(!capture.nonblock); +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; +// assert!(!capture.nonblock); - let ctx = pcap_setnonblock_context(); - ctx.expect() - .withf_st(move |arg1, arg2, _| (*arg1 == pcap) && (*arg2 == 1)) - .return_once(|_, _, _| -1); +// let ctx = pcap_setnonblock_context(); +// ctx.expect() +// .withf_st(move |arg1, arg2, _| (*arg1 == pcap) && (*arg2 == 1)) +// .return_once(|_, _, _| -1); - let result = capture.setnonblock(); - assert!(result.is_err()); - } +// let result = capture.setnonblock(); +// assert!(result.is_err()); +// } - #[test] - #[cfg(not(windows))] - fn test_as_raw_fd() { - let _m = RAWMTX.lock(); +// #[test] +// #[cfg(not(windows))] +// fn test_as_raw_fd() { +// let _m = RAWMTX.lock(); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - let ctx = pcap_fileno_context(); - ctx.expect() - .withf_st(move |arg1| *arg1 == pcap) - .return_once(|_| 7); +// let ctx = pcap_fileno_context(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap) +// .return_once(|_| 7); - assert_eq!(capture.as_raw_fd(), 7); - } -} +// assert_eq!(capture.as_raw_fd(), 7); +// } +// } diff --git a/src/capture/activated/dead.rs b/src/capture/activated/dead.rs index 5efbbf06..477b8d90 100644 --- a/src/capture/activated/dead.rs +++ b/src/capture/activated/dead.rs @@ -33,53 +33,53 @@ impl Capture { } } -#[cfg(test)] -mod tests { - #[cfg(libpcap_1_5_0)] - use mockall::predicate; +// #[cfg(test)] +// mod tests { +// #[cfg(libpcap_1_5_0)] +// use mockall::predicate; - use crate::raw::testmod::{as_pcap_t, RAWMTX}; +// use crate::raw::testmod::{as_pcap_t, RAWMTX}; - use super::*; +// use super::*; - #[test] - fn test_dead() { - let _m = RAWMTX.lock(); +// #[test] +// fn test_dead() { +// let _m = RAWMTX.lock(); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let ctx = raw::pcap_open_dead_context(); - ctx.expect().return_once_st(move |_, _| pcap); +// let ctx = raw::pcap_open_dead_context(); +// ctx.expect().return_once_st(move |_, _| pcap); - let ctx = raw::pcap_close_context(); - ctx.expect() - .withf_st(move |ptr| *ptr == pcap) - .return_once(|_| {}); +// let ctx = raw::pcap_close_context(); +// ctx.expect() +// .withf_st(move |ptr| *ptr == pcap) +// .return_once(|_| {}); - let result = Capture::dead(Linktype::ETHERNET); - assert!(result.is_ok()); - } +// let result = Capture::dead(Linktype::ETHERNET); +// assert!(result.is_ok()); +// } - #[test] - #[cfg(libpcap_1_5_0)] - fn test_dead_with_precision() { - let _m = RAWMTX.lock(); +// #[test] +// #[cfg(libpcap_1_5_0)] +// fn test_dead_with_precision() { +// let _m = RAWMTX.lock(); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let ctx = raw::pcap_open_dead_with_tstamp_precision_context(); - ctx.expect() - .with(predicate::always(), predicate::always(), predicate::eq(1)) - .return_once_st(move |_, _, _| pcap); +// let ctx = raw::pcap_open_dead_with_tstamp_precision_context(); +// ctx.expect() +// .with(predicate::always(), predicate::always(), predicate::eq(1)) +// .return_once_st(move |_, _, _| pcap); - let ctx = raw::pcap_close_context(); - ctx.expect() - .withf_st(move |ptr| *ptr == pcap) - .return_once(|_| {}); +// let ctx = raw::pcap_close_context(); +// ctx.expect() +// .withf_st(move |ptr| *ptr == pcap) +// .return_once(|_| {}); - let result = Capture::dead_with_precision(Linktype::ETHERNET, Precision::Nano); - assert!(result.is_ok()); - } -} +// let result = Capture::dead_with_precision(Linktype::ETHERNET, Precision::Nano); +// assert!(result.is_ok()); +// } +// } diff --git a/src/capture/activated/iterator.rs b/src/capture/activated/iterator.rs index f7a5080f..33b50347 100644 --- a/src/capture/activated/iterator.rs +++ b/src/capture/activated/iterator.rs @@ -72,208 +72,208 @@ mod lending_iter { } } -#[cfg(test)] -mod tests { - use crate::{ - capture::{ - activated::testmod::{next_ex_expect, PACKET}, - testmod::test_capture, - Active, Offline, - }, - codec::testmod::Codec, - raw::{ - self, - testmod::{as_pcap_t, geterr_expect, RAWMTX}, - }, - }; - - #[cfg(feature = "lending-iter")] - use gat_std::iter::{IntoIterator, Iterator}; +// #[cfg(test)] +// mod tests { +// use crate::{ +// capture::{ +// activated::testmod::{next_ex_expect, PACKET}, +// testmod::test_capture, +// Active, Offline, +// }, +// codec::testmod::Codec, +// raw::{ +// self, +// testmod::{as_pcap_t, geterr_expect, RAWMTX}, +// }, +// }; - use super::*; +// #[cfg(feature = "lending-iter")] +// use gat_std::iter::{IntoIterator, Iterator}; - #[cfg(feature = "lending-iter")] - use super::lending_iter::*; +// use super::*; - #[test] - fn test_iter_next() { - let _m = RAWMTX.lock(); +// #[cfg(feature = "lending-iter")] +// use super::lending_iter::*; - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// #[test] +// fn test_iter_next() { +// let _m = RAWMTX.lock(); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - let mut packet_iter = capture.iter(Codec); +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let _nxt = next_ex_expect(pcap); +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; +// let mut packet_iter = capture.iter(Codec); - let next = packet_iter.next().unwrap(); - let next_packet = next.unwrap(); - assert_eq!(next_packet.header, *PACKET.header); - assert_eq!(*next_packet.data, *PACKET.data); +// let _nxt = next_ex_expect(pcap); - let _nxt = next_ex_expect(pcap); +// let next = packet_iter.next().unwrap(); +// let next_packet = next.unwrap(); +// assert_eq!(next_packet.header, *PACKET.header); +// assert_eq!(*next_packet.data, *PACKET.data); - let next_packet = packet_iter.capture_mut().next_packet().unwrap(); - assert_eq!(next_packet, PACKET); +// let _nxt = next_ex_expect(pcap); - let _nxt = next_ex_expect(pcap); +// let next_packet = packet_iter.capture_mut().next_packet().unwrap(); +// assert_eq!(next_packet, PACKET); - let (mut capture, _) = packet_iter.into(); +// let _nxt = next_ex_expect(pcap); - let next_packet = capture.next_packet().unwrap(); - assert_eq!(next_packet, PACKET); - } +// let (mut capture, _) = packet_iter.into(); - #[test] - fn test_iter_timeout() { - let _m = RAWMTX.lock(); +// let next_packet = capture.next_packet().unwrap(); +// assert_eq!(next_packet, PACKET); +// } - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// #[test] +// fn test_iter_timeout() { +// let _m = RAWMTX.lock(); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let mut packet_iter = capture.iter(Codec); +// let test_capture = test_capture::(pcap); +// let 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 mut packet_iter = capture.iter(Codec); - let next = packet_iter.next().unwrap(); - let err = next.unwrap_err(); - assert_eq!(err, Error::TimeoutExpired); - } +// let ctx = raw::pcap_next_ex_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap) +// .return_once_st(move |_, _, _| 0); - #[test] - fn test_next_packet_read_error() { - let _m = RAWMTX.lock(); +// let next = packet_iter.next().unwrap(); +// let err = next.unwrap_err(); +// assert_eq!(err, Error::TimeoutExpired); +// } - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// #[test] +// fn test_next_packet_read_error() { +// let _m = RAWMTX.lock(); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let mut packet_iter = capture.iter(Codec); +// let test_capture = test_capture::(pcap); +// let 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 mut packet_iter = capture.iter(Codec); - let _err = geterr_expect(pcap); +// let ctx = raw::pcap_next_ex_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap) +// .return_once_st(move |_, _, _| -1); - let next = packet_iter.next().unwrap(); - assert!(next.is_err()); - } +// let _err = geterr_expect(pcap); - #[test] - fn test_next_packet_no_more_packets() { - let _m = RAWMTX.lock(); +// let next = packet_iter.next().unwrap(); +// assert!(next.is_err()); +// } - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// #[test] +// fn test_next_packet_no_more_packets() { +// let _m = RAWMTX.lock(); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let mut packet_iter = capture.iter(Codec); +// let test_capture = test_capture::(pcap); +// let 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 mut packet_iter = capture.iter(Codec); - let next = packet_iter.next(); - assert!(next.is_none()); - } +// let ctx = raw::pcap_next_ex_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap) +// .return_once_st(move |_, _, _| -2); - #[test] - #[cfg(feature = "lending-iter")] - fn test_lending_iter() { - let _m = RAWMTX.lock(); +// let next = packet_iter.next(); +// assert!(next.is_none()); +// } - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// #[test] +// #[cfg(feature = "lending-iter")] +// fn test_lending_iter() { +// let _m = RAWMTX.lock(); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - let mut packet_iter: PacketLendingIter = capture.into_iter(); +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let _nxt = next_ex_expect(pcap); +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; +// let mut packet_iter: PacketLendingIter = capture.into_iter(); - let next = packet_iter.next().unwrap(); - let next_packet = next.unwrap(); - assert_eq!(next_packet, PACKET); - } +// let _nxt = next_ex_expect(pcap); - #[test] - #[cfg(feature = "lending-iter")] - fn test_lending_iter_timeout() { - let _m = RAWMTX.lock(); +// let next = packet_iter.next().unwrap(); +// let next_packet = next.unwrap(); +// assert_eq!(next_packet, PACKET); +// } - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// #[test] +// #[cfg(feature = "lending-iter")] +// fn test_lending_iter_timeout() { +// let _m = RAWMTX.lock(); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - let mut packet_iter: PacketLendingIter = capture.into_iter(); +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let ctx = raw::pcap_next_ex_context(); - ctx.expect() - .withf_st(move |arg1, _, _| *arg1 == pcap) - .return_once_st(move |_, _, _| 0); +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; +// let mut packet_iter: PacketLendingIter = capture.into_iter(); - let next = packet_iter.next().unwrap(); - let err = next.unwrap_err(); - assert_eq!(err, Error::TimeoutExpired); - } +// let ctx = raw::pcap_next_ex_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap) +// .return_once_st(move |_, _, _| 0); - #[test] - #[cfg(feature = "lending-iter")] - fn test_lending_iter_read_error() { - let _m = RAWMTX.lock(); +// let next = packet_iter.next().unwrap(); +// let err = next.unwrap_err(); +// assert_eq!(err, Error::TimeoutExpired); +// } - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// #[test] +// #[cfg(feature = "lending-iter")] +// fn test_lending_iter_read_error() { +// let _m = RAWMTX.lock(); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - let mut packet_iter: PacketLendingIter = capture.into_iter(); +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let ctx = raw::pcap_next_ex_context(); - ctx.expect() - .withf_st(move |arg1, _, _| *arg1 == pcap) - .return_once_st(move |_, _, _| -1); +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; +// let mut packet_iter: PacketLendingIter = capture.into_iter(); - let _err = geterr_expect(pcap); +// let ctx = raw::pcap_next_ex_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap) +// .return_once_st(move |_, _, _| -1); - let next = packet_iter.next().unwrap(); - assert!(next.is_err()); - } +// let _err = geterr_expect(pcap); - #[test] - #[cfg(feature = "lending-iter")] - fn test_lending_iter_no_more_packets() { - let _m = RAWMTX.lock(); +// let next = packet_iter.next().unwrap(); +// assert!(next.is_err()); +// } - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// #[test] +// #[cfg(feature = "lending-iter")] +// fn test_lending_iter_no_more_packets() { +// let _m = RAWMTX.lock(); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - let mut packet_iter: PacketLendingIter = capture.into_iter(); +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let ctx = raw::pcap_next_ex_context(); - ctx.expect() - .withf_st(move |arg1, _, _| *arg1 == pcap) - .return_once_st(move |_, _, _| -2); +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; +// let mut packet_iter: PacketLendingIter = capture.into_iter(); - let next = packet_iter.next(); - assert!(next.is_none()); - } -} +// let ctx = raw::pcap_next_ex_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap) +// .return_once_st(move |_, _, _| -2); + +// let next = packet_iter.next(); +// assert!(next.is_none()); +// } +// } diff --git a/src/capture/activated/mod.rs b/src/capture/activated/mod.rs index 5c51f826..3c643654 100644 --- a/src/capture/activated/mod.rs +++ b/src/capture/activated/mod.rs @@ -478,651 +478,651 @@ mod testmod { } // 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::(pcap); - let capture: Capture = 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::>() - ); - } - - #[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::(pcap); - let mut capture: Capture = 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::(pcap); - let capture: Capture = 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 { - panic!(); - } - - fn test2() -> Capture { - panic!(); - } - - fn maybe(a: bool) -> Capture { - if a { - test1().into() - } else { - test2().into() - } - } - - fn also_maybe(a: &mut Capture) { - a.filter("whatever filter string, this won't be run anyway", false) - .unwrap(); - } - } - - #[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::(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::(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::(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::(pcap); - let capture = test_capture.capture; +// #[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::(pcap); +// let capture: Capture = 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::>() +// ); +// } + +// #[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::(pcap); +// let mut capture: Capture = 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::(pcap); +// let capture: Capture = 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 { +// panic!(); +// } + +// fn test2() -> Capture { +// panic!(); +// } + +// fn maybe(a: bool) -> Capture { +// if a { +// test1().into() +// } else { +// test2().into() +// } +// } - let ctx = raw::pcap_dump_open_append_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| std::ptr::null_mut()); +// fn also_maybe(a: &mut Capture) { +// a.filter("whatever filter string, this won't be run anyway", false) +// .unwrap(); +// } +// } + +// #[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::(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 _err = geterr_expect(pcap); +// let result = capture.savefile("path/to/nowhere"); +// assert!(result.is_ok()); +// } - let result = capture.savefile_append("path/to/nowhere"); - assert!(result.is_err()); - } +// #[test] +// #[cfg(libpcap_1_7_2)] +// fn test_savefile_append() { +// let _m = RAWMTX.lock(); - #[test] - fn test_savefile_ops() { - 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 mut value: isize = 888; +// let pcap_dumper = as_pcap_dumper_t(&mut value); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - let ctx = raw::pcap_dump_close_context(); - ctx.expect() - .withf_st(move |arg1| *arg1 == pcap_dumper) - .return_once(|_| {}); +// let ctx = raw::pcap_dump_open_append_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once_st(move |_, _| pcap_dumper); - let mut savefile = Savefile { - handle: NonNull::new(pcap_dumper).unwrap(), - }; +// let ctx = raw::pcap_dump_close_context(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap_dumper) +// .return_once(|_| {}); - let ctx = raw::pcap_dump_context(); - ctx.expect() - .withf_st(move |arg1, _, _| *arg1 == pcap_dumper as _) - .return_once(|_, _, _| {}); +// let result = capture.savefile_append("path/to/nowhere"); +// assert!(result.is_ok()); +// } - savefile.write(&PACKET); +// #[test] +// fn test_savefile_error() { +// let _m = RAWMTX.lock(); - let ctx = raw::pcap_dump_flush_context(); - ctx.expect() - .withf_st(move |arg1| *arg1 == pcap_dumper) - .return_once(|_| 0); +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - let result = savefile.flush(); - assert!(result.is_ok()); +// let ctx = raw::pcap_dump_open_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| std::ptr::null_mut()); - let ctx = raw::pcap_dump_flush_context(); - ctx.checkpoint(); - ctx.expect() - .withf_st(move |arg1| *arg1 == pcap_dumper) - .return_once(|_| -1); +// 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 result = savefile.flush(); - assert!(result.is_err()); - } +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - #[test] - fn test_direction() { - let _m = RAWMTX.lock(); +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// let ctx = raw::pcap_dump_open_append_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| std::ptr::null_mut()); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let _err = geterr_expect(pcap); - 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.savefile_append("path/to/nowhere"); +// assert!(result.is_err()); +// } - let result = capture.direction(Direction::Out); - assert!(result.is_ok()); +// #[test] +// fn test_savefile_ops() { +// let _m = RAWMTX.lock(); - 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 mut value: isize = 888; +// let pcap_dumper = as_pcap_dumper_t(&mut value); - let _err = geterr_expect(pcap); +// let ctx = raw::pcap_dump_close_context(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap_dumper) +// .return_once(|_| {}); - let result = capture.direction(Direction::Out); - assert!(result.is_err()); +// let mut savefile = Savefile { +// handle: NonNull::new(pcap_dumper).unwrap(), +// }; - // 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); - } +// let ctx = raw::pcap_dump_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap_dumper as _) +// .return_once(|_, _, _| {}); - #[test] - fn test_next_packet() { - let _m = RAWMTX.lock(); +// savefile.write(&PACKET); - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// let ctx = raw::pcap_dump_flush_context(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap_dumper) +// .return_once(|_| 0); - let test_capture = test_capture::(pcap); - let mut capture = test_capture.capture; +// let result = savefile.flush(); +// assert!(result.is_ok()); - let _nxt = next_ex_expect(pcap); +// let ctx = raw::pcap_dump_flush_context(); +// ctx.checkpoint(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap_dumper) +// .return_once(|_| -1); - let next_packet = capture.next_packet().unwrap(); - assert_eq!(next_packet, PACKET); - } +// let result = savefile.flush(); +// assert!(result.is_err()); +// } - #[test] - fn test_next_packet_timeout() { - let _m = RAWMTX.lock(); +// #[test] +// fn test_direction() { +// let _m = RAWMTX.lock(); - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let test_capture = test_capture::(pcap); - let mut capture = test_capture.capture; +// let test_capture = test_capture::(pcap); +// let 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 ctx = raw::pcap_setdirection_context(); +// ctx.expect() +// .withf_st(move |arg1, arg2| (*arg1 == pcap) && (*arg2 == raw::PCAP_D_OUT)) +// .return_once(|_, _| 0); - let err = capture.next_packet().unwrap_err(); - assert_eq!(err, Error::TimeoutExpired); - } +// let result = capture.direction(Direction::Out); +// assert!(result.is_ok()); - #[test] - fn test_next_packet_read_error() { - let _m = RAWMTX.lock(); +// 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 mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// let _err = geterr_expect(pcap); - let test_capture = test_capture::(pcap); - let mut capture = test_capture.capture; +// let result = capture.direction(Direction::Out); +// assert!(result.is_err()); - let ctx = raw::pcap_next_ex_context(); - ctx.expect() - .withf_st(move |arg1, _, _| *arg1 == pcap) - .return_once_st(move |_, _, _| -1); +// // 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); +// } - let _err = geterr_expect(pcap); +// #[test] +// fn test_next_packet() { +// let _m = RAWMTX.lock(); - let result = capture.next_packet(); - assert!(result.is_err()); - } +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - #[test] - fn test_next_packet_no_more_packets() { - let _m = RAWMTX.lock(); +// let test_capture = test_capture::(pcap); +// let mut capture = test_capture.capture; - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// let _nxt = next_ex_expect(pcap); - let test_capture = test_capture::(pcap); - let mut capture = test_capture.capture; +// let next_packet = capture.next_packet().unwrap(); +// assert_eq!(next_packet, PACKET); +// } - let ctx = raw::pcap_next_ex_context(); - ctx.expect() - .withf_st(move |arg1, _, _| *arg1 == pcap) - .return_once_st(move |_, _, _| -2); +// #[test] +// fn test_next_packet_timeout() { +// let _m = RAWMTX.lock(); - let err = capture.next_packet().unwrap_err(); - assert_eq!(err, Error::NoMorePackets); - } +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - #[test] - fn test_compile() { - let _m = RAWMTX.lock(); +// let test_capture = test_capture::(pcap); +// let mut capture = test_capture.capture; - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// let ctx = raw::pcap_next_ex_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap) +// .return_once_st(move |_, _, _| 0); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let err = capture.next_packet().unwrap_err(); +// assert_eq!(err, Error::TimeoutExpired); +// } - let ctx = raw::pcap_compile_context(); - ctx.expect() - .withf_st(move |arg1, _, _, _, _| *arg1 == pcap) - .return_once(|_, _, _, _, _| -1); +// #[test] +// fn test_next_packet_read_error() { +// let _m = RAWMTX.lock(); - let _err = geterr_expect(pcap); +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let ctx = raw::pcap_freecode_context(); - ctx.expect().return_once(|_| {}); +// let test_capture = test_capture::(pcap); +// let mut capture = test_capture.capture; - let result = capture.compile("some bpf program", false); - assert!(result.is_err()); +// let ctx = raw::pcap_next_ex_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _| *arg1 == pcap) +// .return_once_st(move |_, _, _| -1); - let ctx = raw::pcap_compile_context(); - ctx.checkpoint(); - ctx.expect() - .withf_st(move |arg1, _, _, _, _| *arg1 == pcap) - .return_once(|_, _, _, _, _| 0); +// let _err = geterr_expect(pcap); - let ctx = raw::pcap_freecode_context(); - ctx.checkpoint(); - ctx.expect().return_once(|_| {}); +// let result = capture.next_packet(); +// assert!(result.is_err()); +// } - let result = capture.compile("some bpf program", false); - assert!(result.is_ok()); - } +// #[test] +// fn test_next_packet_no_more_packets() { +// let _m = RAWMTX.lock(); - #[test] - fn test_filter() { - let _m = RAWMTX.lock(); +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// let test_capture = test_capture::(pcap); +// let mut capture = test_capture.capture; - let test_capture = test_capture::(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 ctx = raw::pcap_compile_context(); - ctx.expect() - .withf_st(move |arg1, _, _, _, _| *arg1 == pcap) - .return_once(|_, _, _, _, _| 0); +// let err = capture.next_packet().unwrap_err(); +// assert_eq!(err, Error::NoMorePackets); +// } - let ctx = raw::pcap_setfilter_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| -1); +// #[test] +// fn test_compile() { +// let _m = RAWMTX.lock(); - let _err = geterr_expect(pcap); +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let ctx = raw::pcap_freecode_context(); - ctx.expect().return_once(|_| {}); +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - let result = capture.filter("some bpf program", false); - assert!(result.is_err()); +// let ctx = raw::pcap_compile_context(); +// ctx.expect() +// .withf_st(move |arg1, _, _, _, _| *arg1 == pcap) +// .return_once(|_, _, _, _, _| -1); - let ctx = raw::pcap_compile_context(); - ctx.checkpoint(); - ctx.expect() - .withf_st(move |arg1, _, _, _, _| *arg1 == pcap) - .return_once(|_, _, _, _, _| 0); +// let _err = geterr_expect(pcap); - 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.expect().return_once(|_| {}); - let ctx = raw::pcap_freecode_context(); - ctx.checkpoint(); - ctx.expect().return_once(|_| {}); +// let result = capture.compile("some bpf program", false); +// assert!(result.is_err()); - let result = capture.compile("some bpf program", false); - assert!(result.is_ok()); - } +// let ctx = raw::pcap_compile_context(); +// ctx.checkpoint(); +// ctx.expect() +// .withf_st(move |arg1, _, _, _, _| *arg1 == pcap) +// .return_once(|_, _, _, _, _| 0); - #[test] - fn test_stats() { - let _m = RAWMTX.lock(); +// let ctx = raw::pcap_freecode_context(); +// ctx.checkpoint(); +// ctx.expect().return_once(|_| {}); - let mut value: isize = 777; - let pcap = as_pcap_t(&mut value); +// let result = capture.compile("some bpf program", false); +// assert!(result.is_ok()); +// } - let test_capture = test_capture::(pcap); - let mut capture = test_capture.capture; +// #[test] +// fn test_filter() { +// let _m = RAWMTX.lock(); - let stat = raw::pcap_stat { - ps_recv: 1, - ps_drop: 2, - ps_ifdrop: 3, - }; +// let mut value: isize = 777; +// let pcap = as_pcap_t(&mut value); - let ctx = raw::pcap_stats_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once_st(move |_, arg2| { - unsafe { *arg2 = stat }; - 0 - }); +// let test_capture = test_capture::(pcap); +// let mut capture = test_capture.capture; - 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::(pcap); - let mut capture: Capture = 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::(pcap); - let mut capture: Capture = 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::(pcap); - let mut capture: Capture = 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::(pcap); - let mut capture: Capture = test_capture.capture.into(); - - let mut packets = 0; - capture - .for_each(Some(0), |_| { - packets += 1; - }) - .unwrap(); - assert_eq!(packets, 0); - } -} +// 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::(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::(pcap); +// let mut capture: Capture = 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::(pcap); +// let mut capture: Capture = 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::(pcap); +// let mut capture: Capture = 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::(pcap); +// let mut capture: Capture = test_capture.capture.into(); + +// let mut packets = 0; +// capture +// .for_each(Some(0), |_| { +// packets += 1; +// }) +// .unwrap(); +// assert_eq!(packets, 0); +// } +// } diff --git a/src/capture/activated/offline.rs b/src/capture/activated/offline.rs index 950d3894..2c0c7fe0 100644 --- a/src/capture/activated/offline.rs +++ b/src/capture/activated/offline.rs @@ -79,79 +79,79 @@ impl Capture { } } -#[cfg(test)] -mod tests { - #[cfg(libpcap_1_5_0)] - use mockall::predicate; - - use crate::{ - capture::testmod::test_capture, - raw::testmod::{as_pcap_t, RAWMTX}, - }; - - use super::*; - - #[test] - fn test_from_file() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let ctx = raw::pcap_open_offline_context(); - ctx.expect().return_once_st(move |_, _| pcap); - - let ctx = raw::pcap_close_context(); - ctx.expect() - .withf_st(move |ptr| *ptr == pcap) - .return_once(|_| {}); - - let result = Capture::from_file("path/to/nowhere"); - assert!(result.is_ok()); - } - - #[test] - #[cfg(libpcap_1_5_0)] - fn test_from_file_with_precision() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let ctx = raw::pcap_open_offline_with_tstamp_precision_context(); - ctx.expect() - .with(predicate::always(), predicate::eq(1), predicate::always()) - .return_once_st(move |_, _, _| pcap); - - let ctx = raw::pcap_close_context(); - ctx.expect() - .withf_st(move |ptr| *ptr == pcap) - .return_once(|_| {}); - - let result = Capture::from_file_with_precision("path/to/nowhere", Precision::Nano); - assert!(result.is_ok()); - } - - #[test] - fn test_version() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let ctx = raw::pcap_major_version_context(); - ctx.expect() - .withf_st(move |arg| *arg == pcap) - .return_once(|_| 5); - - let ctx = raw::pcap_minor_version_context(); - ctx.expect() - .withf_st(move |arg| *arg == pcap) - .return_once(|_| 7); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - - assert_eq!(capture.version(), (5, 7)); - } -} +// #[cfg(test)] +// mod tests { +// #[cfg(libpcap_1_5_0)] +// use mockall::predicate; + +// use crate::{ +// capture::testmod::test_capture, +// raw::testmod::{as_pcap_t, RAWMTX}, +// }; + +// use super::*; + +// #[test] +// fn test_from_file() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let ctx = raw::pcap_open_offline_context(); +// ctx.expect().return_once_st(move |_, _| pcap); + +// let ctx = raw::pcap_close_context(); +// ctx.expect() +// .withf_st(move |ptr| *ptr == pcap) +// .return_once(|_| {}); + +// let result = Capture::from_file("path/to/nowhere"); +// assert!(result.is_ok()); +// } + +// #[test] +// #[cfg(libpcap_1_5_0)] +// fn test_from_file_with_precision() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let ctx = raw::pcap_open_offline_with_tstamp_precision_context(); +// ctx.expect() +// .with(predicate::always(), predicate::eq(1), predicate::always()) +// .return_once_st(move |_, _, _| pcap); + +// let ctx = raw::pcap_close_context(); +// ctx.expect() +// .withf_st(move |ptr| *ptr == pcap) +// .return_once(|_| {}); + +// let result = Capture::from_file_with_precision("path/to/nowhere", Precision::Nano); +// assert!(result.is_ok()); +// } + +// #[test] +// fn test_version() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let ctx = raw::pcap_major_version_context(); +// ctx.expect() +// .withf_st(move |arg| *arg == pcap) +// .return_once(|_| 5); + +// let ctx = raw::pcap_minor_version_context(); +// ctx.expect() +// .withf_st(move |arg| *arg == pcap) +// .return_once(|_| 7); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; + +// assert_eq!(capture.version(), (5, 7)); +// } +// } diff --git a/src/capture/inactive.rs b/src/capture/inactive.rs index bccd7dc1..e4fcc2df 100644 --- a/src/capture/inactive.rs +++ b/src/capture/inactive.rs @@ -173,261 +173,261 @@ pub enum TimestampType { AdapterUnsynced = 4, } -#[cfg(test)] -mod tests { - use crate::{ - capture::testmod::test_capture, - raw::testmod::{as_pcap_t, geterr_expect, RAWMTX}, - }; +// #[cfg(test)] +// mod tests { +// use crate::{ +// capture::testmod::test_capture, +// raw::testmod::{as_pcap_t, geterr_expect, RAWMTX}, +// }; - use super::*; +// use super::*; - #[test] - fn test_from_device() { - let _m = RAWMTX.lock(); +// #[test] +// fn test_from_device() { +// let _m = RAWMTX.lock(); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let ctx = raw::pcap_create_context(); - ctx.expect().return_once_st(move |_, _| pcap); +// let ctx = raw::pcap_create_context(); +// ctx.expect().return_once_st(move |_, _| pcap); - let ctx = raw::pcap_close_context(); - ctx.expect() - .withf_st(move |ptr| *ptr == pcap) - .return_once(|_| {}); +// let ctx = raw::pcap_close_context(); +// ctx.expect() +// .withf_st(move |ptr| *ptr == pcap) +// .return_once(|_| {}); - let result = Capture::from_device("some_device"); - assert!(result.is_ok()); - } - - #[test] - fn test_from_device_error() { - let _m = RAWMTX.lock(); - - let ctx = raw::pcap_create_context(); - ctx.expect().return_once_st(|_, _| std::ptr::null_mut()); - - let result = Capture::from_device("some_device"); - assert!(result.is_err()); - } - - #[test] - fn test_open() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - - let ctx = raw::pcap_activate_context(); - ctx.expect() - .withf_st(move |arg1| *arg1 == pcap) - .return_once(|_| 0); - - let result = capture.open(); - assert!(result.is_ok()); - } - - #[test] - fn test_open_error() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - - let ctx = raw::pcap_activate_context(); - ctx.expect() - .withf_st(move |arg1| *arg1 == pcap) - .return_once(|_| -1); - - let _err = geterr_expect(pcap); - - let result = capture.open(); - assert!(result.is_err()); - } - - #[test] - fn test_timeout() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - - let ctx = raw::pcap_set_timeout_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| 0); - - let _capture = capture.timeout(5); - } - - #[test] - #[cfg(libpcap_1_2_1)] - fn test_timstamp_type() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - - let ctx = raw::pcap_set_tstamp_type_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| 0); - - let _capture = capture.tstamp_type(TimestampType::Host); - - // For code coverage of the derive line. - assert_ne!(TimestampType::Host, TimestampType::HostLowPrec); - assert_ne!(TimestampType::Host, TimestampType::HostHighPrec); - } - - #[test] - fn test_promisc() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let result = Capture::from_device("some_device"); +// assert!(result.is_ok()); +// } - let ctx = raw::pcap_set_promisc_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| 0); +// #[test] +// fn test_from_device_error() { +// let _m = RAWMTX.lock(); - let _capture = capture.promisc(true); - } +// let ctx = raw::pcap_create_context(); +// ctx.expect().return_once_st(|_, _| std::ptr::null_mut()); - #[cfg(libpcap_1_5_0)] - struct ImmediateModeExpect(raw::__pcap_set_immediate_mode::Context); +// let result = Capture::from_device("some_device"); +// assert!(result.is_err()); +// } - #[cfg(all(windows, not(libpcap_1_5_0)))] - struct ImmediateModeExpect(raw::__pcap_setmintocopy::Context); +// #[test] +// fn test_open() { +// let _m = RAWMTX.lock(); - #[cfg(any(libpcap_1_5_0, windows))] - fn immediate_mode_expect(pcap: *mut raw::pcap_t) -> ImmediateModeExpect { - #[cfg(libpcap_1_5_0)] - { - let ctx = raw::pcap_set_immediate_mode_context(); - ctx.checkpoint(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| 0); - ImmediateModeExpect(ctx) - } - #[cfg(all(windows, not(libpcap_1_5_0)))] - { - let ctx = raw::pcap_setmintocopy_context(); - ctx.checkpoint(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| 0); - ImmediateModeExpect(ctx) - } - } +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - #[test] - #[cfg(any(libpcap_1_5_0, windows))] - fn test_immediate_mode() { - let _m = RAWMTX.lock(); +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let ctx = raw::pcap_activate_context(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap) +// .return_once(|_| 0); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let result = capture.open(); +// assert!(result.is_ok()); +// } - let _ctx = immediate_mode_expect(pcap); - let capture = capture.immediate_mode(true); +// #[test] +// fn test_open_error() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; + +// let ctx = raw::pcap_activate_context(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap) +// .return_once(|_| -1); + +// let _err = geterr_expect(pcap); + +// let result = capture.open(); +// assert!(result.is_err()); +// } + +// #[test] +// fn test_timeout() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; + +// let ctx = raw::pcap_set_timeout_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| 0); + +// let _capture = capture.timeout(5); +// } + +// #[test] +// #[cfg(libpcap_1_2_1)] +// fn test_timstamp_type() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let _ctx = immediate_mode_expect(pcap); - let _capture = capture.immediate_mode(false); - } +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - #[test] - #[cfg(not(windows))] - fn test_rfmon() { - let _m = RAWMTX.lock(); +// let ctx = raw::pcap_set_tstamp_type_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| 0); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let _capture = capture.tstamp_type(TimestampType::Host); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// // For code coverage of the derive line. +// assert_ne!(TimestampType::Host, TimestampType::HostLowPrec); +// assert_ne!(TimestampType::Host, TimestampType::HostHighPrec); +// } + +// #[test] +// fn test_promisc() { +// let _m = RAWMTX.lock(); - let ctx = raw::pcap_set_rfmon_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| 0); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let _capture = capture.rfmon(true); - } +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - #[test] - fn test_buffer_size() { - let _m = RAWMTX.lock(); +// let ctx = raw::pcap_set_promisc_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| 0); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let _capture = capture.promisc(true); +// } - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// #[cfg(libpcap_1_5_0)] +// struct ImmediateModeExpect(raw::__pcap_set_immediate_mode::Context); - let ctx = raw::pcap_set_buffer_size_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| 0); +// #[cfg(all(windows, not(libpcap_1_5_0)))] +// struct ImmediateModeExpect(raw::__pcap_setmintocopy::Context); - let _capture = capture.buffer_size(10); - } - - #[test] - #[cfg(libpcap_1_5_0)] - fn test_precision() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - - let ctx = raw::pcap_set_tstamp_precision_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| 0); - - let _capture = capture.precision(Precision::Nano); - } - - #[test] - fn test_snaplen() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - - let ctx = raw::pcap_set_snaplen_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| 0); - - let _capture = capture.snaplen(10); - } -} +// #[cfg(any(libpcap_1_5_0, windows))] +// fn immediate_mode_expect(pcap: *mut raw::pcap_t) -> ImmediateModeExpect { +// #[cfg(libpcap_1_5_0)] +// { +// let ctx = raw::pcap_set_immediate_mode_context(); +// ctx.checkpoint(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| 0); +// ImmediateModeExpect(ctx) +// } +// #[cfg(all(windows, not(libpcap_1_5_0)))] +// { +// let ctx = raw::pcap_setmintocopy_context(); +// ctx.checkpoint(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| 0); +// ImmediateModeExpect(ctx) +// } +// } + +// #[test] +// #[cfg(any(libpcap_1_5_0, windows))] +// fn test_immediate_mode() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; + +// let _ctx = immediate_mode_expect(pcap); +// let capture = capture.immediate_mode(true); + +// let _ctx = immediate_mode_expect(pcap); +// let _capture = capture.immediate_mode(false); +// } + +// #[test] +// #[cfg(not(windows))] +// fn test_rfmon() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; + +// let ctx = raw::pcap_set_rfmon_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| 0); + +// let _capture = capture.rfmon(true); +// } + +// #[test] +// fn test_buffer_size() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; + +// let ctx = raw::pcap_set_buffer_size_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| 0); + +// let _capture = capture.buffer_size(10); +// } + +// #[test] +// #[cfg(libpcap_1_5_0)] +// fn test_precision() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; + +// let ctx = raw::pcap_set_tstamp_precision_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| 0); + +// let _capture = capture.precision(Precision::Nano); +// } + +// #[test] +// fn test_snaplen() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; + +// let ctx = raw::pcap_set_snaplen_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| 0); + +// let _capture = capture.snaplen(10); +// } +// } diff --git a/src/capture/mod.rs b/src/capture/mod.rs index 1e67a4a3..9e20c4e7 100644 --- a/src/capture/mod.rs +++ b/src/capture/mod.rs @@ -220,70 +220,70 @@ pub mod testmod { } // GRCOV_EXCL_STOP -#[cfg(test)] -mod tests { - use crate::{ - capture::testmod::test_capture, - raw::testmod::{as_pcap_t, RAWMTX}, - }; +// #[cfg(test)] +// mod tests { +// use crate::{ +// capture::testmod::test_capture, +// raw::testmod::{as_pcap_t, RAWMTX}, +// }; - use super::*; +// use super::*; - #[test] - fn test_capture_getters() { - let _m = RAWMTX.lock(); +// #[test] +// fn test_capture_getters() { +// let _m = RAWMTX.lock(); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - assert!(!capture.is_nonblock()); - assert_eq!(capture.as_ptr(), capture.handle.as_ptr()); - } +// assert!(!capture.is_nonblock()); +// assert_eq!(capture.as_ptr(), capture.handle.as_ptr()); +// } - #[test] - #[cfg(windows)] - fn test_min_to_copy() { - let _m = RAWMTX.lock(); +// #[test] +// #[cfg(windows)] +// fn test_min_to_copy() { +// let _m = RAWMTX.lock(); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - let ctx = raw::pcap_setmintocopy_context(); - ctx.expect() - .withf_st(move |arg1, _| *arg1 == pcap) - .return_once(|_, _| 0); +// let ctx = raw::pcap_setmintocopy_context(); +// ctx.expect() +// .withf_st(move |arg1, _| *arg1 == pcap) +// .return_once(|_, _| 0); - let _capture = capture.min_to_copy(5); - } +// let _capture = capture.min_to_copy(5); +// } - #[test] - #[cfg(windows)] - fn test_get_event() { - let _m = RAWMTX.lock(); +// #[test] +// #[cfg(windows)] +// fn test_get_event() { +// let _m = RAWMTX.lock(); - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; - let ctx = raw::pcap_getevent_context(); - ctx.expect() - .withf_st(move |arg1| *arg1 == pcap) - .return_once(|_| 5); +// let ctx = raw::pcap_getevent_context(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap) +// .return_once(|_| 5); - let handle = unsafe { capture.get_event() }; - assert_eq!(handle, 5); - } +// let handle = unsafe { capture.get_event() }; +// assert_eq!(handle, 5); +// } - #[test] - fn test_precision() { - assert_ne!(Precision::Micro, Precision::Nano); - } -} +// #[test] +// fn test_precision() { +// assert_ne!(Precision::Micro, Precision::Nano); +// } +// } diff --git a/src/capture/selectable.rs b/src/capture/selectable.rs index 55b0fe9d..15448a88 100644 --- a/src/capture/selectable.rs +++ b/src/capture/selectable.rs @@ -31,51 +31,51 @@ impl AsRawFd for SelectableCapture { } } -#[cfg(test)] -mod tests { - use crate::{ - capture::{testmod::test_capture, Active}, - raw::testmod::{as_pcap_t, RAWMTX}, - }; - - use super::*; - - #[test] - fn test_selectable_capture() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - - let ctx = raw::pcap_get_selectable_fd_context(); - ctx.expect() - .withf_st(move |arg1| *arg1 == pcap) - .return_once(|_| 5); - - let mut selectable = SelectableCapture::new(capture).unwrap(); - assert!(!selectable.get_inner_mut().is_nonblock()); - assert_eq!(selectable.as_raw_fd(), 5); - } - - #[test] - fn test_selectable_capture_error() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - - let ctx = raw::pcap_get_selectable_fd_context(); - ctx.expect() - .withf_st(move |arg1| *arg1 == pcap) - .return_once(|_| -1); - - let result = SelectableCapture::new(capture); - assert!(result.is_err()); - } -} +// #[cfg(test)] +// mod tests { +// use crate::{ +// capture::{testmod::test_capture, Active}, +// raw::testmod::{as_pcap_t, RAWMTX}, +// }; + +// use super::*; + +// #[test] +// fn test_selectable_capture() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; + +// let ctx = raw::pcap_get_selectable_fd_context(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap) +// .return_once(|_| 5); + +// let mut selectable = SelectableCapture::new(capture).unwrap(); +// assert!(!selectable.get_inner_mut().is_nonblock()); +// assert_eq!(selectable.as_raw_fd(), 5); +// } + +// #[test] +// fn test_selectable_capture_error() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; + +// let ctx = raw::pcap_get_selectable_fd_context(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap) +// .return_once(|_| -1); + +// let result = SelectableCapture::new(capture); +// assert!(result.is_err()); +// } +// } diff --git a/src/device.rs b/src/device.rs index 561b11fd..da799870 100644 --- a/src/device.rs +++ b/src/device.rs @@ -283,402 +283,402 @@ impl Address { } } -#[cfg(test)] -mod tests { - use std::ffi::CString; +// #[cfg(test)] +// mod tests { +// use std::ffi::CString; + +// use crate::raw::testmod::{as_pcap_t, RAWMTX}; + +// use super::*; + +// #[cfg(not(windows))] +// enum Sockaddr { +// SockaddrIn(libc::sockaddr_in), +// SockaddrIn6(libc::sockaddr_in6), +// } + +// #[cfg(windows)] +// enum Sockaddr { +// SockaddrIn(WinSock::SOCKADDR_IN), +// SockaddrIn6(WinSock::SOCKADDR_IN6), +// } + +// impl Sockaddr { +// fn as_mut_ptr(&mut self) -> *mut libc::sockaddr { +// match self { +// Sockaddr::SockaddrIn(ref mut sin) => sin as *mut _ as _, +// Sockaddr::SockaddrIn6(ref mut sin6) => sin6 as *mut _ as _, +// } +// } + +// fn set_family(&mut self, family: u16) { +// // Annoyingly this differs between Linux (u16) and Mac (u8). +// #[cfg(not(windows))] +// let family = family as libc::sa_family_t; + +// match self { +// Sockaddr::SockaddrIn(ref mut sin) => sin.sin_family = family, +// Sockaddr::SockaddrIn6(ref mut sin6) => sin6.sin6_family = family, +// } +// } +// } + +// static IF1_NAME: &str = "if1"; +// static IF2_NAME: &str = "if2"; +// static IF1_DESC: &str = "if1 desc"; +// static IF2_DESC: &str = "if2 desc"; + +// fn devs() -> Vec { +// let mut devs = vec![ +// raw::pcap_if_t { +// next: std::ptr::null_mut(), +// name: CString::new(IF1_NAME).unwrap().into_raw(), +// description: CString::new(IF1_DESC).unwrap().into_raw(), +// addresses: std::ptr::null_mut(), +// flags: (raw::PCAP_IF_LOOPBACK | raw::PCAP_IF_UP), +// }, +// raw::pcap_if_t { +// next: std::ptr::null_mut(), +// name: CString::new(IF2_NAME).unwrap().into_raw(), +// description: CString::new(IF2_DESC).unwrap().into_raw(), +// addresses: std::ptr::null_mut(), +// flags: 0, +// }, +// ]; +// devs[0].next = &mut devs[1]; +// devs +// } + +// trait InetAddressV4 { +// fn new() -> Self; +// fn set_addr(&mut self, addr: u32); +// } + +// #[cfg(not(windows))] +// impl InetAddressV4 for libc::sockaddr_in { +// fn new() -> Self { +// let mut addr: Self = unsafe { std::mem::zeroed() }; +// addr.sin_family = libc::AF_INET as libc::sa_family_t; +// addr +// } + +// fn set_addr(&mut self, addr: u32) { +// self.sin_addr.s_addr = addr; +// } +// } + +// #[cfg(windows)] +// impl InetAddressV4 for WinSock::SOCKADDR_IN { +// fn new() -> Self { +// let mut addr: Self = unsafe { std::mem::zeroed() }; +// // The cast is only necessary due to a bug in windows_sys@v0.36.1 +// addr.sin_family = WinSock::AF_INET as u16; +// addr +// } + +// fn set_addr(&mut self, addr: u32) { +// self.sin_addr.S_un.S_addr = addr; +// } +// } + +// fn sockaddr_ipv4() -> Sockaddr { +// #[cfg(not(windows))] +// let mut addr: libc::sockaddr_in = InetAddressV4::new(); +// #[cfg(windows)] +// let mut addr: WinSock::SOCKADDR_IN = InetAddressV4::new(); + +// addr.sin_port = 1075; +// addr.set_addr(0x0A000042_u32.to_be()); + +// Sockaddr::SockaddrIn(addr) +// } + +// trait InetAddressV6 { +// fn new() -> Self; +// fn set_octet(&mut self, index: usize, octet: u8); +// } + +// #[cfg(not(windows))] +// impl InetAddressV6 for libc::sockaddr_in6 { +// fn new() -> Self { +// let mut addr: Self = unsafe { std::mem::zeroed() }; +// addr.sin6_family = libc::AF_INET6 as libc::sa_family_t; +// addr.sin6_addr.s6_addr[0] = 0xFE; +// addr.sin6_addr.s6_addr[1] = 0x80; +// addr +// } + +// fn set_octet(&mut self, index: usize, octet: u8) { +// self.sin6_addr.s6_addr[index] = octet; +// } +// } + +// #[cfg(windows)] +// impl InetAddressV6 for WinSock::SOCKADDR_IN6 { +// fn new() -> Self { +// let mut addr: Self = unsafe { std::mem::zeroed() }; +// // The cast is only necessary due to a bug in windows_sys@v0.36.1 +// addr.sin6_family = WinSock::AF_INET6 as u16; +// unsafe { +// addr.sin6_addr.u.Byte[0] = 0xFE; +// addr.sin6_addr.u.Byte[1] = 0x80; +// } +// addr +// } + +// fn set_octet(&mut self, index: usize, octet: u8) { +// unsafe { self.sin6_addr.u.Byte[index] = octet }; +// } +// } + +// fn sockaddr_ipv6() -> Sockaddr { +// #[cfg(not(windows))] +// let mut addr: libc::sockaddr_in6 = InetAddressV6::new(); +// #[cfg(windows)] +// let mut addr: WinSock::SOCKADDR_IN6 = InetAddressV6::new(); + +// addr.sin6_port = 1075; +// addr.set_octet(15, 0x42); + +// Sockaddr::SockaddrIn6(addr) +// } + +// impl From<&mut Sockaddr> for raw::pcap_addr_t { +// fn from(value: &mut Sockaddr) -> Self { +// raw::pcap_addr_t { +// next: std::ptr::null_mut(), +// addr: value.as_mut_ptr(), +// netmask: std::ptr::null_mut(), +// broadaddr: std::ptr::null_mut(), +// dstaddr: std::ptr::null_mut(), +// } +// } +// } + +// #[test] +// fn test_device_flags() { +// let flags = DeviceFlags::from( +// raw::PCAP_IF_LOOPBACK | raw::PCAP_IF_UP | raw::PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE, +// ); + +// assert!(flags.is_loopback()); +// assert!(flags.is_up()); +// assert!(flags.contains(IfFlags::LOOPBACK | IfFlags::UP)); + +// assert!(!flags.is_running()); +// assert!(!flags.is_wireless()); + +// assert_ne!(flags.connection_status, ConnectionStatus::Unknown); +// assert_ne!(flags.connection_status, ConnectionStatus::Connected); +// assert_ne!(flags.connection_status, ConnectionStatus::Disconnected); +// assert_eq!(flags.connection_status, ConnectionStatus::NotApplicable); + +// assert!(!format!("{:?}", flags).is_empty()); +// } + +// #[test] +// fn test_connection_status() { +// let flags = raw::PCAP_IF_CONNECTION_STATUS_UNKNOWN; +// assert_eq!(ConnectionStatus::from(flags), ConnectionStatus::Unknown); + +// let flags = raw::PCAP_IF_CONNECTION_STATUS_CONNECTED; +// assert_eq!(ConnectionStatus::from(flags), ConnectionStatus::Connected); + +// let flags = raw::PCAP_IF_CONNECTION_STATUS_DISCONNECTED; +// assert_eq!( +// ConnectionStatus::from(flags), +// ConnectionStatus::Disconnected +// ); + +// let flags = raw::PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE; +// assert_eq!( +// ConnectionStatus::from(flags), +// ConnectionStatus::NotApplicable +// ); +// } + +// #[test] +// fn test_into_capture() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let ctx = raw::pcap_create_context(); +// ctx.expect().return_once_st(move |_, _| pcap); + +// let ctx = raw::pcap_activate_context(); +// ctx.expect() +// .withf_st(move |arg1| *arg1 == pcap) +// .return_once(|_| 0); + +// let ctx = raw::pcap_close_context(); +// ctx.expect() +// .withf_st(move |ptr| *ptr == pcap) +// .return_once(|_| {}); + +// let device: Device = "device".into(); +// let _capture: Capture = device.clone().open().unwrap(); + +// assert!(!format!("{:?}", device).is_empty()); +// } + +// #[test] +// fn test_lookup() { +// let _m = RAWMTX.lock(); + +// let ctx = raw::pcap_findalldevs_context(); +// ctx.expect().return_once_st(move |arg1, _| { +// unsafe { *arg1 = std::ptr::null_mut() }; +// 0 +// }); + +// let ctx = raw::pcap_freealldevs_context(); +// ctx.expect().return_once(move |_| {}); + +// let device = Device::lookup().unwrap(); +// assert!(device.is_none()); + +// let mut devs = devs(); +// let mut addrs = sockaddr_ipv4(); +// let mut pcap_addr = (&mut addrs).into(); +// devs[0].addresses = &mut pcap_addr; +// let devs_ptr = devs.as_mut_ptr(); + +// let ctx = raw::pcap_findalldevs_context(); +// ctx.checkpoint(); +// ctx.expect().return_once_st(move |arg1, _| { +// unsafe { *arg1 = devs_ptr }; +// 0 +// }); + +// let ctx = raw::pcap_freealldevs_context(); +// ctx.checkpoint(); +// ctx.expect().return_once(move |_| {}); + +// let device = Device::lookup().unwrap().unwrap(); +// assert_eq!(&device.name, IF1_NAME); +// assert_eq!(&device.desc.unwrap(), IF1_DESC); +// assert_eq!(device.addresses.len(), 1); +// assert!(device.addresses[0].addr.is_ipv4()); + +// let ctx = raw::pcap_findalldevs_context(); +// ctx.checkpoint(); +// ctx.expect().return_once_st(move |_, _| -1); + +// let ctx = raw::pcap_freealldevs_context(); +// ctx.checkpoint(); + +// let result = Device::lookup(); +// assert!(result.is_err()); +// } + +// #[test] +// fn test_list() { +// let _m = RAWMTX.lock(); + +// let ctx = raw::pcap_findalldevs_context(); +// ctx.expect().return_once_st(move |arg1, _| { +// unsafe { *arg1 = std::ptr::null_mut() }; +// 0 +// }); + +// let ctx = raw::pcap_freealldevs_context(); +// ctx.expect().return_once(move |_| {}); + +// let devices = Device::list().unwrap(); +// assert!(devices.is_empty()); + +// let mut devs = devs(); +// let mut ipv4s = sockaddr_ipv4(); +// let mut ipv6s = sockaddr_ipv6(); +// let mut pcap_addr: raw::pcap_addr_t = (&mut ipv4s).into(); +// let mut pcap_addr6: raw::pcap_addr_t = (&mut ipv6s).into(); +// pcap_addr.next = &mut pcap_addr6; +// devs[1].addresses = &mut pcap_addr; +// let devs_ptr = devs.as_mut_ptr(); + +// let ctx = raw::pcap_findalldevs_context(); +// ctx.checkpoint(); +// ctx.expect().return_once_st(move |arg1, _| { +// unsafe { *arg1 = devs_ptr }; +// 0 +// }); + +// let ctx = raw::pcap_freealldevs_context(); +// ctx.checkpoint(); +// ctx.expect().return_once(move |_| {}); + +// let devices = Device::list().unwrap(); +// assert_eq!(devices.len(), devs.len()); + +// assert_eq!(&devices[0].name, IF1_NAME); +// assert_eq!(devices[0].desc.as_ref().unwrap(), IF1_DESC); +// assert_eq!(devices[0].addresses.len(), 0); + +// assert_eq!(&devices[1].name, IF2_NAME); +// assert_eq!(devices[1].desc.as_ref().unwrap(), IF2_DESC); +// assert_eq!(devices[1].addresses.len(), 2); +// assert!(devices[1].addresses[0].addr.is_ipv4()); +// assert!(devices[1].addresses[1].addr.is_ipv6()); + +// let ctx = raw::pcap_findalldevs_context(); +// ctx.checkpoint(); +// ctx.expect().return_once_st(move |_, _| -1); + +// let ctx = raw::pcap_freealldevs_context(); +// ctx.checkpoint(); + +// let result = Device::list(); +// assert!(result.is_err()); +// } + +// #[test] +// fn test_address_ipv4() { +// let mut addr = sockaddr_ipv4(); +// let pcap_addr: raw::pcap_addr_t = (&mut addr).into(); + +// let address = unsafe { Address::new(&pcap_addr) }.unwrap(); + +// assert!(address.addr.is_ipv4()); +// assert_eq!(address.addr.to_string(), "10.0.0.66"); + +// assert!(address.netmask.is_none()); +// assert!(address.broadcast_addr.is_none()); +// assert!(address.dst_addr.is_none()); + +// assert!(!format!("{:?}", address).is_empty()); +// } + +// #[test] +// fn test_address_family() { +// let mut addr = sockaddr_ipv4(); + +// #[cfg(not(windows))] +// addr.set_family(libc::AF_IPX as u16); +// #[cfg(windows)] +// addr.set_family(WinSock::AF_IPX); + +// let pcap_addr: raw::pcap_addr_t = (&mut addr).into(); - use crate::raw::testmod::{as_pcap_t, RAWMTX}; +// let address = unsafe { Address::new(&pcap_addr) }; +// assert!(address.is_none()); +// } - use super::*; +// #[test] +// fn test_address_ipv6() { +// let mut addr = sockaddr_ipv6(); +// let pcap_addr: raw::pcap_addr_t = (&mut addr).into(); + +// let address = unsafe { Address::new(&pcap_addr) }.unwrap(); - #[cfg(not(windows))] - enum Sockaddr { - SockaddrIn(libc::sockaddr_in), - SockaddrIn6(libc::sockaddr_in6), - } - - #[cfg(windows)] - enum Sockaddr { - SockaddrIn(WinSock::SOCKADDR_IN), - SockaddrIn6(WinSock::SOCKADDR_IN6), - } - - impl Sockaddr { - fn as_mut_ptr(&mut self) -> *mut libc::sockaddr { - match self { - Sockaddr::SockaddrIn(ref mut sin) => sin as *mut _ as _, - Sockaddr::SockaddrIn6(ref mut sin6) => sin6 as *mut _ as _, - } - } - - fn set_family(&mut self, family: u16) { - // Annoyingly this differs between Linux (u16) and Mac (u8). - #[cfg(not(windows))] - let family = family as libc::sa_family_t; - - match self { - Sockaddr::SockaddrIn(ref mut sin) => sin.sin_family = family, - Sockaddr::SockaddrIn6(ref mut sin6) => sin6.sin6_family = family, - } - } - } - - static IF1_NAME: &str = "if1"; - static IF2_NAME: &str = "if2"; - static IF1_DESC: &str = "if1 desc"; - static IF2_DESC: &str = "if2 desc"; - - fn devs() -> Vec { - let mut devs = vec![ - raw::pcap_if_t { - next: std::ptr::null_mut(), - name: CString::new(IF1_NAME).unwrap().into_raw(), - description: CString::new(IF1_DESC).unwrap().into_raw(), - addresses: std::ptr::null_mut(), - flags: (raw::PCAP_IF_LOOPBACK | raw::PCAP_IF_UP), - }, - raw::pcap_if_t { - next: std::ptr::null_mut(), - name: CString::new(IF2_NAME).unwrap().into_raw(), - description: CString::new(IF2_DESC).unwrap().into_raw(), - addresses: std::ptr::null_mut(), - flags: 0, - }, - ]; - devs[0].next = &mut devs[1]; - devs - } - - trait InetAddressV4 { - fn new() -> Self; - fn set_addr(&mut self, addr: u32); - } - - #[cfg(not(windows))] - impl InetAddressV4 for libc::sockaddr_in { - fn new() -> Self { - let mut addr: Self = unsafe { std::mem::zeroed() }; - addr.sin_family = libc::AF_INET as libc::sa_family_t; - addr - } - - fn set_addr(&mut self, addr: u32) { - self.sin_addr.s_addr = addr; - } - } - - #[cfg(windows)] - impl InetAddressV4 for WinSock::SOCKADDR_IN { - fn new() -> Self { - let mut addr: Self = unsafe { std::mem::zeroed() }; - // The cast is only necessary due to a bug in windows_sys@v0.36.1 - addr.sin_family = WinSock::AF_INET as u16; - addr - } - - fn set_addr(&mut self, addr: u32) { - self.sin_addr.S_un.S_addr = addr; - } - } - - fn sockaddr_ipv4() -> Sockaddr { - #[cfg(not(windows))] - let mut addr: libc::sockaddr_in = InetAddressV4::new(); - #[cfg(windows)] - let mut addr: WinSock::SOCKADDR_IN = InetAddressV4::new(); - - addr.sin_port = 1075; - addr.set_addr(0x0A000042_u32.to_be()); - - Sockaddr::SockaddrIn(addr) - } - - trait InetAddressV6 { - fn new() -> Self; - fn set_octet(&mut self, index: usize, octet: u8); - } - - #[cfg(not(windows))] - impl InetAddressV6 for libc::sockaddr_in6 { - fn new() -> Self { - let mut addr: Self = unsafe { std::mem::zeroed() }; - addr.sin6_family = libc::AF_INET6 as libc::sa_family_t; - addr.sin6_addr.s6_addr[0] = 0xFE; - addr.sin6_addr.s6_addr[1] = 0x80; - addr - } - - fn set_octet(&mut self, index: usize, octet: u8) { - self.sin6_addr.s6_addr[index] = octet; - } - } - - #[cfg(windows)] - impl InetAddressV6 for WinSock::SOCKADDR_IN6 { - fn new() -> Self { - let mut addr: Self = unsafe { std::mem::zeroed() }; - // The cast is only necessary due to a bug in windows_sys@v0.36.1 - addr.sin6_family = WinSock::AF_INET6 as u16; - unsafe { - addr.sin6_addr.u.Byte[0] = 0xFE; - addr.sin6_addr.u.Byte[1] = 0x80; - } - addr - } - - fn set_octet(&mut self, index: usize, octet: u8) { - unsafe { self.sin6_addr.u.Byte[index] = octet }; - } - } - - fn sockaddr_ipv6() -> Sockaddr { - #[cfg(not(windows))] - let mut addr: libc::sockaddr_in6 = InetAddressV6::new(); - #[cfg(windows)] - let mut addr: WinSock::SOCKADDR_IN6 = InetAddressV6::new(); - - addr.sin6_port = 1075; - addr.set_octet(15, 0x42); - - Sockaddr::SockaddrIn6(addr) - } - - impl From<&mut Sockaddr> for raw::pcap_addr_t { - fn from(value: &mut Sockaddr) -> Self { - raw::pcap_addr_t { - next: std::ptr::null_mut(), - addr: value.as_mut_ptr(), - netmask: std::ptr::null_mut(), - broadaddr: std::ptr::null_mut(), - dstaddr: std::ptr::null_mut(), - } - } - } - - #[test] - fn test_device_flags() { - let flags = DeviceFlags::from( - raw::PCAP_IF_LOOPBACK | raw::PCAP_IF_UP | raw::PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE, - ); - - assert!(flags.is_loopback()); - assert!(flags.is_up()); - assert!(flags.contains(IfFlags::LOOPBACK | IfFlags::UP)); - - assert!(!flags.is_running()); - assert!(!flags.is_wireless()); - - assert_ne!(flags.connection_status, ConnectionStatus::Unknown); - assert_ne!(flags.connection_status, ConnectionStatus::Connected); - assert_ne!(flags.connection_status, ConnectionStatus::Disconnected); - assert_eq!(flags.connection_status, ConnectionStatus::NotApplicable); - - assert!(!format!("{:?}", flags).is_empty()); - } - - #[test] - fn test_connection_status() { - let flags = raw::PCAP_IF_CONNECTION_STATUS_UNKNOWN; - assert_eq!(ConnectionStatus::from(flags), ConnectionStatus::Unknown); - - let flags = raw::PCAP_IF_CONNECTION_STATUS_CONNECTED; - assert_eq!(ConnectionStatus::from(flags), ConnectionStatus::Connected); - - let flags = raw::PCAP_IF_CONNECTION_STATUS_DISCONNECTED; - assert_eq!( - ConnectionStatus::from(flags), - ConnectionStatus::Disconnected - ); - - let flags = raw::PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE; - assert_eq!( - ConnectionStatus::from(flags), - ConnectionStatus::NotApplicable - ); - } - - #[test] - fn test_into_capture() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let ctx = raw::pcap_create_context(); - ctx.expect().return_once_st(move |_, _| pcap); - - let ctx = raw::pcap_activate_context(); - ctx.expect() - .withf_st(move |arg1| *arg1 == pcap) - .return_once(|_| 0); - - let ctx = raw::pcap_close_context(); - ctx.expect() - .withf_st(move |ptr| *ptr == pcap) - .return_once(|_| {}); - - let device: Device = "device".into(); - let _capture: Capture = device.clone().open().unwrap(); - - assert!(!format!("{:?}", device).is_empty()); - } - - #[test] - fn test_lookup() { - let _m = RAWMTX.lock(); - - let ctx = raw::pcap_findalldevs_context(); - ctx.expect().return_once_st(move |arg1, _| { - unsafe { *arg1 = std::ptr::null_mut() }; - 0 - }); - - let ctx = raw::pcap_freealldevs_context(); - ctx.expect().return_once(move |_| {}); - - let device = Device::lookup().unwrap(); - assert!(device.is_none()); - - let mut devs = devs(); - let mut addrs = sockaddr_ipv4(); - let mut pcap_addr = (&mut addrs).into(); - devs[0].addresses = &mut pcap_addr; - let devs_ptr = devs.as_mut_ptr(); - - let ctx = raw::pcap_findalldevs_context(); - ctx.checkpoint(); - ctx.expect().return_once_st(move |arg1, _| { - unsafe { *arg1 = devs_ptr }; - 0 - }); - - let ctx = raw::pcap_freealldevs_context(); - ctx.checkpoint(); - ctx.expect().return_once(move |_| {}); - - let device = Device::lookup().unwrap().unwrap(); - assert_eq!(&device.name, IF1_NAME); - assert_eq!(&device.desc.unwrap(), IF1_DESC); - assert_eq!(device.addresses.len(), 1); - assert!(device.addresses[0].addr.is_ipv4()); - - let ctx = raw::pcap_findalldevs_context(); - ctx.checkpoint(); - ctx.expect().return_once_st(move |_, _| -1); - - let ctx = raw::pcap_freealldevs_context(); - ctx.checkpoint(); - - let result = Device::lookup(); - assert!(result.is_err()); - } - - #[test] - fn test_list() { - let _m = RAWMTX.lock(); - - let ctx = raw::pcap_findalldevs_context(); - ctx.expect().return_once_st(move |arg1, _| { - unsafe { *arg1 = std::ptr::null_mut() }; - 0 - }); - - let ctx = raw::pcap_freealldevs_context(); - ctx.expect().return_once(move |_| {}); - - let devices = Device::list().unwrap(); - assert!(devices.is_empty()); - - let mut devs = devs(); - let mut ipv4s = sockaddr_ipv4(); - let mut ipv6s = sockaddr_ipv6(); - let mut pcap_addr: raw::pcap_addr_t = (&mut ipv4s).into(); - let mut pcap_addr6: raw::pcap_addr_t = (&mut ipv6s).into(); - pcap_addr.next = &mut pcap_addr6; - devs[1].addresses = &mut pcap_addr; - let devs_ptr = devs.as_mut_ptr(); - - let ctx = raw::pcap_findalldevs_context(); - ctx.checkpoint(); - ctx.expect().return_once_st(move |arg1, _| { - unsafe { *arg1 = devs_ptr }; - 0 - }); - - let ctx = raw::pcap_freealldevs_context(); - ctx.checkpoint(); - ctx.expect().return_once(move |_| {}); - - let devices = Device::list().unwrap(); - assert_eq!(devices.len(), devs.len()); - - assert_eq!(&devices[0].name, IF1_NAME); - assert_eq!(devices[0].desc.as_ref().unwrap(), IF1_DESC); - assert_eq!(devices[0].addresses.len(), 0); - - assert_eq!(&devices[1].name, IF2_NAME); - assert_eq!(devices[1].desc.as_ref().unwrap(), IF2_DESC); - assert_eq!(devices[1].addresses.len(), 2); - assert!(devices[1].addresses[0].addr.is_ipv4()); - assert!(devices[1].addresses[1].addr.is_ipv6()); - - let ctx = raw::pcap_findalldevs_context(); - ctx.checkpoint(); - ctx.expect().return_once_st(move |_, _| -1); - - let ctx = raw::pcap_freealldevs_context(); - ctx.checkpoint(); - - let result = Device::list(); - assert!(result.is_err()); - } - - #[test] - fn test_address_ipv4() { - let mut addr = sockaddr_ipv4(); - let pcap_addr: raw::pcap_addr_t = (&mut addr).into(); - - let address = unsafe { Address::new(&pcap_addr) }.unwrap(); - - assert!(address.addr.is_ipv4()); - assert_eq!(address.addr.to_string(), "10.0.0.66"); - - assert!(address.netmask.is_none()); - assert!(address.broadcast_addr.is_none()); - assert!(address.dst_addr.is_none()); - - assert!(!format!("{:?}", address).is_empty()); - } - - #[test] - fn test_address_family() { - let mut addr = sockaddr_ipv4(); - - #[cfg(not(windows))] - addr.set_family(libc::AF_IPX as u16); - #[cfg(windows)] - addr.set_family(WinSock::AF_IPX); - - let pcap_addr: raw::pcap_addr_t = (&mut addr).into(); - - let address = unsafe { Address::new(&pcap_addr) }; - assert!(address.is_none()); - } - - #[test] - fn test_address_ipv6() { - let mut addr = sockaddr_ipv6(); - let pcap_addr: raw::pcap_addr_t = (&mut addr).into(); - - let address = unsafe { Address::new(&pcap_addr) }.unwrap(); - - assert!(address.addr.is_ipv6()); - assert_eq!(address.addr.to_string(), "fe80::42"); - - assert!(address.netmask.is_none()); - assert!(address.broadcast_addr.is_none()); - assert!(address.dst_addr.is_none()); - - assert!(!format!("{:?}", address).is_empty()); - } -} +// assert!(address.addr.is_ipv6()); +// assert_eq!(address.addr.to_string(), "fe80::42"); + +// assert!(address.netmask.is_none()); +// assert!(address.broadcast_addr.is_none()); +// assert!(address.dst_addr.is_none()); + +// assert!(!format!("{:?}", address).is_empty()); +// } +// } diff --git a/src/lib.rs b/src/lib.rs index 39a2374a..d9c483ef 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -227,56 +227,56 @@ impl From for Error { } } -#[cfg(test)] -mod tests { - use std::error::Error as StdError; - use std::{ffi::CString, io}; +// #[cfg(test)] +// mod tests { +// use std::error::Error as StdError; +// use std::{ffi::CString, io}; - use super::*; +// use super::*; - #[test] - fn test_error_invalid_utf8() { - let bytes: [u8; 8] = [0x78, 0xfe, 0xe9, 0x89, 0x00, 0x00, 0xed, 0x4f]; - let error = unsafe { Error::new(&bytes as *const _ as _) }; - assert!(matches!(error, Error::MalformedError(_))); - } +// #[test] +// fn test_error_invalid_utf8() { +// let bytes: [u8; 8] = [0x78, 0xfe, 0xe9, 0x89, 0x00, 0x00, 0xed, 0x4f]; +// let error = unsafe { Error::new(&bytes as *const _ as _) }; +// assert!(matches!(error, Error::MalformedError(_))); +// } - #[test] - fn test_error_null() { - let error = unsafe { Error::new(std::ptr::null()) }; - assert_eq!(error, Error::PcapError("".to_string())); - } +// #[test] +// fn test_error_null() { +// let error = unsafe { Error::new(std::ptr::null()) }; +// assert_eq!(error, Error::PcapError("".to_string())); +// } - #[test] - #[allow(deprecated)] - fn test_errors() { - let mut errors: Vec = vec![]; +// #[test] +// #[allow(deprecated)] +// fn test_errors() { +// let mut errors: Vec = vec![]; - let bytes: [u8; 8] = [0x78, 0xfe, 0xe9, 0x89, 0x00, 0x00, 0xed, 0x4f]; - let cstr = unsafe { CStr::from_ptr(&bytes as *const _ as _) }; +// let bytes: [u8; 8] = [0x78, 0xfe, 0xe9, 0x89, 0x00, 0x00, 0xed, 0x4f]; +// let cstr = unsafe { CStr::from_ptr(&bytes as *const _ as _) }; - errors.push(cstr.to_str().unwrap_err().into()); - errors.push(Error::InvalidString); - errors.push(Error::PcapError("git rekt".to_string())); - errors.push(Error::InvalidLinktype); - errors.push(Error::TimeoutExpired); - errors.push(Error::NoMorePackets); - errors.push(Error::NonNonBlock); - errors.push(Error::InsufficientMemory); - errors.push(CString::new(b"f\0oo".to_vec()).unwrap_err().into()); - errors.push(io::Error::new(io::ErrorKind::Interrupted, "error").into()); - #[cfg(not(windows))] - errors.push(Error::InvalidRawFd); - errors.push(Error::ErrnoError(errno::Errno(125))); - errors.push(Error::BufferOverflow); +// errors.push(cstr.to_str().unwrap_err().into()); +// errors.push(Error::InvalidString); +// errors.push(Error::PcapError("git rekt".to_string())); +// errors.push(Error::InvalidLinktype); +// errors.push(Error::TimeoutExpired); +// errors.push(Error::NoMorePackets); +// errors.push(Error::NonNonBlock); +// errors.push(Error::InsufficientMemory); +// errors.push(CString::new(b"f\0oo".to_vec()).unwrap_err().into()); +// errors.push(io::Error::new(io::ErrorKind::Interrupted, "error").into()); +// #[cfg(not(windows))] +// errors.push(Error::InvalidRawFd); +// errors.push(Error::ErrnoError(errno::Errno(125))); +// errors.push(Error::BufferOverflow); - for error in errors.iter() { - assert!(!error.to_string().is_empty()); - assert!(!error.description().is_empty()); - match error { - Error::MalformedError(_) => assert!(error.cause().is_some()), - _ => assert!(error.cause().is_none()), - } - } - } -} +// for error in errors.iter() { +// assert!(!error.to_string().is_empty()); +// assert!(!error.description().is_empty()); +// match error { +// Error::MalformedError(_) => assert!(error.cause().is_some()), +// _ => assert!(error.cause().is_none()), +// } +// } +// } +// } diff --git a/src/linktype.rs b/src/linktype.rs index 26044e89..b391d58e 100644 --- a/src/linktype.rs +++ b/src/linktype.rs @@ -169,53 +169,53 @@ impl Linktype { pub const ATSC_ALP: Self = Self(289); } -#[cfg(test)] -mod tests { - use crate::raw::testmod::RAWMTX; +// #[cfg(test)] +// mod tests { +// use crate::raw::testmod::RAWMTX; - use super::*; +// use super::*; - #[test] - fn test_get_name() { - let _m = RAWMTX.lock(); - let name = "datalink name"; +// #[test] +// fn test_get_name() { +// let _m = RAWMTX.lock(); +// let name = "datalink name"; - let cstr = CString::new(name).unwrap(); - let ctx = raw::pcap_datalink_val_to_name_context(); - ctx.expect().return_once(|_| cstr.into_raw()); +// let cstr = CString::new(name).unwrap(); +// let ctx = raw::pcap_datalink_val_to_name_context(); +// ctx.expect().return_once(|_| cstr.into_raw()); - let linktype_name = Linktype::ARCNET_LINUX.get_name().unwrap(); - assert_eq!(&linktype_name, name); - } +// let linktype_name = Linktype::ARCNET_LINUX.get_name().unwrap(); +// assert_eq!(&linktype_name, name); +// } - #[test] - fn test_get_description() { - let _m = RAWMTX.lock(); - let desc = "datalink description"; +// #[test] +// fn test_get_description() { +// let _m = RAWMTX.lock(); +// let desc = "datalink description"; - let cstr = CString::new(desc).unwrap(); - let ctx = raw::pcap_datalink_val_to_description_context(); - ctx.expect().return_once(|_| cstr.into_raw()); +// let cstr = CString::new(desc).unwrap(); +// let ctx = raw::pcap_datalink_val_to_description_context(); +// ctx.expect().return_once(|_| cstr.into_raw()); - let linktype_name = Linktype::ARCNET_LINUX.get_description().unwrap(); - assert_eq!(&linktype_name, desc); - } +// let linktype_name = Linktype::ARCNET_LINUX.get_description().unwrap(); +// assert_eq!(&linktype_name, desc); +// } - #[test] - fn test_from_name() { - let _m = RAWMTX.lock(); +// #[test] +// fn test_from_name() { +// let _m = RAWMTX.lock(); - let ctx = raw::pcap_datalink_name_to_val_context(); - ctx.expect().return_once(|_| 7); +// let ctx = raw::pcap_datalink_name_to_val_context(); +// ctx.expect().return_once(|_| 7); - let linktype = Linktype::from_name("git rekt scrub").unwrap(); - assert_eq!(linktype, Linktype::ARCNET_BSD); +// let linktype = Linktype::from_name("git rekt scrub").unwrap(); +// assert_eq!(linktype, Linktype::ARCNET_BSD); - let ctx = raw::pcap_datalink_name_to_val_context(); - ctx.checkpoint(); - ctx.expect().return_once(|_| -1); +// let ctx = raw::pcap_datalink_name_to_val_context(); +// ctx.checkpoint(); +// ctx.expect().return_once(|_| -1); - let err = Linktype::from_name("git rekt scrub").unwrap_err(); - assert_eq!(err, Error::InvalidLinktype); - } -} +// let err = Linktype::from_name("git rekt scrub").unwrap_err(); +// assert_eq!(err, Error::InvalidLinktype); +// } +// } diff --git a/src/packet.rs b/src/packet.rs index 240ffdbc..d88dd042 100644 --- a/src/packet.rs +++ b/src/packet.rs @@ -60,37 +60,37 @@ impl PartialEq for PacketHeader { impl Eq for PacketHeader {} -#[cfg(test)] -mod tests { - use crate::raw; +// #[cfg(test)] +// mod tests { +// use crate::raw; - use super::*; +// use super::*; - static HEADER: PacketHeader = PacketHeader { - ts: libc::timeval { - tv_sec: 5, - tv_usec: 50, - }, - caplen: 5, - len: 9, - }; +// static HEADER: PacketHeader = PacketHeader { +// ts: libc::timeval { +// tv_sec: 5, +// tv_usec: 50, +// }, +// caplen: 5, +// len: 9, +// }; - #[test] - fn test_packet_header_size() { - use std::mem::size_of; - assert_eq!(size_of::(), size_of::()); - } +// #[test] +// fn test_packet_header_size() { +// use std::mem::size_of; +// assert_eq!(size_of::(), size_of::()); +// } - #[test] - fn test_packet_header_clone() { - // For code coverag purposes. - #[allow(clippy::clone_on_copy)] - let header_clone = HEADER.clone(); - assert_eq!(header_clone, HEADER); - } +// #[test] +// fn test_packet_header_clone() { +// // For code coverag purposes. +// #[allow(clippy::clone_on_copy)] +// let header_clone = HEADER.clone(); +// assert_eq!(header_clone, HEADER); +// } - #[test] - fn test_packet_header_display() { - assert!(!format!("{:?}", HEADER).is_empty()); - } -} +// #[test] +// fn test_packet_header_display() { +// assert!(!format!("{:?}", HEADER).is_empty()); +// } +// } diff --git a/src/stream/mod.rs b/src/stream/mod.rs index 2488baac..b83a69dd 100644 --- a/src/stream/mod.rs +++ b/src/stream/mod.rs @@ -29,26 +29,26 @@ impl Capture { } } -#[cfg(test)] -mod tests { - use crate::{ - capture::{testmod::test_capture, Active}, - codec::testmod::Codec, - raw::testmod::{as_pcap_t, RAWMTX}, - }; - - #[test] - fn test_stream_error() { - let _m = RAWMTX.lock(); - - let mut dummy: isize = 777; - let pcap = as_pcap_t(&mut dummy); - - let test_capture = test_capture::(pcap); - let capture = test_capture.capture; - assert!(!capture.is_nonblock()); - - let result = capture.stream(Codec); - assert!(result.is_err()); - } -} +// #[cfg(test)] +// mod tests { +// use crate::{ +// capture::{testmod::test_capture, Active}, +// codec::testmod::Codec, +// raw::testmod::{as_pcap_t, RAWMTX}, +// }; + +// #[test] +// fn test_stream_error() { +// let _m = RAWMTX.lock(); + +// let mut dummy: isize = 777; +// let pcap = as_pcap_t(&mut dummy); + +// let test_capture = test_capture::(pcap); +// let capture = test_capture.capture; +// assert!(!capture.is_nonblock()); + +// let result = capture.stream(Codec); +// assert!(result.is_err()); +// } +// }