tests: rework the actually useful tests to live in the integration crate

crates/irtt-server/src/socket_io/ancillary.rs

@@ -545,150 +545,3 @@ impl ControlBuffer {
         &mut self.0
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// Which reply sources need their interface named, which no normal
-    /// interface can show: it takes a host whose route back to a peer leaves by
-    /// a different interface than the request arrived on, and a test host has
-    /// one loopback.
-    #[test]
-    fn only_a_link_local_source_pins_the_egress_interface() {
-        const ARRIVED_ON: u32 = 7;
-
-        for (address, expected, why) in [
-            (
-                "fe80::1",
-                ARRIVED_ON,
-                "a link-local source needs its link named",
-            ),
-            (
-                "fe80::7858:baff:fe91:183d",
-                ARRIVED_ON,
-                "and so does any other one",
-            ),
-            ("2001:db8::1", 0, "a global source identifies itself"),
-            ("fd00::1", 0, "so does a unique-local one"),
-            ("::1", 0, "and loopback"),
-            ("::ffff:127.0.0.2", 0, "and an IPv4-mapped destination"),
-        ] {
-            assert_eq!(
-                egress_interface_index(address.parse().unwrap(), ARRIVED_ON),
-                expected,
-                "{address}: {why}"
-            );
-        }
-    }
-
-    /// What the two listener kinds do with the metadata they did or did not
-    /// get, which is the whole distinction this module rests on: a destination
-    /// is correctness-critical for one of them and irrelevant to the other.
-    #[test]
-    fn only_a_listener_that_needs_a_destination_is_stopped_by_a_missing_one() {
-        let recovered = ReplySource::V4 {
-            address: Ipv4Addr::LOCALHOST,
-        };
-
-        assert_eq!(
-            resolved_reply_source(Some(recovered), true),
-            Some(recovered),
-            "a wildcard listener replies from the destination it recovered"
-        );
-        assert_eq!(
-            resolved_reply_source(None, true),
-            None,
-            "and cannot answer a request whose destination did not arrive"
-        );
-        assert_eq!(
-            resolved_reply_source(None, false),
-            Some(ReplySource::Bound),
-            "an explicit listener never needed one"
-        );
-        assert_eq!(
-            resolved_reply_source(Some(recovered), false),
-            Some(ReplySource::Bound),
-            "and sends from its bind even if one turned up"
-        );
-    }
-
-    /// Which truncation is fatal to whom. A cut payload always is; cut control
-    /// data is fatal only where it may have taken the destination with it.
-    /// Turning a lost *timestamp* into a lost packet would trade a real client
-    /// request for optional precision.
-    #[test]
-    fn control_truncation_only_condemns_a_datagram_whose_destination_it_may_have_taken() {
-        for (flags, require_destination, unusable, why) in [
-            (MsgFlags::empty(), true, false, "a clean wildcard receive"),
-            (MsgFlags::empty(), false, false, "a clean explicit receive"),
-            (
-                MsgFlags::MSG_TRUNC,
-                false,
-                true,
-                "a cut payload is not what the client sent",
-            ),
-            (
-                MsgFlags::MSG_TRUNC,
-                true,
-                true,
-                "and no less so for a wildcard listener",
-            ),
-            (
-                MsgFlags::MSG_CTRUNC,
-                true,
-                true,
-                "cut control data may have taken the destination",
-            ),
-            (
-                MsgFlags::MSG_CTRUNC,
-                false,
-                false,
-                "but for an explicit listener it can only have cost a timestamp",
-            ),
-            (
-                MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC,
-                false,
-                true,
-                "the payload rule still applies",
-            ),
-        ] {
-            assert_eq!(is_unusable(flags, require_destination), unusable, "{why}");
-        }
-    }
-
-    /// A representable kernel reading becomes an instant; anything else becomes
-    /// absent metadata. Note what is *not* rejected here: a reading far from
-    /// now is structurally fine, and judging it belongs to whoever measures
-    /// with it.
-    #[cfg(target_os = "linux")]
-    #[cfg_attr(target_env = "musl", allow(deprecated))]
-    #[test]
-    fn a_kernel_timestamp_converts_only_where_it_describes_an_instant() {
-        assert_eq!(
-            system_time_from_timespec(TimeSpec::new(1, 2))
-                .unwrap()
-                .duration_since(UNIX_EPOCH)
-                .unwrap(),
-            Duration::new(1, 2)
-        );
-        assert_eq!(
-            system_time_from_timespec(TimeSpec::new(0, 0)),
-            Some(UNIX_EPOCH),
-            "the epoch itself is representable"
-        );
-
-        assert_eq!(system_time_from_timespec(TimeSpec::new(-1, 0)), None);
-        assert_eq!(system_time_from_timespec(TimeSpec::new(0, -1)), None);
-        assert_eq!(
-            system_time_from_timespec(TimeSpec::new(0, 1_000_000_000)),
-            None
-        );
-        assert_eq!(
-            system_time_from_timespec(TimeSpec::new(libc::time_t::MIN, libc::c_long::MIN)),
-            None,
-            "and the extremes convert rather than panic"
-        );
-        let _ = system_time_from_timespec(TimeSpec::new(libc::time_t::MAX, 999_999_999));
-    }
-}