refactor(client): move internal client tests to a dedicated sub-module

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

@@ -0,0 +1,515 @@
+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 {
+        duration: Some(Duration::from_secs(5)),
+        interval: Duration::from_millis(250),
+        length: 1472,
+        received_stats: ReceivedStats::Window,
+        stamp_at: StampAt::Midpoint,
+        clock: Clock::Wall,
+        dscp: 46,
+        hmac_key: Some(b"secret".to_vec()),
+        server_fill: Some("rand".to_owned()),
+        ..ClientConfig::default()
+    };
+
+    let params = params_from_config(&config).unwrap();
+    assert_eq!(params.protocol_version, PROTOCOL_VERSION);
+    assert_eq!(params.duration_ns, 5_000_000_000);
+    assert_eq!(params.interval_ns, 250_000_000);
+    assert_eq!(params.length, 1472);
+    assert_eq!(params.received_stats, ReceivedStats::Window);
+    assert_eq!(params.stamp_at, StampAt::Midpoint);
+    assert_eq!(params.clock, Clock::Wall);
+    assert_eq!(params.dscp, 46, "config DSCP codepoint must not be shifted");
+    assert_eq!(
+        params.server_fill.as_ref().map(|fill| fill.value.as_str()),
+        Some("rand")
+    );
+    assert_eq!(config.hmac_key.as_deref(), Some(b"secret".as_slice()));
+}
+
+#[test]
+fn params_from_config_encodes_continuous_duration_as_zero() {
+    let config = ClientConfig {
+        duration: None,
+        ..ClientConfig::default()
+    };
+    assert_eq!(params_from_config(&config).unwrap().duration_ns, 0);
+}
+
+#[test]
+fn params_from_config_accepts_max_dscp_codepoint() {
+    let config = ClientConfig {
+        dscp: 63,
+        ..ClientConfig::default()
+    };
+    assert_eq!(params_from_config(&config).unwrap().dscp, 63);
+}
+
+#[test]
+fn params_from_config_rejects_invalid_dscp_codepoint() {
+    let config = ClientConfig {
+        dscp: 64,
+        ..ClientConfig::default()
+    };
+    assert!(matches!(
+        params_from_config(&config),
+        Err(ClientError::InvalidConfig { .. })
+    ));
+}
+
+#[test]
+fn params_from_config_rejects_oversized_server_fill() {
+    let config = ClientConfig {
+        server_fill: Some("0123456789abcdef0123456789abcdefx".to_owned()),
+        ..ClientConfig::default()
+    };
+    assert!(matches!(
+        params_from_config(&config),
+        Err(ClientError::InvalidConfig { .. })
+    ));
+}
+
+#[test]
+fn address_resolution_connects_to_local_fake_server() {
+    let server = start_fake_server(|socket, tx| {
+        let _ = recv_request(&socket, &tx);
+    });
+    let client = Client::connect(default_test_config(server.addr)).unwrap();
+    client.socket.send(b"ping").unwrap();
+    assert_eq!(server.rx.recv().unwrap(), b"ping");
+    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(ClientTimestamp::now()).unwrap());
+    assert_eq!(negotiated.params, params);
+    assert!(matches!(client.phase, ClientPhase::Open { token: TOKEN }));
+    server.join();
+}
+
+#[test]
+fn open_fails_when_already_open() {
+    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);
+    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    assert_open_started(client.open(ClientTimestamp::now()).unwrap());
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::AlreadyOpen)
+    ));
+    server.join();
+}
+
+#[test]
+fn open_fails_after_close() {
+    let config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    let params = params_from_config(&config).unwrap();
+    let server = start_fake_server(move |socket, tx| {
+        let (_, peer) = recv_request(&socket, &tx);
+        let reply = open_reply(FLAG_OPEN | FLAG_REPLY, TOKEN, &params, None);
+        socket.send_to(&reply, peer).unwrap();
+        let _ = recv_request(&socket, &tx);
+    });
+    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    assert_open_started(client.open(ClientTimestamp::now()).unwrap());
+    client.close(ClientTimestamp::now()).unwrap();
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::AlreadyClosed)
+    ));
+    server.join();
+}
+
+#[test]
+fn open_fails_after_no_test_completed() {
+    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, 0);
+    config.server_addr = server.addr.to_string();
+    let mut client = Client::connect(config).unwrap();
+    assert_no_test_completed(client.open(ClientTimestamp::now()).unwrap());
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::AlreadyCompleted)
+    ));
+    server.join();
+}
+
+#[test]
+fn open_retries_after_first_timeout() {
+    let server = start_fake_server(|socket, tx| {
+        let (first, _) = recv_request(&socket, &tx);
+        let (_, peer) = recv_request(&socket, &tx);
+        let params = Params::decode(&first[4..]).unwrap();
+        let reply = open_reply(FLAG_OPEN | FLAG_REPLY, TOKEN, &params, None);
+        assert_eq!(first[3] & FLAG_OPEN, FLAG_OPEN);
+        socket.send_to(&reply, peer).unwrap();
+    });
+    let config = ClientConfig {
+        open_timeouts: vec![Duration::from_millis(200), Duration::from_millis(500)],
+        ..default_test_config(server.addr)
+    };
+    let mut client = Client::connect(config).unwrap();
+    let outcome = client.open(ClientTimestamp::now()).unwrap();
+    assert_open_started(outcome);
+    assert_eq!(server.rx.iter().take(2).count(), 2);
+    server.join();
+}
+
+#[test]
+fn open_timeout_after_all_timeouts() {
+    let server = timeout_server(Duration::from_millis(700));
+    let config = ClientConfig {
+        open_timeouts: vec![Duration::from_millis(200), Duration::from_millis(200)],
+        ..default_test_config(server.addr)
+    };
+    let mut client = Client::connect(config).unwrap();
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::OpenTimeout)
+    ));
+    assert_eq!(server.rx.iter().take(2).count(), 2);
+    server.join();
+}
+
+#[test]
+fn open_restores_configured_read_timeout_after_timeout() {
+    let server = timeout_server(Duration::from_millis(700));
+    let config = ClientConfig {
+        open_timeouts: vec![Duration::from_millis(200)],
+        socket_config: crate::SocketConfig {
+            recv_timeout: Some(Duration::from_millis(450)),
+            ..crate::SocketConfig::default()
+        },
+        ..default_test_config(server.addr)
+    };
+    let mut client = Client::connect(config).unwrap();
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::OpenTimeout)
+    ));
+
+    let start = std::time::Instant::now();
+    let mut buf = [0_u8; 1];
+    assert!(client.socket.recv(&mut buf).is_err());
+    assert!(start.elapsed() >= Duration::from_millis(350));
+    server.join();
+}
+
+#[test]
+fn strict_negotiation_accepts_identical_params() {
+    let config = ClientConfig::default();
+    let params = params_from_config(&config).unwrap();
+    assert!(validate_negotiated_params(&params, &params, NegotiationPolicy::Strict).is_ok());
+}
+
+#[test]
+fn strict_negotiation_rejects_changed_params() {
+    let config = ClientConfig::default();
+    let requested = params_from_config(&config).unwrap();
+    let mut returned = requested.clone();
+    returned.dscp = 1;
+    assert!(matches!(
+        validate_negotiated_params(&requested, &returned, NegotiationPolicy::Strict),
+        Err(ClientError::NegotiationRejected { .. })
+    ));
+}
+
+#[test]
+fn loose_negotiation_accepts_server_restricted_params() {
+    let config = ClientConfig::default();
+    let requested = params_from_config(&config).unwrap();
+    let mut returned = requested.clone();
+    returned.duration_ns /= 2;
+    returned.length = 0;
+    assert!(validate_negotiated_params(&requested, &returned, NegotiationPolicy::Loose).is_ok());
+}
+
+#[test]
+fn protocol_version_mismatch_fails() {
+    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    config.negotiation_policy = NegotiationPolicy::Loose;
+    let mut params = params_from_config(&config).unwrap();
+    params.protocol_version = 2;
+    let server = open_success_server(params);
+    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::ProtocolVersionMismatch { received: 2, .. })
+    ));
+    server.join();
+}
+
+#[test]
+fn server_rejection_fails_in_normal_mode() {
+    let config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    let params = params_from_config(&config).unwrap();
+    let server = start_fake_server(move |socket, tx| {
+        let (_, peer) = recv_request(&socket, &tx);
+        let reply = open_reply(FLAG_OPEN | FLAG_REPLY | flags::FLAG_CLOSE, 0, &params, None);
+        socket.send_to(&reply, peer).unwrap();
+    });
+    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::ServerRejected)
+    ));
+    server.join();
+}
+
+#[test]
+fn no_test_open_close_succeeds_on_open_reply_close() {
+    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(ClientTimestamp::now()).unwrap());
+    assert_eq!(negotiated.params, params);
+    assert_eq!(client.negotiated.as_ref(), Some(&negotiated));
+    assert!(matches!(
+        client.close(ClientTimestamp::now()),
+        Err(ClientError::NotOpen)
+    ));
+    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(ClientTimestamp::now()).unwrap());
+    assert_eq!(negotiated.params, params);
+    server.join();
+}
+
+#[test]
+fn no_test_rejects_non_close_open_reply() {
+    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 = open_success_server(params);
+    config.server_addr = server.addr.to_string();
+    let mut client = Client::connect(config).unwrap();
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::UnexpectedNoTestReply)
+    ));
+    server.join();
+}
+
+#[test]
+fn no_test_rejects_non_zero_token_with_close_reply() {
+    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, TOKEN);
+    config.server_addr = server.addr.to_string();
+    let mut client = Client::connect(config).unwrap();
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::NonZeroNoTestToken { token: TOKEN })
+    ));
+    server.join();
+}
+
+#[test]
+fn no_test_strict_negotiation_rejects_changed_params() {
+    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    config.run_mode = RunMode::NoTest;
+    let mut params = params_from_config(&config).unwrap();
+    params.dscp = 1;
+    let server = no_test_server(params, 0);
+    config.server_addr = server.addr.to_string();
+    let mut client = Client::connect(config).unwrap();
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::NegotiationRejected { .. })
+    ));
+    server.join();
+}
+
+#[test]
+fn no_test_loose_negotiation_accepts_restricted_params() {
+    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    config.run_mode = RunMode::NoTest;
+    config.negotiation_policy = NegotiationPolicy::Loose;
+    let mut params = params_from_config(&config).unwrap();
+    params.duration_ns /= 2;
+    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(ClientTimestamp::now()).unwrap());
+    assert_eq!(negotiated.params, params);
+    server.join();
+}
+
+#[test]
+fn close_sends_one_close_packet_with_negotiated_token() {
+    let config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    let params = params_from_config(&config).unwrap();
+    let server = start_fake_server(move |socket, tx| {
+        let (_, peer) = recv_request(&socket, &tx);
+        let reply = open_reply(FLAG_OPEN | FLAG_REPLY, TOKEN, &params, None);
+        socket.send_to(&reply, peer).unwrap();
+        let _ = recv_request(&socket, &tx);
+    });
+    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    assert_open_started(client.open(ClientTimestamp::now()).unwrap());
+    let events = client.close(ClientTimestamp::now()).unwrap();
+    assert_eq!(events.len(), 1);
+    let packets: Vec<_> = server.rx.iter().take(2).collect();
+    let close = &packets[1];
+    assert_eq!(close[3], flags::FLAG_CLOSE);
+    assert_eq!(u64::from_le_bytes(close[4..12].try_into().unwrap()), TOKEN);
+    server.join();
+}
+
+#[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_hmac(&key, &request, HMAC_OFFSET).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(ClientTimestamp::now()).unwrap());
+    server.join();
+}
+
+#[test]
+fn hmac_open_rejects_missing_hmac() {
+    let key = b"secret".to_vec();
+    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    config.hmac_key = Some(key);
+    let params = params_from_config(&config).unwrap();
+    let server = start_fake_server(move |socket, tx| {
+        let (_, peer) = recv_request(&socket, &tx);
+        let reply = open_reply(FLAG_OPEN | FLAG_REPLY, TOKEN, &params, None);
+        socket.send_to(&reply, peer).unwrap();
+    });
+    config.server_addr = server.addr.to_string();
+    let mut client = Client::connect(config).unwrap();
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::Protocol(
+            irtt_proto::ProtoError::HmacPresenceMismatch
+        ))
+    ));
+    server.join();
+}
+
+#[test]
+fn hmac_open_rejects_bad_hmac() {
+    let key = b"secret".to_vec();
+    let wrong_key = b"wrong".to_vec();
+    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    config.hmac_key = Some(key);
+    let params = params_from_config(&config).unwrap();
+    let server = start_fake_server(move |socket, tx| {
+        let (_, peer) = recv_request(&socket, &tx);
+        let reply = open_reply(FLAG_OPEN | FLAG_REPLY, TOKEN, &params, Some(&wrong_key));
+        socket.send_to(&reply, peer).unwrap();
+    });
+    config.server_addr = server.addr.to_string();
+    let mut client = Client::connect(config).unwrap();
+    assert!(matches!(
+        client.open(ClientTimestamp::now()),
+        Err(ClientError::Protocol(irtt_proto::ProtoError::BadHmac))
+    ));
+    server.join();
+}
+
+#[test]
+fn hmac_close_packet_includes_valid_hmac() {
+    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_key = key.clone();
+    let server = start_fake_server(move |socket, tx| {
+        let (_, peer) = recv_request(&socket, &tx);
+        let reply = open_reply(FLAG_OPEN | FLAG_REPLY, TOKEN, &params, Some(&server_key));
+        socket.send_to(&reply, peer).unwrap();
+        let _ = recv_request(&socket, &tx);
+    });
+    config.server_addr = server.addr.to_string();
+    let mut client = Client::connect(config).unwrap();
+    assert_open_started(client.open(ClientTimestamp::now()).unwrap());
+    client.close(ClientTimestamp::now()).unwrap();
+    let packets: Vec<_> = server.rx.iter().take(2).collect();
+    let close = &packets[1];
+    assert_eq!(close[3], flags::FLAG_CLOSE | FLAG_HMAC);
+    verify_hmac(&key, close, HMAC_OFFSET).unwrap();
+    assert_eq!(
+        u64::from_le_bytes(close[4 + HMAC_SIZE..12 + HMAC_SIZE].try_into().unwrap()),
+        TOKEN
+    );
+    server.join();
+}
+
+#[test]
+fn minimum_open_timeout_under_200ms_is_rejected() {
+    let config = ClientConfig {
+        open_timeouts: vec![Duration::from_millis(199)],
+        ..ClientConfig::default()
+    };
+    assert!(matches!(
+        Client::connect(config),
+        Err(ClientError::OpenTimeoutTooSmall { .. })
+    ));
+}
+
+#[test]
+fn empty_open_timeouts_is_rejected() {
+    let config = ClientConfig {
+        open_timeouts: vec![],
+        ..ClientConfig::default()
+    };
+    assert!(matches!(
+        Client::connect(config),
+        Err(ClientError::NoOpenTimeouts)
+    ));
+}

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

@@ -0,0 +1,13 @@
+use super::*;
+use crate::config::{NegotiationPolicy, DEFAULT_OPEN_TIMEOUTS};
+use irtt_proto::{
+    echo_packet_len, flags::FLAG_HMAC, flags::FLAG_OPEN, flags::FLAG_REPLY, verify_hmac, Clock,
+    ReceivedStats, StampAt, HMAC_SIZE, MAGIC,
+};
+use std::{thread, time::SystemTime};
+
+mod support;
+use support::*;
+
+mod config_open;
+mod probes_replies;

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

@@ -0,0 +1,269 @@
+use super::*;
+use irtt_proto::{
+    compute_hmac_in_place, echo_packet_len, flags::FLAG_HMAC, flags::FLAG_OPEN, flags::FLAG_REPLY,
+    layout::PacketLayout, Clock, ReceivedStats, StampAt, HMAC_SIZE, MAGIC,
+};
+use std::{
+    net::UdpSocket,
+    sync::mpsc,
+    thread::{self, JoinHandle},
+};
+
+pub(super) const TOKEN: u64 = 0x1234_5678_90ab_cdef;
+pub(super) const HMAC_OFFSET: usize = 4;
+
+pub(super) struct FakeServer {
+    pub(super) addr: SocketAddr,
+    pub(super) rx: mpsc::Receiver<Vec<u8>>,
+    done: JoinHandle<()>,
+}
+
+impl FakeServer {
+    pub(super) fn join(self) {
+        self.done.join().unwrap();
+    }
+}
+
+pub(super) fn default_test_config(addr: SocketAddr) -> ClientConfig {
+    ClientConfig {
+        server_addr: addr.to_string(),
+        open_timeouts: vec![Duration::from_millis(200), Duration::from_millis(200)],
+        ..ClientConfig::default()
+    }
+}
+
+pub(super) fn start_fake_server<F>(handler: F) -> FakeServer
+where
+    F: FnOnce(UdpSocket, mpsc::Sender<Vec<u8>>) + Send + 'static,
+{
+    let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
+    let addr = socket.local_addr().unwrap();
+    let (tx, rx) = mpsc::channel();
+    let done = thread::spawn(move || handler(socket, tx));
+    FakeServer { addr, rx, done }
+}
+
+pub(super) fn recv_request(
+    socket: &UdpSocket,
+    tx: &mpsc::Sender<Vec<u8>>,
+) -> (Vec<u8>, SocketAddr) {
+    let mut buf = [0_u8; 512];
+    let (size, peer) = socket.recv_from(&mut buf).unwrap();
+    let packet = buf[..size].to_vec();
+    tx.send(packet.clone()).unwrap();
+    (packet, peer)
+}
+
+pub(super) fn open_reply(
+    flags: u8,
+    token: u64,
+    params: &Params,
+    hmac_key: Option<&[u8]>,
+) -> Vec<u8> {
+    let mut packet = Vec::new();
+    packet.extend_from_slice(&MAGIC);
+    packet.push(flags | hmac_key.map_or(0, |_| FLAG_HMAC));
+    if hmac_key.is_some() {
+        packet.extend_from_slice(&[0_u8; HMAC_SIZE]);
+    }
+    packet.extend_from_slice(&token.to_le_bytes());
+    packet.extend_from_slice(&params.encode());
+    if let Some(key) = hmac_key {
+        compute_hmac_in_place(key, &mut packet, HMAC_OFFSET).unwrap();
+    }
+    packet
+}
+
+pub(super) fn echo_reply_packet(
+    token: u64,
+    seq: u32,
+    params: &Params,
+    timestamps: &TimestampFields,
+    hmac_key: Option<&[u8]>,
+) -> Vec<u8> {
+    let has_hmac = hmac_key.is_some();
+    let layout = PacketLayout::echo(has_hmac, params);
+    let packet_len = echo_packet_len(has_hmac, params);
+    let mut packet = Vec::with_capacity(packet_len);
+
+    let mut flags = FLAG_REPLY;
+    if has_hmac {
+        flags |= FLAG_HMAC;
+    }
+    packet.extend_from_slice(&MAGIC);
+    packet.push(flags);
+    if has_hmac {
+        packet.extend_from_slice(&[0_u8; HMAC_SIZE]);
+    }
+    packet.extend_from_slice(&token.to_le_bytes());
+    packet.extend_from_slice(&seq.to_le_bytes());
+
+    if layout.recv_count {
+        packet.extend_from_slice(&42_u32.to_le_bytes());
+    }
+    if layout.recv_window {
+        packet.extend_from_slice(&0x07_u64.to_le_bytes());
+    }
+
+    if layout.recv_wall {
+        packet.extend_from_slice(&timestamps.recv_wall.unwrap_or(0).to_le_bytes());
+    }
+    if layout.recv_mono {
+        packet.extend_from_slice(&timestamps.recv_mono.unwrap_or(0).to_le_bytes());
+    }
+    if layout.midpoint_wall {
+        packet.extend_from_slice(&timestamps.midpoint_wall.unwrap_or(0).to_le_bytes());
+    }
+    if layout.midpoint_mono {
+        packet.extend_from_slice(&timestamps.midpoint_mono.unwrap_or(0).to_le_bytes());
+    }
+    if layout.send_wall {
+        packet.extend_from_slice(&timestamps.send_wall.unwrap_or(0).to_le_bytes());
+    }
+    if layout.send_mono {
+        packet.extend_from_slice(&timestamps.send_mono.unwrap_or(0).to_le_bytes());
+    }
+
+    packet.resize(packet_len, 0);
+
+    if let Some(key) = hmac_key {
+        compute_hmac_in_place(key, &mut packet, HMAC_OFFSET).unwrap();
+    }
+    packet
+}
+
+pub(super) fn open_success_server(params: Params) -> FakeServer {
+    start_fake_server(move |socket, tx| {
+        let (_, peer) = recv_request(&socket, &tx);
+        let reply = open_reply(FLAG_OPEN | FLAG_REPLY, TOKEN, &params, None);
+        socket.send_to(&reply, peer).unwrap();
+    })
+}
+
+pub(super) fn no_test_server(params: Params, token: u64) -> FakeServer {
+    start_fake_server(move |socket, tx| {
+        let (request, peer) = recv_request(&socket, &tx);
+        assert_eq!(request[3] & flags::FLAG_CLOSE, flags::FLAG_CLOSE);
+        let reply = open_reply(
+            FLAG_OPEN | FLAG_REPLY | flags::FLAG_CLOSE,
+            token,
+            &params,
+            None,
+        );
+        socket.send_to(&reply, peer).unwrap();
+    })
+}
+
+pub(super) fn timeout_server(wait: Duration) -> FakeServer {
+    start_fake_server(move |socket, tx| {
+        socket.set_read_timeout(Some(wait)).unwrap();
+        while recv_request_timeout(&socket, &tx).is_some() {}
+    })
+}
+
+pub(super) fn recv_request_timeout(
+    socket: &UdpSocket,
+    tx: &mpsc::Sender<Vec<u8>>,
+) -> Option<(Vec<u8>, SocketAddr)> {
+    let mut buf = [0_u8; 512];
+    match socket.recv_from(&mut buf) {
+        Ok((size, peer)) => {
+            let packet = buf[..size].to_vec();
+            tx.send(packet.clone()).unwrap();
+            Some((packet, peer))
+        }
+        Err(_) => None,
+    }
+}
+
+pub(super) fn echo_server(params: Params) -> FakeServer {
+    start_fake_server(move |socket, tx| {
+        let (_, peer) = recv_request(&socket, &tx);
+        let reply = open_reply(FLAG_OPEN | FLAG_REPLY, TOKEN, &params, None);
+        socket.send_to(&reply, peer).unwrap();
+
+        socket
+            .set_read_timeout(Some(Duration::from_secs(5)))
+            .unwrap();
+        loop {
+            let mut buf = [0_u8; 2048];
+            let size = match socket.recv_from(&mut buf) {
+                Ok((size, _)) => size,
+                Err(_) => break,
+            };
+            let packet = buf[..size].to_vec();
+            tx.send(packet.clone()).unwrap();
+
+            if buf[3] & flags::FLAG_CLOSE != 0 {
+                break;
+            }
+
+            let seq = u32::from_le_bytes(buf[12..16].try_into().unwrap());
+            let ts = TimestampFields {
+                recv_wall: Some(1_000_000_000),
+                recv_mono: Some(100_000),
+                send_wall: Some(1_000_100_000),
+                send_mono: Some(200_000),
+                ..Default::default()
+            };
+            let reply_packet = echo_reply_packet(TOKEN, seq, &params, &ts, None);
+            socket.send_to(&reply_packet, peer).unwrap();
+        }
+    })
+}
+
+pub(super) fn assert_open_started(outcome: OpenOutcome) -> NegotiatedParams {
+    match outcome {
+        OpenOutcome::Started {
+            token, negotiated, ..
+        } => {
+            assert_eq!(token, TOKEN);
+            negotiated
+        }
+        OpenOutcome::NoTestCompleted { .. } => panic!("unexpected no-test outcome"),
+    }
+}
+
+pub(super) fn assert_no_test_completed(outcome: OpenOutcome) -> NegotiatedParams {
+    match outcome {
+        OpenOutcome::NoTestCompleted {
+            negotiated, event, ..
+        } => {
+            assert!(matches!(
+                event,
+                ClientEvent::NoTestCompleted {
+                    negotiated: ref event_params,
+                    ..
+                } if *event_params == negotiated
+            ));
+            negotiated
+        }
+        OpenOutcome::Started { .. } => panic!("unexpected started outcome"),
+    }
+}
+
+pub(super) fn open_client_with_echo_server(params: &Params) -> (Client, FakeServer) {
+    let server = echo_server(params.clone());
+    let config = ClientConfig {
+        socket_config: crate::SocketConfig {
+            recv_timeout: Some(Duration::from_millis(200)),
+            ..Default::default()
+        },
+        ..default_test_config(server.addr)
+    };
+    let mut client = Client::connect(config).unwrap();
+    assert_open_started(client.open(ClientTimestamp::now()).unwrap());
+    (client, server)
+}
+
+pub(super) fn default_params() -> Params {
+    Params {
+        protocol_version: 1,
+        duration_ns: 3_000_000_000,
+        interval_ns: 1_000_000_000,
+        received_stats: ReceivedStats::Both,
+        stamp_at: StampAt::Both,
+        clock: Clock::Both,
+        ..Params::default()
+    }
+}