nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 23:04:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #122095 - lukas-code:windows-shutdown-test, r=ChrisDenton

Browse Source 
fix `close_read_wakes_up` test

On windows, `shutdown` does not interrupt `read`, even though we document that it does (see https://github.com/rust-lang/rust/issues/121594).

The `close_read_wakes_up` test has a race condition and only passes on windows if the `shutdown` happens before the `read`. This PR ignores the test on windows adds a sleep to make it more likely that the `read` happens before the `shutdown` and the test actually tests what it is supposed to test on other platforms.

I'm submitting this before any docs changes, so that we can find out on what platforms `shutdown` actually works as documented.

r? `@ChrisDenton`
This commit is contained in:
bors 2024-03-09 06:23:18 +00:00
commit 48a15aa2c4
1 changed files with 20 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
library/std/src/net/tcp/tests.rs
View File

@ -544,30 +544,33 @@ fn close_readwrite_smoke() {
}
#[test]
// FIXME: https://github.com/fortanix/rust-sgx/issues/110
#[cfg_attr(target_env = "sgx", ignore)]
// On windows, shutdown will not wake up blocking I/O operations.
#[cfg_attr(windows, ignore)]
fn close_read_wakes_up() {
each_ip(&mut |addr| {
let a = t!(TcpListener::bind(&addr));
let (tx1, rx) = channel::<()>();
let listener = t!(TcpListener::bind(&addr));
let _t = thread::spawn(move || {
let _s = t!(a.accept());
let _ = rx.recv();
let (stream, _) = t!(listener.accept());
stream
});
let s = t!(TcpStream::connect(&addr));
let s2 = t!(s.try_clone());
let (tx, rx) = channel();
let _t = thread::spawn(move || {
let mut s2 = s2;
assert_eq!(t!(s2.read(&mut [0])), 0);
tx.send(()).unwrap();
});
// this should wake up the child thread
t!(s.shutdown(Shutdown::Read));
let mut stream = t!(TcpStream::connect(&addr));
let stream2 = t!(stream.try_clone());
// this test will never finish if the child doesn't wake up
rx.recv().unwrap();
drop(tx1);
let _t = thread::spawn(move || {
let stream2 = stream2;
// to make it more likely that `read` happens before `shutdown`
thread::sleep(Duration::from_millis(1000));
// this should wake up the reader up
t!(stream2.shutdown(Shutdown::Read));
});
// this `read` should get interrupted by `shutdown`
assert_eq!(t!(stream.read(&mut [0])), 0);
})
}