mikros/rust
1
0
Fork 0
Code Issues Pull Requests 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] #[test]
// FIXME: https://github.com/fortanix/rust-sgx/issues/110
#[cfg_attr(target_env = "sgx", ignore)] #[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() { fn close_read_wakes_up() {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let a = t!(TcpListener::bind(&addr)); let listener = t!(TcpListener::bind(&addr));
let (tx1, rx) = channel::<()>();
let _t = thread::spawn(move || { let _t = thread::spawn(move || {
let _s = t!(a.accept()); let (stream, _) = t!(listener.accept());
let _ = rx.recv(); stream
}); });
let s = t!(TcpStream::connect(&addr)); let mut stream = t!(TcpStream::connect(&addr));
let s2 = t!(s.try_clone()); let stream2 = t!(stream.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));
// this test will never finish if the child doesn't wake up let _t = thread::spawn(move || {
rx.recv().unwrap(); let stream2 = stream2;
drop(tx1);
// 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);
}) })
} }