From 4c0dc07ba5b19c85d3942bab0163df3ef6c5b2a6 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 4 Sep 2026 00:01:17 +0200 Subject: [PATCH] Make the Rust suite green and stop silently ignoring packages exact_reliable_acks_clear_more_than_one_ack_window_of_fragments has been failing on main. It was not a defect: send_many returned 32 packets where the test expected 40, and 32 is exactly CULTNET_RUDP_RELIABLE_SEND_WINDOW_PACKETS. The reliable send window landed and this test kept asserting the pre-window behaviour, so a test whose name is about crossing an ack window had stopped crossing one. It now asserts that a window's worth leaves immediately, that the remaining eight fragments queue, and that acknowledgements promote them until every fragment is delivered -- the same loop packages/cultnet-rs/tests /cultnet.rs already uses for this contract. All three Rust crates are green: 46, 95 and 7. The NuGet packages rule hides every language package until one is named in the re-include list, and cultmath, cultmesh-browser and cultmesh-kotlin were never added. Nothing is currently lost -- every source file in them is tracked -- but any new file added to those three would have been dropped in silence. cultmesh-rs hit this on the way in. Co-Authored-By: Claude Opus 5 --- .gitignore | 6 +++++ packages/cultnet-rs/tests/rudp_server_hub.rs | 27 ++++++++++++++++---- 2 files changed, 28 insertions(+), 5 deletions(-) diff --git a/.gitignore b/.gitignore index ce48c2dc..656fafa0 100644 --- a/.gitignore +++ b/.gitignore @@ -309,6 +309,12 @@ node_modules/ !packages/cultnet-rs/** !packages/cultmesh-rs/ !packages/cultmesh-rs/** +!packages/cultmath/ +!packages/cultmath/** +!packages/cultmesh-browser/ +!packages/cultmesh-browser/** +!packages/cultmesh-kotlin/ +!packages/cultmesh-kotlin/** packages/**/node_modules/ packages/**/dist/ packages/**/dist-test/ diff --git a/packages/cultnet-rs/tests/rudp_server_hub.rs b/packages/cultnet-rs/tests/rudp_server_hub.rs index a8a2c114..cdc6e390 100644 --- a/packages/cultnet-rs/tests/rudp_server_hub.rs +++ b/packages/cultnet-rs/tests/rudp_server_hub.rs @@ -1,3 +1,4 @@ +use std::collections::VecDeque; use std::net::UdpSocket; use std::time::Duration; @@ -317,16 +318,32 @@ fn exact_reliable_acks_clear_more_than_one_ack_window_of_fragments() -> Result<( }, Some(1), )?; - assert_eq!(packets.len(), 40); + // Forty one-byte fragments cannot leave inside one reliable send window. The + // window's worth goes out now and the rest queue until acknowledgements free + // space, which is the crossing this test exists to prove. + assert_eq!(packets.len(), CULTNET_RUDP_RELIABLE_SEND_WINDOW_PACKETS); + assert_eq!( + sender.queued_reliable_packet_count(), + 40 - CULTNET_RUDP_RELIABLE_SEND_WINDOW_PACKETS + ); + + let mut wire = VecDeque::from(packets); let mut delivered = Vec::new(); - for packet in &packets { - let result = receiver.receive(packet, 2)?; - delivered.extend(result.delivered); - sender.receive(&receiver.create_ack_for(packet.sequence), 3)?; + while !wire.is_empty() { + let admitted = wire.len(); + for _ in 0..admitted { + let packet = wire.pop_front().expect("admitted packet remains queued"); + let received = receiver.receive(&packet, 2)?; + delivered.extend(received.delivered); + } + let acknowledged = sender.receive(&receiver.create_ack(), 3)?; + wire.extend(acknowledged.ready_to_send); } + assert_eq!(delivered.len(), 1); assert_eq!(delivered[0].payload, vec![0x5a; 40]); assert!(sender.pending_reliable_sequences().is_empty()); + assert_eq!(sender.outstanding_reliable_packet_count(), 0); Ok(()) }