use crate::{Error, Runtime, ScopeOptions, SuspensionReason, context, net::unix::UnixStream};
use std::{
os::fd::{AsFd, AsRawFd},
sync::Arc,
time::{Duration, Instant},
};
#[test]
fn readiness_source_reuses_one_owned_descriptor() {
let (socket, _peer) = std::os::unix::net::UnixStream::pair().unwrap();
let source = super::ReadinessSource::default();
let first = source.acquire(socket.as_fd()).unwrap();
let second = source.acquire(socket.as_fd()).unwrap();
assert!(Arc::ptr_eq(&first, &second));
assert_ne!(first.as_raw_fd(), socket.as_raw_fd());
}
#[test]
fn immediately_ready_operation_does_not_enter_a_suspension_reason() {
let runtime = Runtime::new().unwrap();
let (socket, _peer) = std::os::unix::net::UnixStream::pair().unwrap();
runtime
.run_scope(|scope| {
scope
.spawn("ready", move || {
super::operation(
socket.as_fd(),
zio::Interest::READABLE,
SuspensionReason::IoRead,
|| {
let mounted = context::current().unwrap();
assert_eq!(
mounted.execution().unwrap().data.reason(),
SuspensionReason::Park
);
Ok::<_, std::io::Error>(())
},
)
})?
.join()??;
Ok(())
})
.unwrap();
}
#[test]
fn socket_deadline_cleans_registration_and_preserves_unread_data() {
let runtime = Runtime::new().unwrap();
let (reader, writer) = UnixStream::pair().unwrap();
let reader = Arc::new(reader);
let error = runtime
.run_scope_with(
ScopeOptions::default().deadline(Instant::now() + Duration::from_millis(30)),
|scope| {
let reader = Arc::clone(&reader);
let mut task = scope.spawn("timeout", move || reader.read(&mut [0; 1]))?;
assert!(matches!(task.join()?, Err(Error::DeadlineExceeded)));
Ok(())
},
)
.unwrap_err();
assert!(matches!(error.primary(), Error::DeadlineExceeded));
runtime
.run_scope(|scope| {
scope
.spawn("write", move || writer.write_all(b"x"))?
.join()??;
let mut task = scope.spawn("read-again", move || {
let mut byte = [0; 1];
reader.read_exact(&mut byte)?;
Ok::<_, Error>(byte)
})?;
assert_eq!(task.join()??, *b"x");
Ok(())
})
.unwrap();
}
#[test]
fn readiness_capacity_rejects_excess_waits_without_poisoning_the_socket() {
use crate::support_test::until;
let runtime = Runtime::builder().io_capacity(1).build().unwrap();
let (reader, _writer) = UnixStream::pair().unwrap();
let reader = Arc::new(reader);
runtime
.run_scope(|scope| {
let socket = Arc::clone(&reader);
let mut first = scope.spawn("first", move || socket.read(&mut [0; 1]))?;
until(|| runtime.snapshot().services.readiness_waits == 1);
let socket = Arc::clone(&reader);
let mut second = scope.spawn("excess", move || socket.read(&mut [0; 1]))?;
assert!(matches!(
second.join()?,
Err(Error::Capacity {
resource: crate::error::CapacityResource::Readiness,
limit: 1
})
));
scope.cancel();
assert!(matches!(first.join()?, Err(Error::Cancelled)));
Ok(())
})
.unwrap();
until(|| runtime.snapshot().services.readiness_registered == 0);
}
#[test]
fn read_exact_reports_short_eof_without_discarding_the_received_prefix() {
use std::net::Shutdown;
let runtime = Runtime::new().unwrap();
let (reader, writer) = UnixStream::pair().unwrap();
runtime.run_scope(|scope| {
scope.spawn("write", move || {
writer.write_all(b"ab")?;
writer.shutdown(Shutdown::Write)
})?.join()??;
scope.spawn("short-read", move || {
let mut buffer = [0; 4];
assert!(matches!(reader.read_exact(&mut buffer), Err(Error::Io(error)) if error.kind() == std::io::ErrorKind::UnexpectedEof));
assert_eq!(&buffer[..2], b"ab");
})?.join()?;
Ok(())
}).unwrap();
}