use std::ops::{Deref, DerefMut};
use std::sync::{Mutex, MutexGuard, PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
pub(crate) struct Held<G> {
guard: G,
#[cfg(test)]
_count: Count,
}
impl<G: Deref> Deref for Held<G> {
type Target = G::Target;
fn deref(&self) -> &G::Target {
&self.guard
}
}
impl<G: DerefMut> DerefMut for Held<G> {
fn deref_mut(&mut self) -> &mut G::Target {
&mut self.guard
}
}
impl<G> Held<G> {
#[track_caller]
fn take(take: impl FnOnce() -> G) -> Self {
#[cfg(test)]
let count = Count::new();
Self {
guard: take(),
#[cfg(test)]
_count: count,
}
}
}
#[track_caller]
pub(crate) fn lock<T>(m: &Mutex<T>) -> Held<MutexGuard<'_, T>> {
Held::take(|| m.lock().unwrap_or_else(PoisonError::into_inner))
}
#[track_caller]
pub(crate) fn read<T>(l: &RwLock<T>) -> Held<RwLockReadGuard<'_, T>> {
Held::take(|| l.read().unwrap_or_else(PoisonError::into_inner))
}
#[track_caller]
pub(crate) fn write<T>(l: &RwLock<T>) -> Held<RwLockWriteGuard<'_, T>> {
Held::take(|| l.write().unwrap_or_else(PoisonError::into_inner))
}
#[cfg(test)]
thread_local! {
static HELD: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
static AFTER: std::cell::RefCell<Option<AfterRelease>> =
const { std::cell::RefCell::new(None) };
}
#[cfg(test)]
pub(crate) type AfterRelease = std::rc::Rc<dyn Fn()>;
#[cfg(test)]
pub(crate) fn after_each_release(check: Option<AfterRelease>) {
AFTER.with(|a| *a.borrow_mut() = check);
}
#[cfg(test)]
struct Count;
#[cfg(test)]
impl Count {
#[track_caller]
fn new() -> Self {
HELD.with(|held| {
assert_eq!(
held.get(),
0,
"an Environment lock taken while another is held (plan section 3.16)"
);
held.set(1);
});
Self
}
}
#[cfg(test)]
impl Drop for Count {
fn drop(&mut self) {
HELD.with(|held| held.set(held.get().saturating_sub(1)));
if std::thread::panicking() {
return;
}
let check = AFTER.with(|a| a.borrow_mut().take());
if let Some(check) = check {
check();
AFTER.with(|a| *a.borrow_mut() = Some(check));
}
}
}
#[cfg(test)]
mod tests {
use std::sync::{Mutex, RwLock};
use std::cell::Cell;
use std::panic::{AssertUnwindSafe, catch_unwind};
use std::rc::Rc;
use super::{after_each_release, lock, read, write};
#[test]
fn a_lock_taken_while_another_is_held_panics() {
let (m, l) = (Mutex::new(1), RwLock::new(2));
let one = *lock(&m);
assert_eq!(one + *read(&l), 3);
*write(&l) = 3;
let nested = std::panic::catch_unwind(|| {
let _m = lock(&m);
drop(read(&l));
});
assert!(nested.is_err(), "the nested lock was not caught");
assert_eq!(*read(&l), 3);
}
#[test]
fn a_check_runs_after_each_release_with_the_lock_free() {
let l = Rc::new(RwLock::new(1));
let seen = Rc::new(Cell::new(0));
after_each_release(Some({
let (l, seen) = (l.clone(), seen.clone());
Rc::new(move || {
assert!(l.try_write().is_ok(), "the lock is still held");
seen.set(seen.get() + *read(&l));
})
}));
*write(&l) = 2;
assert_eq!(seen.get(), 2, "the check saw the release's value, once");
drop(read(&l));
assert_eq!(seen.get(), 4);
let unwound = catch_unwind(AssertUnwindSafe(|| {
let _held = read(&l);
panic!("unwinds the guard");
}));
assert!(unwound.is_err());
assert_eq!(seen.get(), 4, "a release a panic unwound ran the check");
after_each_release(None);
drop(read(&l));
assert_eq!(seen.get(), 4);
}
}