use super::*;
#[test]
fn test_controller_initialization() {
let controller = LedbatController::new();
assert_eq!(controller.get_window_size(), LEDBAT_MIN_CWND * DEFAULT_MSS);
assert_eq!(controller.get_bytes_in_flight(), 0);
assert!(controller.can_send());
assert!(!controller.is_slow_start());
assert_eq!(controller.get_target_delay(), LEDBAT_TARGET_DELAY);
}
#[test]
fn test_controller_with_custom_mss() {
let controller = LedbatController::with_mss(1400);
assert_eq!(controller.get_mss(), 1400);
assert_eq!(controller.get_window_size(), LEDBAT_MIN_CWND * 1400);
}
#[test]
fn test_controller_with_custom_target_delay() {
let controller = LedbatController::with_target_delay(Duration::from_millis(200));
assert_eq!(controller.get_target_delay(), Duration::from_millis(200));
}
#[test]
fn custom_mss_and_target_delay_keep_window_math_defined() {
let zero_mss = LedbatController::with_mss(0);
assert_eq!(zero_mss.get_mss(), 1);
assert_eq!(zero_mss.get_window_packets(), LEDBAT_MIN_CWND);
let huge_mss = LedbatController::with_mss(u32::MAX);
assert_eq!(huge_mss.get_mss(), u32::MAX / LEDBAT_MAX_CWND);
assert_eq!(huge_mss.get_window_packets(), LEDBAT_MIN_CWND);
let mut zero_delay = LedbatController::with_target_delay(Duration::ZERO);
assert_eq!(zero_delay.get_target_delay(), Duration::from_micros(1));
for _ in 0..12 {
zero_delay.on_ack_received(0, 1400);
}
assert!(zero_delay.get_window_size() >= LEDBAT_MIN_CWND * zero_delay.get_mss());
let huge_delay = LedbatController::with_target_delay(Duration::MAX);
assert_eq!(
huge_delay.get_target_delay(),
Duration::from_micros(u64::MAX)
);
}
#[test]
fn test_on_data_sent() {
let mut controller = LedbatController::new();
controller.on_data_sent(1500);
assert_eq!(controller.get_bytes_in_flight(), 1500);
assert!(controller.time_since_last_send().is_some());
controller.on_data_sent(500);
assert_eq!(controller.get_bytes_in_flight(), 2000);
}
#[test]
fn test_can_send() {
let mut controller = LedbatController::new();
assert!(controller.can_send());
let window = controller.get_window_size();
controller.on_data_sent(window);
assert!(!controller.can_send());
controller.on_ack_received(50_000, 1500);
assert!(controller.can_send());
}
#[test]
fn test_available_window() {
let mut controller = LedbatController::new();
let initial_window = controller.available_window();
assert_eq!(initial_window, controller.get_window_size());
controller.on_data_sent(1500);
let available = controller.available_window();
assert_eq!(available, controller.get_window_size() - 1500);
}
#[test]
fn rfc_initial_window_increases_at_most_one_mss_per_ack() {
let mut controller = LedbatController::new();
let initial_cwnd = controller.get_window_size();
controller.on_data_sent(initial_cwnd);
controller.on_ack_received(50_000, 1500);
assert!(controller.get_window_size() > initial_cwnd);
assert!(controller.get_window_size() <= initial_cwnd + controller.get_mss());
assert!(!controller.is_slow_start());
}
#[test]
fn one_minute_base_delay_tracks_the_minimum_delay() {
let mut controller = LedbatController::new();
controller.on_data_sent(controller.get_window_size());
controller.on_ack_received(50_000, 1500); controller.on_ack_received(45_000, 1500); controller.on_ack_received(48_000, 1500);
assert_eq!(
controller.get_base_delay(),
Some(Duration::from_micros(45_000))
);
let high_delay = LEDBAT_TARGET_DELAY.as_micros() as u64 + 50_000; controller.on_ack_received(high_delay, 1500);
assert!(!controller.is_slow_start());
}
#[test]
fn controller_has_no_slow_start_phase() {
let mut controller = LedbatController::new();
for _ in 0..15 {
controller.on_data_sent(1500);
controller.on_ack_received(50_000, 1500);
}
assert!(!controller.is_slow_start());
}
#[test]
fn test_congestion_avoidance_below_target() {
let mut controller = LedbatController::new();
let initial_cwnd = controller.get_window_size();
let low_delay = 50_000; controller.base_delay = Some(20_000); controller.current_delay = low_delay;
controller.on_ack_received(low_delay, 1500);
assert!(controller.get_window_size() >= initial_cwnd);
}
#[test]
fn test_congestion_avoidance_above_target() {
let mut controller = LedbatController::new();
controller.cwnd = 10_000;
controller.bytes_in_flight = controller.cwnd;
controller.on_ack_received(20_000, 1500); controller.bytes_in_flight = controller.cwnd;
controller.on_ack_received(25_000, 1500); controller.bytes_in_flight = controller.cwnd;
controller.on_ack_received(22_000, 1500);
assert_eq!(
controller.get_base_delay(),
Some(Duration::from_micros(20_000))
);
let cwnd_before_high_delay = controller.get_window_size();
let high_delay = 150_000; controller.bytes_in_flight = controller.cwnd;
controller.on_ack_received(high_delay, 1500);
assert!(controller.get_window_size() < cwnd_before_high_delay);
for _ in 0..50 {
controller.bytes_in_flight = controller.cwnd;
controller.on_ack_received(high_delay, 1500);
}
assert!(controller.get_window_size() < cwnd_before_high_delay - 500);
}
#[test]
fn test_on_timeout() {
let mut controller = LedbatController::new();
controller.cwnd = 10_000;
controller.bytes_in_flight = 10_000;
controller.on_timeout();
assert_eq!(controller.get_window_size(), DEFAULT_MSS);
assert!(controller.get_bytes_in_flight() > 0);
assert!(!controller.is_slow_start());
}
#[test]
fn test_on_loss() {
let mut controller = LedbatController::new();
controller.cwnd = 10_000;
controller.bytes_in_flight = 10_000;
let cwnd_before = controller.get_window_size();
controller.on_loss();
assert!(controller.get_window_size() <= cwnd_before / 2);
assert!(!controller.is_slow_start());
}
#[test]
fn test_reset() {
let mut controller = LedbatController::new();
controller.on_data_sent(1500);
controller.on_ack_received(50_000, 1500);
controller.on_data_sent(1500);
controller.reset();
assert_eq!(controller.get_window_size(), LEDBAT_MIN_CWND * DEFAULT_MSS);
assert_eq!(controller.get_bytes_in_flight(), 0);
assert!(!controller.is_slow_start());
assert!(controller.get_base_delay().is_none());
assert_eq!(controller.get_current_delay(), Duration::ZERO);
}
#[test]
fn test_delay_measurements() {
let mut controller = LedbatController::new();
controller.on_ack_received(50_000, 1500);
assert_eq!(
controller.get_base_delay(),
Some(Duration::from_micros(50_000))
);
assert_eq!(
controller.get_current_delay(),
Duration::from_micros(50_000)
);
controller.on_ack_received(80_000, 1500);
assert_eq!(
controller.get_base_delay(),
Some(Duration::from_micros(50_000))
); assert_eq!(
controller.get_current_delay(),
Duration::from_micros(80_000)
);
controller.on_ack_received(30_000, 1500);
assert_eq!(
controller.get_base_delay(),
Some(Duration::from_micros(30_000))
); assert_eq!(
controller.get_current_delay(),
Duration::from_micros(30_000)
);
}
#[test]
fn base_delay_minimum_ages_out_after_ten_minute_windows() {
let mut controller = LedbatController::new();
controller.update_base_delay_at(20_000, 0);
for _ in 0..100 {
controller.update_base_delay_at(50_000, 0);
}
assert_eq!(
controller.get_base_delay(),
Some(Duration::from_micros(20_000))
);
for minute in 1..10 {
controller.update_base_delay_at(50_000, minute);
}
assert_eq!(
controller.get_base_delay(),
Some(Duration::from_micros(20_000))
);
controller.update_base_delay_at(50_000, 10);
assert_eq!(
controller.get_base_delay(),
Some(Duration::from_micros(50_000))
);
}
#[test]
fn test_queuing_delay() {
let mut controller = LedbatController::new();
controller.base_delay = Some(50_000); controller.current_delay = 150_000;
let queuing = controller.get_queuing_delay();
assert_eq!(queuing, Duration::from_micros(100_000)); }
#[test]
fn test_window_bounds() {
let mut controller = LedbatController::new();
controller.cwnd = LEDBAT_MAX_CWND * DEFAULT_MSS + 10000;
controller.bytes_in_flight = u32::MAX;
controller.on_ack_received(50_000, 1500);
assert_eq!(controller.get_window_size(), LEDBAT_MAX_CWND * DEFAULT_MSS);
}
#[test]
fn test_minimum_window() {
let mut controller = LedbatController::new();
controller.cwnd = 100; controller.on_ack_received(200_000, 1500);
assert!(controller.get_window_size() >= LEDBAT_MIN_CWND * DEFAULT_MSS);
}
#[test]
fn test_bytes_in_flight_tracking() {
let mut controller = LedbatController::new();
controller.on_data_sent(1500);
assert_eq!(controller.get_bytes_in_flight(), 1500);
controller.on_data_sent(1500);
assert_eq!(controller.get_bytes_in_flight(), 3000);
controller.on_ack_received(50_000, 1500);
assert_eq!(controller.get_bytes_in_flight(), 1500);
controller.on_ack_received(50_000, 1500);
assert_eq!(controller.get_bytes_in_flight(), 0);
}
#[test]
fn test_delay_sample_count() {
let controller = LedbatController::new();
assert_eq!(controller.delay_sample_count(), 0);
assert!(!controller.has_delay_samples());
let mut controller = controller;
controller.on_ack_received(50_000, 1500);
assert_eq!(controller.delay_sample_count(), 1);
assert!(controller.has_delay_samples());
}
#[test]
fn test_ledbat_queue_delay_scenario() {
let mut controller = LedbatController::new();
for i in 0..3 {
controller.bytes_in_flight = controller.cwnd;
controller.on_ack_received(50_000 - i * 1000, 1500); println!(
"Iteration {}: cwnd = {}, slow_start = {}, base_delay = {:?}",
i,
controller.get_window_size(),
controller.is_slow_start(),
controller.get_base_delay()
);
}
assert!(controller.get_window_size() > LEDBAT_MIN_CWND * DEFAULT_MSS);
assert!(controller.get_base_delay().is_some());
for i in 0..3 {
controller.bytes_in_flight = controller.cwnd;
controller.on_ack_received(150_000, 1500); println!(
"Congestion {}: cwnd = {}, slow_start = {}, queuing_delay = {:?}",
i,
controller.get_window_size(),
controller.is_slow_start(),
controller.get_queuing_delay()
);
}
assert!(!controller.is_slow_start());
}
#[test]
fn test_gain_factor() {
let mut controller = LedbatController::new();
controller.cwnd = 10000;
controller.bytes_in_flight = controller.cwnd;
controller.on_ack_received(20_000, 1500); controller.bytes_in_flight = controller.cwnd;
controller.on_ack_received(25_000, 1500); controller.bytes_in_flight = controller.cwnd;
controller.on_ack_received(22_000, 1500);
assert_eq!(
controller.get_base_delay(),
Some(Duration::from_micros(20_000))
);
let initial_cwnd = controller.get_window_size();
controller.on_data_sent(10_000);
controller.on_ack_received(70_000, 1500);
let new_cwnd = controller.get_window_size();
assert!(new_cwnd > initial_cwnd);
assert!(new_cwnd < initial_cwnd + 100); }
#[test]
fn test_saturating_operations() {
let mut controller = LedbatController::new();
controller.on_data_sent(u32::MAX / 2);
controller.on_data_sent(u32::MAX / 2);
controller.on_ack_received(50_000, u32::MAX);
assert_eq!(controller.get_bytes_in_flight(), 0);
}
#[test]
fn test_time_since_last_send() {
let controller = LedbatController::new();
assert!(controller.time_since_last_send().is_none());
let mut controller = controller;
controller.on_data_sent(1500);
let elapsed = controller.time_since_last_send();
assert!(elapsed.is_some());
assert!(elapsed.unwrap() < Duration::from_millis(100));
}