tests(client): cleanup unnecessary tests and hooks

crates/irtt-client/src/client/tests/close.rs

@@ -93,20 +93,6 @@ fn recv_available_stops_after_peer_close() {
     server.join();
 }
 
-#[test]
-fn normal_echo_reply_does_not_close_session() {
-    let params = default_params();
-    let (mut client, server) = open_client_with_echo_server(&params);
-    client.send_probe().unwrap();
-
-    let events = client.recv_once().unwrap();
-    assert!(matches!(events.as_slice(), [ClientEvent::EchoReply { .. }]));
-    assert!(client.send_probe().is_ok());
-
-    client.close().unwrap();
-    server.join();
-}
-
 #[test]
 fn close_flagged_duplicate_emits_duplicate_then_closes() {
     let params = default_params();

crates/irtt-client/src/client/tests/config.rs

@@ -1,24 +1,5 @@
 use super::*;
 
-#[test]
-fn client_config_default() {
-    let config = ClientConfig::default();
-    assert_eq!(config.duration, Some(Duration::from_secs(3)));
-    assert_eq!(config.interval, Duration::from_secs(1));
-    assert_eq!(config.length, 0);
-    assert_eq!(config.received_stats, ReceivedStats::Both);
-    assert_eq!(config.stamp_at, StampAt::Both);
-    assert_eq!(config.clock, Clock::Both);
-    assert_eq!(config.dscp, 0);
-    assert_eq!(config.hmac_key, None);
-    assert_eq!(config.server_fill, None);
-    assert_eq!(config.open_timeouts, DEFAULT_OPEN_TIMEOUTS);
-    assert_eq!(config.run_mode, RunMode::Normal);
-    assert_eq!(config.negotiation_policy, NegotiationPolicy::Strict);
-    assert_eq!(config.probe_timeout, Duration::from_secs(4));
-    assert_eq!(config.max_pending_probes, 4096);
-}
-
 #[test]
 fn params_from_config_maps_compatibility_fields() {
     let config = ClientConfig {

crates/irtt-client/src/client/tests/dscp.rs

@@ -1,5 +1,4 @@
 use super::*;
-use crate::socket_options::socket_traffic_class;
 
 #[test]
 #[cfg(not(any(
@@ -25,20 +24,17 @@ fn normal_open_applies_negotiated_traffic_class_after_open_and_close_clears_it()
     let mut client = Client::connect(config).unwrap();
 
     assert_eq!(
-        socket_traffic_class(&client.socket, client.remote).unwrap() & 0xfc,
+        socket2::SockRef::from(&client.socket).tos_v4().unwrap() & 0xfc,
         0
     );
     assert_open_started(client.open().unwrap());
     assert_eq!(
-        socket_traffic_class(&client.socket, client.remote).unwrap() & 0xfc,
+        socket2::SockRef::from(&client.socket).tos_v4().unwrap() & 0xfc,
         184
     );
 
     client.close().unwrap();
-    assert_eq!(
-        socket_traffic_class(&client.socket, client.remote).unwrap(),
-        0
-    );
+    assert_eq!(socket2::SockRef::from(&client.socket).tos_v4().unwrap(), 0);
     server.join();
 }
 
@@ -69,10 +65,7 @@ fn normal_open_uses_negotiated_traffic_class_not_requested_dscp() {
             negotiated: 0,
         }]
     );
-    assert_eq!(
-        socket_traffic_class(&client.socket, client.remote).unwrap(),
-        0
-    );
+    assert_eq!(socket2::SockRef::from(&client.socket).tos_v4().unwrap(), 0);
     server.join();
 }
 
@@ -128,10 +121,6 @@ fn authenticated_peer_close_clears_negotiated_traffic_class() {
         ]
     ));
 
-    assert_eq!(client.applied_traffic_class, None);
-    assert_eq!(
-        socket_traffic_class(&client.socket, client.remote).unwrap(),
-        0
-    );
+    assert_eq!(socket2::SockRef::from(&client.socket).tos_v4().unwrap(), 0);
     server.join();
 }

crates/irtt-client/src/client/tests/hmac.rs

@@ -1,23 +1,5 @@
 use super::*;
 
-#[test]
-fn hmac_open_success() {
-    let key = b"secret".to_vec();
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
-    config.hmac_key = Some(key.clone());
-    let params = params_from_config(&config).unwrap();
-    let server = start_fake_server(move |socket, tx| {
-        let (request, peer) = recv_request(&socket, &tx);
-        verify_packet_hmac(&key, &request).unwrap();
-        let reply = open_reply(FLAG_OPEN | FLAG_REPLY, TOKEN, &params, Some(&key));
-        socket.send_to(&reply, peer).unwrap();
-    });
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
-    assert_open_started(client.open().unwrap());
-    server.join();
-}
-
 #[test]
 fn hmac_open_ignores_missing_hmac_before_valid_reply() {
     let key = b"secret".to_vec();

crates/irtt-client/src/client/tests/mod.rs

@@ -1,5 +1,5 @@
 use super::*;
-use crate::config::{NegotiationPolicy, DEFAULT_OPEN_TIMEOUTS};
+use crate::config::NegotiationPolicy;
 use crate::{
     session::machine::{
         compute_one_way, compute_rtt, params_from_config, sequence_is_after, sequence_is_before,

crates/irtt-client/src/client/tests/negotiation.rs

@@ -17,38 +17,6 @@ fn rejection_reason(requested: &Params, returned: &Params, policy: NegotiationPo
     }
 }
 
-#[test]
-fn strict_negotiation_accepts_identical_params() {
-    let config = ClientConfig::default();
-    let params = params_from_config(&config).unwrap();
-    let negotiated = assert_negotiates(&params, &params, NegotiationPolicy::Strict);
-    assert_eq!(negotiated.params, params);
-    assert!(negotiated.restrictions.is_empty());
-}
-
-#[test]
-fn strict_negotiation_rejects_changed_params() {
-    let config = ClientConfig {
-        dscp: 46,
-        ..ClientConfig::default()
-    };
-    let requested = params_from_config(&config).unwrap();
-    assert_eq!(
-        requested.dscp, 184,
-        "codepoint 46 must become raw wire byte 184"
-    );
-    let mut returned = requested.clone();
-    returned.dscp = 0;
-    assert_eq!(
-        rejection_reason(&requested, &returned, NegotiationPolicy::Strict),
-        NegotiationRestriction::DscpChanged {
-            requested: 46,
-            negotiated: 0,
-        }
-        .message()
-    );
-}
-
 #[test]
 fn loose_negotiation_accepts_server_restricted_params() {
     let config = ClientConfig::default();
@@ -88,79 +56,6 @@ fn loose_negotiation_rejects_non_positive_returned_interval() {
     }
 }
 
-#[test]
-fn loose_negotiation_accepts_documented_duration_combinations() {
-    let finite_config = ClientConfig::default();
-    let requested_finite = params_from_config(&finite_config).unwrap();
-
-    let returned_same_finite = requested_finite.clone();
-    assert!(assert_negotiates(
-        &requested_finite,
-        &returned_same_finite,
-        NegotiationPolicy::Loose
-    )
-    .restrictions
-    .is_empty());
-
-    let mut returned_shorter_finite = requested_finite.clone();
-    returned_shorter_finite.duration_ns /= 2;
-    assert_eq!(
-        assert_negotiates(
-            &requested_finite,
-            &returned_shorter_finite,
-            NegotiationPolicy::Loose
-        )
-        .restrictions,
-        vec![NegotiationRestriction::DurationReduced {
-            requested_ns: requested_finite.duration_ns,
-            negotiated_ns: returned_shorter_finite.duration_ns,
-        }]
-    );
-
-    let continuous_config = ClientConfig {
-        duration: None,
-        ..ClientConfig::default()
-    };
-    let requested_continuous = params_from_config(&continuous_config).unwrap();
-
-    let returned_continuous = requested_continuous.clone();
-    assert!(assert_negotiates(
-        &requested_continuous,
-        &returned_continuous,
-        NegotiationPolicy::Loose
-    )
-    .restrictions
-    .is_empty());
-
-    let mut returned_finite = requested_continuous.clone();
-    returned_finite.duration_ns = 1_000_000_000;
-    assert_eq!(
-        assert_negotiates(
-            &requested_continuous,
-            &returned_finite,
-            NegotiationPolicy::Loose
-        )
-        .restrictions,
-        vec![NegotiationRestriction::DurationReduced {
-            requested_ns: requested_continuous.duration_ns,
-            negotiated_ns: returned_finite.duration_ns,
-        }]
-    );
-}
-
-#[test]
-fn loose_negotiation_rejects_finite_request_returned_continuous() {
-    let config = ClientConfig::default();
-    let requested = params_from_config(&config).unwrap();
-    let mut returned = requested.clone();
-    returned.duration_ns = 0;
-
-    assert_eq!(
-        rejection_reason(&requested, &returned, NegotiationPolicy::Loose),
-        "server returned continuous duration for finite request"
-    );
-}
-
 #[test]
 fn loose_negotiation_rejects_negative_returned_length() {
     let config = ClientConfig::default();
@@ -238,26 +133,6 @@ fn loose_negotiation_records_dscp_disabled_by_server() {
     );
 }
 
-#[test]
-fn strict_negotiation_rejects_dscp_disabled_by_server_as_specific_restriction() {
-    let config = ClientConfig {
-        dscp: 46,
-        ..ClientConfig::default()
-    };
-    let requested = params_from_config(&config).unwrap();
-    let mut returned = requested.clone();
-    returned.dscp = 0;
-
-    assert_eq!(
-        rejection_reason(&requested, &returned, NegotiationPolicy::Strict),
-        NegotiationRestriction::DscpChanged {
-            requested: 46,
-            negotiated: 0,
-        }
-        .message()
-    );
-}
-
 #[test]
 fn negotiation_rejects_unsupported_dscp_changes() {
     let config = ClientConfig {

crates/irtt-client/src/client/tests/no_test.rs

@@ -113,19 +113,3 @@ fn open_fails_after_no_test_completed() {
     assert!(matches!(client.open(), Err(ClientError::AlreadyCompleted)));
     server.join();
 }
-
-#[test]
-fn no_test_success_validates_params() {
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
-    config.run_mode = RunMode::NoTest;
-    let params = params_from_config(&config).unwrap();
-    let server = no_test_server(params.clone(), 0);
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
-
-    let negotiated = assert_no_test_completed(client.open().unwrap());
-    assert_eq!(negotiated.params, params);
-
-    assert_eq!(client.applied_traffic_class, None);
-    server.join();
-}

crates/irtt-client/src/client/tests/open.rs

@@ -136,20 +136,6 @@ fn post_token_negotiation_failure_sends_cleanup_close() {
     server.join();
 }
 
-#[test]
-fn successful_open_handshake() {
-    let config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
-    let params = params_from_config(&config).unwrap();
-    let server = open_success_server(params.clone());
-    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
-
-    let negotiated = assert_open_started(client.open().unwrap());
-    assert_eq!(negotiated.params, params);
-
-    assert_eq!(client.applied_traffic_class, Some(0));
-    server.join();
-}
-
 #[test]
 fn successful_open_restores_configured_receive_timeout() {
     let config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));

crates/irtt-client/src/client/tests/ttl.rs

@@ -1,5 +1,3 @@
-use crate::socket_options::socket_ttl;
-
 use super::*;
 
 #[test]
@@ -27,13 +25,13 @@ fn connect_applies_configured_ipv4_ttl_before_open_and_close_preserves_it() {
     config.socket_config.ttl = Some(64);
     let mut client = Client::connect(config).unwrap();
 
-    assert_eq!(socket_ttl(&client.socket, client.remote).unwrap(), 64);
+    assert_eq!(socket2::SockRef::from(&client.socket).ttl_v4().unwrap(), 64);
 
     client.open().unwrap();
     server.join();
 
     client.close().unwrap();
-    assert_eq!(socket_ttl(&client.socket, client.remote).unwrap(), 64);
+    assert_eq!(socket2::SockRef::from(&client.socket).ttl_v4().unwrap(), 64);
 }
 
 #[test]