aria2-protocol 0.3.10

Multi-protocol networking stack for aria2-rust: HTTP/HTTPS client, FTP/SFTP, full BitTorrent (DHT/PEX/MSE), and Metalink V3/V4 parser
Documentation
use super::*;
use std::net::{IpAddr, Ipv4Addr};

fn test_addr() -> SocketAddr {
    SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 12345)
}

#[test]
fn test_connection_new() {
    let conn = UtpConnection::new();
    assert_eq!(conn.state(), ConnectionState::Closed);
    assert!(!conn.is_established());
    assert!(conn.remote_addr().is_none());
}

#[test]
fn test_connection_connect() {
    let mut conn = UtpConnection::new();
    let result = conn.connect(test_addr());
    assert!(result.is_ok());
    assert_eq!(conn.state(), ConnectionState::SynSent);
    assert_eq!(conn.remote_addr(), Some(test_addr()));
}

#[test]
fn test_connection_connect_already_connected() {
    let mut conn = UtpConnection::new();
    conn.connect(test_addr()).unwrap();
    let result = conn.connect(test_addr());
    assert!(matches!(result, Err(ConnectionError::AlreadyExists)));
}

#[test]
fn test_connection_close_not_connected() {
    let mut conn = UtpConnection::new();
    let result = conn.close();
    assert!(matches!(result, Err(ConnectionError::NotConnected)));
}

#[test]
fn test_connection_send_data_not_connected() {
    let mut conn = UtpConnection::new();
    let result = conn.send_data(&[1, 2, 3]);
    assert!(matches!(result, Err(ConnectionError::NotConnected)));
}

#[test]
fn test_connection_default() {
    let conn = UtpConnection::default();
    assert_eq!(conn.state(), ConnectionState::Closed);
}

#[test]
fn test_connection_idle_time() {
    let conn = UtpConnection::new();
    let idle = conn.idle_time();
    assert!(idle.as_nanos() > 0 || idle.is_zero());
}

#[test]
fn test_connection_recv_data_empty() {
    let mut conn = UtpConnection::new();
    let data = conn.recv_data();
    assert!(data.is_empty());
}

#[test]
fn test_connection_timeout() {
    let mut conn = UtpConnection::new();
    let result = conn.check_timeout(Duration::ZERO);
    assert!(result);
    assert_eq!(conn.state(), ConnectionState::Closed);
}

#[test]
fn test_connection_no_timeout() {
    let mut conn = UtpConnection::new();
    let result = conn.check_timeout(Duration::from_secs(3600));
    assert!(!result);
}

#[test]
fn send_window_tracks_ledbat_ack_growth_and_timeout_loss() {
    let mut conn = UtpConnection::new();
    let syn = conn.connect(test_addr()).unwrap();
    conn.on_packet_received(&UtpPacket::syn_ack(
        syn.connection_id,
        40,
        syn.seq_nr,
        65_536,
    ))
    .unwrap();

    assert_eq!(conn.congestion_window(), 2 * 1400);
    assert_eq!(conn.send_data(&vec![0x33; 2800]).unwrap().len(), 2);
    assert_eq!(conn.bytes_in_flight(), 2800);

    let mut ack = UtpPacket::ack(syn.connection_id, 2, 40, 65_536);
    ack.timestamp_difference_microseconds = 50_000;
    conn.on_packet_received(&ack).unwrap();
    assert_eq!(conn.bytes_in_flight(), 1400);
    assert!(conn.congestion_window() > 2 * 1400);
    assert_eq!(conn.send_data(&vec![0x44; 1400]).unwrap().len(), 1);

    let before_loss = conn.congestion_window();
    let retransmission = conn
        .retransmit_packet(3, super::RetransmitEvent::Loss)
        .unwrap();
    assert_eq!(retransmission.seq_nr, 3);
    assert!(conn.congestion_window() < before_loss);
    assert_eq!(conn.bytes_in_flight(), 2800);
}

#[test]
fn connection_rtt_uses_local_send_time_and_excludes_retransmits() {
    let mut conn = UtpConnection::new();
    let syn = conn.connect(test_addr()).unwrap();
    conn.syn_retransmitted = true;
    conn.on_packet_received(&UtpPacket::syn_ack(
        syn.connection_id,
        40,
        syn.seq_nr,
        65_536,
    ))
    .unwrap();

    let packet = conn.send_data(b"rtt").unwrap().pop().unwrap();
    conn.send_buffer.back_mut().unwrap().sent_at = Instant::now() - Duration::from_millis(120);
    conn.on_packet_received(&UtpPacket::ack(
        syn.connection_id,
        packet.seq_nr,
        40,
        65_536,
    ))
    .unwrap();
    assert!((Duration::from_millis(118)..=Duration::from_millis(125)).contains(&conn.rtt()));
    assert_eq!(conn.rto(), Duration::from_millis(500));

    let retransmitted = conn.send_data(b"retry").unwrap().pop().unwrap();
    conn.send_buffer.back_mut().unwrap().sent_at = Instant::now() - Duration::from_secs(1);
    conn.retransmit_packet(retransmitted.seq_nr, super::RetransmitEvent::Timeout)
        .unwrap();
    conn.on_packet_received(&UtpPacket::ack(
        syn.connection_id,
        retransmitted.seq_nr,
        40,
        65_536,
    ))
    .unwrap();
    assert!(conn.rtt() < Duration::from_millis(200));
}

#[test]
fn outgoing_timestamp_difference_tracks_remote_delay_sample_across_wrap() {
    let mut conn = UtpConnection::new();
    conn.timestamp_origin = Instant::now() - Duration::from_micros(u64::from(u32::MAX) + 15_000);
    let syn = conn.connect(test_addr()).unwrap();
    assert!(syn.timestamp_microseconds < 100_000);

    let remote_timestamp = conn.timestamp_now_microseconds().wrapping_sub(5_000);
    let mut response = UtpPacket::syn_ack(syn.connection_id, 40, syn.seq_nr, 65_536);
    response.timestamp_microseconds = remote_timestamp;
    conn.on_packet_received(&response).unwrap();
    assert!((4_000..=6_000).contains(&conn.reply_micro));

    let outgoing = conn.send_data(b"clock").unwrap().pop().unwrap();
    assert!(outgoing.timestamp_microseconds < 100_000);
    assert!((4_000..=6_000).contains(&outgoing.timestamp_difference_microseconds));
}