refactor(structure): run tests as unit tests and remove lib functionality

34 files changed, 212 insertions, 206 deletions

diff --git a/src/lib.rs b/src/lib.rs
deleted file mode 100644
index 99f0a39..0000000
--- a/src/lib.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-mod display;
-pub mod network;
-
-use display::display_loop;
-use network::{Connection, Sniffer, Utilization, DnsQueue, resolve_connections};
-
-use ::std::net::IpAddr;
-
-use ::pnet::datalink::{DataLinkReceiver, NetworkInterface};
-use ::std::collections::HashMap;
-use ::std::sync::atomic::{AtomicBool, Ordering};
-use ::std::sync::{Arc, Mutex};
-use ::std::{thread, time};
-use ::termion::event::{Event, Key};
-use ::tui::backend::Backend;
-use ::tui::Terminal;
-
-pub struct OsInput {
-    pub network_interface: NetworkInterface,
-    pub network_frames: Box<DataLinkReceiver>,
-    pub get_open_sockets: fn() -> HashMap<Connection, String>,
-    pub keyboard_events: Box<Iterator<Item = Event> + Send + Sync + 'static>,
-    pub lookup_addr: Box<Fn(&IpAddr) -> Option<String> + Send + Sync + 'static>
-}
-
-pub fn start<B>(terminal_backend: B, os_input: OsInput)
-where
-    B: Backend + Send + 'static,
-{
-    let running = Arc::new(AtomicBool::new(true));
-
-    let keyboard_events = os_input.keyboard_events; // TODO: as methods in os_interface
-    let get_open_sockets = os_input.get_open_sockets;
-    let lookup_addr = os_input.lookup_addr;
-
-    let stdin_handler = thread::spawn({
-        let running = running.clone();
-        move || {
-            for evt in keyboard_events {
-                match evt {
-                    Event::Key(Key::Ctrl('c')) | Event::Key(Key::Char('q')) => {
-                        // TODO: exit faster
-                        running.store(false, Ordering::Relaxed);
-                        break;
-                    }
-                    _ => (),
-                };
-            }
-        }
-    });
-
-    let mut sniffer = Sniffer::new(os_input.network_interface, os_input.network_frames);
-    let network_utilization = Arc::new(Mutex::new(Utilization::new()));
-
-    let dns_queue = Arc::new(DnsQueue::new());
-    let ip_to_host = Arc::new(Mutex::new(HashMap::new()));
-
-    let dns_handler = thread::spawn({
-        let running = running.clone();
-        let dns_queue = dns_queue.clone();
-        let ip_to_host = ip_to_host.clone();
-        move || {
-            while running.load(Ordering::Relaxed) {
-                let jobs = dns_queue.wait_for_jobs();
-                for ip in jobs {
-                    if let Some(addr) = lookup_addr(&IpAddr::V4(ip.clone())) {
-                        ip_to_host.lock().unwrap().insert(ip, addr);
-                    }
-                }
-            }
-        }
-    });
-
-    let display_handler = thread::spawn({
-        let running = running.clone();
-        let network_utilization = network_utilization.clone();
-        let ip_to_host = ip_to_host.clone();
-        let dns_queue = dns_queue.clone();
-        move || {
-            let mut terminal = Terminal::new(terminal_backend).unwrap();
-            terminal.clear().unwrap();
-            terminal.hide_cursor().unwrap();
-            while running.load(Ordering::Relaxed) {
-                let connections_to_procs = {
-                    let open_sockets = get_open_sockets();
-                    let ip_to_host = ip_to_host.lock().unwrap();
-                    let (unresolved_ips, connections_to_procs) = resolve_connections(open_sockets, &ip_to_host);
-                    dns_queue.add_ips_to_resolve(unresolved_ips);
-                    connections_to_procs
-                };
-                {
-                    let mut network_utilization = network_utilization.lock().unwrap();
-                    let utilization = network_utilization.clone_and_reset();
-                    display_loop(&utilization, &mut terminal, connections_to_procs);
-                }
-                thread::sleep(time::Duration::from_secs(1));
-            }
-            terminal.clear().unwrap();
-            terminal.show_cursor().unwrap();
-            dns_queue.end();
-        }
-    });
-
-    let sniffing_handler = thread::spawn(move || {
-        while running.load(Ordering::Relaxed) {
-            if let Some(segment) = sniffer.next() {
-                network_utilization.lock().unwrap().update(&segment)
-            }
-        }
-    });
-    display_handler.join().unwrap();
-    sniffing_handler.join().unwrap();
-    stdin_handler.join().unwrap();
-    dns_handler.join().unwrap();
-}
diff --git a/src/main.rs b/src/main.rs
index c85b555..8121894 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,22 @@
+mod display;
+mod network;
 mod os;
+#[cfg(test)]
+mod tests;
+
+use display::display_loop;
+use network::{resolve_connections, Connection, DnsQueue, Sniffer, Utilization};
+
+use ::std::net::IpAddr;
+
+use ::pnet::datalink::{DataLinkReceiver, NetworkInterface};
+use ::std::collections::HashMap;
+use ::std::sync::atomic::{AtomicBool, Ordering};
+use ::std::sync::{Arc, Mutex};
+use ::std::{thread, time};
+use ::termion::event::{Event, Key};
+use ::tui::backend::Backend;
+use ::tui::Terminal;
 
 use ::std::io;
 use ::termion::raw::IntoRawMode;
@@ -19,7 +37,7 @@ fn main() {
         "Sorry, no implementations for platforms other than linux yet :( - PRs welcome!"
     );
 
-    use os::{get_datalink_channel, get_interface, get_open_sockets, KeyboardEvents, lookup_addr};
+    use os::{get_datalink_channel, get_interface, get_open_sockets, lookup_addr, KeyboardEvents};
 
     let opt = Opt::from_args();
     let stdout = io::stdout().into_raw_mode().unwrap();
@@ -30,13 +48,113 @@ fn main() {
     let network_frames = get_datalink_channel(&network_interface);
     let lookup_addr = Box::new(lookup_addr);
 
-    let os_input = what::OsInput {
+    let os_input = OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
 
-    what::start(terminal_backend, os_input)
+    start(terminal_backend, os_input)
+}
+
+pub struct OsInput {
+    pub network_interface: NetworkInterface,
+    pub network_frames: Box<DataLinkReceiver>,
+    pub get_open_sockets: fn() -> HashMap<Connection, String>,
+    pub keyboard_events: Box<Iterator<Item = Event> + Send + Sync + 'static>,
+    pub lookup_addr: Box<Fn(&IpAddr) -> Option<String> + Send + Sync + 'static>,
+}
+
+pub fn start<B>(terminal_backend: B, os_input: OsInput)
+where
+    B: Backend + Send + 'static,
+{
+    let running = Arc::new(AtomicBool::new(true));
+
+    let keyboard_events = os_input.keyboard_events; // TODO: as methods in os_interface
+    let get_open_sockets = os_input.get_open_sockets;
+    let lookup_addr = os_input.lookup_addr;
+
+    let stdin_handler = thread::spawn({
+        let running = running.clone();
+        move || {
+            for evt in keyboard_events {
+                match evt {
+                    Event::Key(Key::Ctrl('c')) | Event::Key(Key::Char('q')) => {
+                        // TODO: exit faster
+                        running.store(false, Ordering::Relaxed);
+                        break;
+                    }
+                    _ => (),
+                };
+            }
+        }
+    });
+
+    let mut sniffer = Sniffer::new(os_input.network_interface, os_input.network_frames);
+    let network_utilization = Arc::new(Mutex::new(Utilization::new()));
+
+    let dns_queue = Arc::new(DnsQueue::new());
+    let ip_to_host = Arc::new(Mutex::new(HashMap::new()));
+
+    let dns_handler = thread::spawn({
+        let running = running.clone();
+        let dns_queue = dns_queue.clone();
+        let ip_to_host = ip_to_host.clone();
+        move || {
+            while running.load(Ordering::Relaxed) {
+                let jobs = dns_queue.wait_for_jobs();
+                for ip in jobs {
+                    if let Some(addr) = lookup_addr(&IpAddr::V4(ip.clone())) {
+                        ip_to_host.lock().unwrap().insert(ip, addr);
+                    }
+                }
+            }
+        }
+    });
+
+    let display_handler = thread::spawn({
+        let running = running.clone();
+        let network_utilization = network_utilization.clone();
+        let ip_to_host = ip_to_host.clone();
+        let dns_queue = dns_queue.clone();
+        move || {
+            let mut terminal = Terminal::new(terminal_backend).unwrap();
+            terminal.clear().unwrap();
+            terminal.hide_cursor().unwrap();
+            while running.load(Ordering::Relaxed) {
+                let connections_to_procs = {
+                    let open_sockets = get_open_sockets();
+                    let ip_to_host = ip_to_host.lock().unwrap();
+                    let (unresolved_ips, connections_to_procs) =
+                        resolve_connections(open_sockets, &ip_to_host);
+                    dns_queue.add_ips_to_resolve(unresolved_ips);
+                    connections_to_procs
+                };
+                {
+                    let mut network_utilization = network_utilization.lock().unwrap();
+                    let utilization = network_utilization.clone_and_reset();
+                    display_loop(&utilization, &mut terminal, connections_to_procs);
+                }
+                thread::sleep(time::Duration::from_secs(1));
+            }
+            terminal.clear().unwrap();
+            terminal.show_cursor().unwrap();
+            dns_queue.end();
+        }
+    });
+
+    let sniffing_handler = thread::spawn(move || {
+        while running.load(Ordering::Relaxed) {
+            if let Some(segment) = sniffer.next() {
+                network_utilization.lock().unwrap().update(&segment)
+            }
+        }
+    });
+    display_handler.join().unwrap();
+    sniffing_handler.join().unwrap();
+    stdin_handler.join().unwrap();
+    dns_handler.join().unwrap();
 }
diff --git a/src/network/connection.rs b/src/network/connection.rs
index 34194c1..5af3c32 100644
--- a/src/network/connection.rs
+++ b/src/network/connection.rs
@@ -26,14 +26,14 @@ impl fmt::Display for Protocol {
 pub struct Socket {
     pub ip: Ipv4Addr,
     pub port: u16,
-    host_addr: Option<String>
+    host_addr: Option<String>,
 }
 
 impl Socket {
     pub fn clone_host_or_ip(&self) -> String {
         match &self.host_addr {
             Some(host_addr) => host_addr.clone(),
-            None => self.ip.to_string()
+            None => self.ip.to_string(),
         }
     }
 }
@@ -43,7 +43,7 @@ impl Ord for Socket {
         let ip_eq = self.ip.cmp(&other.ip); // TODO: also port
         match ip_eq {
             Ordering::Equal => self.port.cmp(&other.port),
-            _ => ip_eq
+            _ => ip_eq,
         }
     }
 }
@@ -72,12 +72,8 @@ impl Hash for Socket {
 impl fmt::Display for Socket {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self.host_addr {
-            Some(host_addr) => {
-                write!(f, "{}:{}", host_addr, self.port)
-            },
-            None => {
-                write!(f, "{}:{}", self.ip, self.port)
-            }
+            Some(host_addr) => write!(f, "{}:{}", host_addr, self.port),
+            None => write!(f, "{}:{}", self.ip, self.port),
         }
     }
 }
@@ -106,21 +102,19 @@ impl Connection {
         protocol: Protocol,
     ) -> Option<Self> {
         match (local_socket, remote_socket) {
-            (SocketAddr::V4(local_socket), SocketAddr::V4(remote_socket)) => {
-                Some(Connection {
-                    local_socket: Socket {
-                        ip: *local_socket.ip(),
-                        port: local_socket.port(),
-                        host_addr: None,
-                    },
-                    remote_socket: Socket {
-                        ip: *remote_socket.ip(),
-                        port: remote_socket.port(),
-                        host_addr: None,
-                    },
-                    protocol,
-                })
-            },
+            (SocketAddr::V4(local_socket), SocketAddr::V4(remote_socket)) => Some(Connection {
+                local_socket: Socket {
+                    ip: *local_socket.ip(),
+                    port: local_socket.port(),
+                    host_addr: None,
+                },
+                remote_socket: Socket {
+                    ip: *remote_socket.ip(),
+                    port: remote_socket.port(),
+                    host_addr: None,
+                },
+                protocol,
+            }),
             (_, _) => None,
         }
     }
diff --git a/src/network/dns_queue.rs b/src/network/dns_queue.rs
index 93728e8..3072314 100644
--- a/src/network/dns_queue.rs
+++ b/src/network/dns_queue.rs
@@ -1,19 +1,18 @@
-
 use ::std::net::Ipv4Addr;
 
 use ::std::mem::swap;
-use ::std::sync::{Mutex, Condvar};
+use ::std::sync::{Condvar, Mutex};
 
 pub struct DnsQueue {
     jobs: Mutex<Vec<Ipv4Addr>>,
-    cvar: Condvar
+    cvar: Condvar,
 }
 
 impl DnsQueue {
     pub fn new() -> Self {
         DnsQueue {
             jobs: Mutex::new(Vec::new()),
-            cvar: Condvar::new()
+            cvar: Condvar::new(),
         }
     }
 }
@@ -28,7 +27,7 @@ impl DnsQueue {
         let mut jobs = self.cvar.wait(self.jobs.lock().unwrap()).unwrap();
         let mut new_jobs = Vec::new();
         swap(&mut new_jobs, &mut jobs);
-        new_jobs 
+        new_jobs
     }
     pub fn end(&self) {
         self.cvar.notify_all();
diff --git a/src/network/mod.rs b/src/network/mod.rs
index 3bb54d7..7590875 100644
--- a/src/network/mod.rs
+++ b/src/network/mod.rs
@@ -1,11 +1,11 @@
 mod connection;
-mod sniffer;
-mod utilization;
 mod dns_queue;
 mod resolve_connections;
+mod sniffer;
+mod utilization;
 
 pub use connection::*;
-pub use sniffer::*;
-pub use utilization::*;
 pub use dns_queue::*;
 pub use resolve_connections::*;
+pub use sniffer::*;
+pub use utilization::*;
diff --git a/src/network/resolve_connections.rs b/src/network/resolve_connections.rs
index ee70ade..be09d2d 100644
--- a/src/network/resolve_connections.rs
+++ b/src/network/resolve_connections.rs
@@ -1,11 +1,11 @@
 use crate::Connection;
 
-use ::std::net::Ipv4Addr;
 use ::std::collections::HashMap;
+use ::std::net::Ipv4Addr;
 
-pub fn resolve_connections (
+pub fn resolve_connections(
     open_sockets: HashMap<Connection, String>,
-    ip_to_host: &HashMap<Ipv4Addr, String>
+    ip_to_host: &HashMap<Ipv4Addr, String>,
 ) -> (Vec<Ipv4Addr>, HashMap<Connection, String>) {
     let mut unresolved_ips = vec![];
     let mut resolved_connections_to_procs: HashMap<Connection, String> = HashMap::new();
diff --git a/src/os/linux.rs b/src/os/linux.rs
index e14a351..bdac6c1 100644
--- a/src/os/linux.rs
+++ b/src/os/linux.rs
@@ -10,7 +10,7 @@ use ::std::net::IpAddr;
 
 use ::procfs::FDTarget;
 
-use what::network::{Connection, Protocol};
+use crate::network::{Connection, Protocol};
 
 pub struct KeyboardEvents;
 
@@ -81,7 +81,7 @@ pub fn get_open_sockets() -> HashMap<Connection, String> {
 
 pub fn lookup_addr(ip: &IpAddr) -> Option<String> {
     if let Ok(addr) = ::dns_lookup::lookup_addr(ip) {
-        return Some(addr)
+        return Some(addr);
     }
     None
 }
diff --git a/tests/fakes/fake_input.rs b/src/tests/fakes/fake_input.rs
index 9ab1624..6007b71 100644
--- a/tests/fakes/fake_input.rs
+++ b/src/tests/fakes/fake_input.rs
@@ -6,7 +6,7 @@ use ::std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use ::std::{thread, time};
 use ::termion::event::Event;
 
-use what::network::{Connection, Protocol};
+use crate::network::{Connection, Protocol};
 
 pub struct KeyboardEvents {
     pub events: Vec<Option<Event>>,
@@ -143,11 +143,11 @@ pub fn get_interface() -> NetworkInterface {
     interface
 }
 
-pub fn create_fake_lookup_addr(ips_to_hosts: HashMap<IpAddr, String>) -> Box<Fn(&IpAddr) -> Option<String> + Send + Sync + 'static> {
-    Box::new(move |ip| {
-        match ips_to_hosts.get(ip) {
-            Some(host) => Some(host.clone()),
-            None => None
-        }
+pub fn create_fake_lookup_addr(
+    ips_to_hosts: HashMap<IpAddr, String>,
+) -> Box<Fn(&IpAddr) -> Option<String> + Send + Sync + 'static> {
+    Box::new(move |ip| match ips_to_hosts.get(ip) {
+        Some(host) => Some(host.clone()),
+        None => None,
     })
 }
diff --git a/tests/fakes/fake_output.rs b/src/tests/fakes/fake_output.rs
index 6fb356c..6fb356c 100644
--- a/tests/fakes/fake_output.rs
+++ b/src/tests/fakes/fake_output.rs
diff --git a/tests/fakes/mod.rs b/src/tests/fakes/mod.rs
index 90009d8..dcd441b 100644
--- a/tests/fakes/mod.rs
+++ b/src/tests/fakes/mod.rs
@@ -1,5 +1,3 @@
-extern crate what;
-
 mod fake_input;
 mod fake_output;
 
diff --git a/tests/cli.rs b/src/tests/mod.rs
index 83f298b..b3a5d9d 100644
--- a/tests/cli.rs
+++ b/src/tests/mod.rs
@@ -1,7 +1,10 @@
 mod fakes;
 
 use fakes::TerminalEvent::*;
-use fakes::{get_interface, get_open_sockets, KeyboardEvents, NetworkFrames, TestBackend, create_fake_lookup_addr};
+use fakes::{
+    create_fake_lookup_addr, get_interface, get_open_sockets, KeyboardEvents, NetworkFrames,
+    TestBackend,
+};
 
 use ::insta::assert_snapshot;
 use ::std::sync::{Arc, Mutex};
@@ -63,14 +66,14 @@ fn basic_startup() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    let os_input = what::OsInput {
+    let os_input = crate::OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
-    what::start(backend, os_input);
+    crate::start(backend, os_input);
 
     let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
@@ -104,14 +107,14 @@ fn one_packet_of_traffic() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    let os_input = what::OsInput {
+    let os_input = crate::OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
-    what::start(backend, os_input);
+    crate::start(backend, os_input);
 
     let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
@@ -157,14 +160,14 @@ fn bi_directional_traffic() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    let os_input = what::OsInput {
+    let os_input = crate::OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
-    what::start(backend, os_input);
+    crate::start(backend, os_input);
 
     let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
@@ -210,14 +213,14 @@ fn multiple_packets_of_traffic_from_different_connections() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    let os_input = what::OsInput {
+    let os_input = crate::OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
-    what::start(backend, os_input);
+    crate::start(backend, os_input);
 
     let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
@@ -263,14 +266,14 @@ fn multiple_packets_of_traffic_from_single_connection() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    let os_input = what::OsInput {
+    let os_input = crate::OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
-    what::start(backend, os_input);
+    crate::start(backend, os_input);
 
     let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
@@ -316,14 +319,14 @@ fn one_process_with_multiple_connections() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    let os_input = what::OsInput {
+    let os_input = crate::OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
-    what::start(backend, os_input);
+    crate::start(backend, os_input);
 
     let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
@@ -383,14 +386,14 @@ fn multiple_processes_with_multiple_connections() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    let os_input = what::OsInput {
+    let os_input = crate::OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
-    what::start(backend, os_input);
+    crate::start(backend, os_input);
 
     let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
@@ -436,14 +439,14 @@ fn multiple_connections_from_remote_ip() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    let os_input = what::OsInput {
+    let os_input = crate::OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
-    what::start(backend, os_input);
+    crate::start(backend, os_input);
 
     let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
@@ -491,14 +494,14 @@ fn sustained_traffic_from_one_process() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    let os_input = what::OsInput {
+    let os_input = crate::OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
-    what::start(backend, os_input);
+    crate::start(backend, os_input);
 
     let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
@@ -560,14 +563,14 @@ fn sustained_traffic_from_multiple_processes() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    let os_input = what::OsInput {
+    let os_input = crate::OsInput {
         network_interface,
         network_frames,
         get_open_sockets,
         keyboard_events,
-        lookup_addr
+        lookup_addr,
     };
-    what::start(backend, os_input);
+    crate::start(backend, os_input);
 
     let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
@@ -657,14 +660,14 @@ fn sustained_traffic_from_multiple_processes_bi_directional() {
     let network_interface = get_interface();
     let lookup_addr = create_fake_lookup_addr(HashMap::new());
 
-    le