snare 3.5.1

Ergonomic in-process network testing on top of snare-interpose: write the code under test against std, describe the peer with a tester builder
Documentation
#![cfg(windows)]

use std::cell::UnsafeCell;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, mpsc};
use std::time::Duration;

use snare::Sim;
use windows_sys::Win32::Foundation::{ERROR_TIMEOUT, GetLastError};
use windows_sys::Win32::System::Threading::*;

struct Locks {
    srw: UnsafeCell<SRWLOCK>,
    cs: UnsafeCell<CRITICAL_SECTION>,
    condition: UnsafeCell<CONDITION_VARIABLE>,
    ready: AtomicUsize,
}

unsafe impl Send for Locks {}
unsafe impl Sync for Locks {}

impl Locks {
    fn new() -> Arc<Self> {
        let locks = Arc::new(Self {
            srw: UnsafeCell::new(SRWLOCK::default()),
            cs: UnsafeCell::new(CRITICAL_SECTION::default()),
            condition: UnsafeCell::new(CONDITION_VARIABLE::default()),
            ready: AtomicUsize::new(0),
        });
        unsafe { InitializeCriticalSection(locks.cs.get()) };
        locks
    }

    fn take(&self, mode: u32) {
        unsafe {
            match mode {
                0 => EnterCriticalSection(self.cs.get()),
                1 => AcquireSRWLockExclusive(self.srw.get()),
                2 => AcquireSRWLockShared(self.srw.get()),
                _ => unreachable!(),
            }
        }
    }

    fn release(&self, mode: u32) {
        unsafe {
            match mode {
                0 => LeaveCriticalSection(self.cs.get()),
                1 => ReleaseSRWLockExclusive(self.srw.get()),
                2 => ReleaseSRWLockShared(self.srw.get()),
                _ => unreachable!(),
            }
        }
    }

    fn wait(&self, mode: u32, timeout: u32) -> i32 {
        unsafe {
            match mode {
                0 => SleepConditionVariableCS(self.condition.get(), self.cs.get(), timeout),
                1 => SleepConditionVariableSRW(self.condition.get(), self.srw.get(), timeout, 0),
                2 => SleepConditionVariableSRW(self.condition.get(), self.srw.get(), timeout, 1),
                _ => unreachable!(),
            }
        }
    }
}

impl Drop for Locks {
    fn drop(&mut self) {
        unsafe { DeleteCriticalSection(self.cs.get()) };
    }
}

fn shared_holders() {
    let locks = Locks::new();
    let (ready, ready_rx) = mpsc::channel();
    let mut readers = Vec::new();
    let mut starts = Vec::new();
    for delay in [10, 20] {
        let locks = locks.clone();
        let ready = ready.clone();
        let (start, start_rx) = mpsc::channel();
        starts.push(start);
        readers.push(std::thread::spawn(move || {
            locks.take(2);
            ready.send(()).unwrap();
            start_rx.recv().unwrap();
            std::thread::sleep(Duration::from_millis(delay));
            locks.release(2);
        }));
    }
    ready_rx.recv().unwrap();
    ready_rx.recv().unwrap();
    assert!(!unsafe { TryAcquireSRWLockExclusive(locks.srw.get()) });
    for start in starts {
        start.send(()).unwrap();
    }
    locks.take(1);
    locks.release(1);
    for reader in readers {
        reader.join().unwrap();
    }
    assert!(unsafe { TryAcquireSRWLockExclusive(locks.srw.get()) });
    locks.release(1);
}

#[test]
fn multiple_shared_holders_block_a_writer_until_the_last_release() {
    shared_holders();
    for deterministic in [false, true] {
        let builder = Sim::builder();
        let sim = if deterministic {
            builder.deterministic()
        } else {
            builder
        }
        .build();
        sim.run(shared_holders);
        assert!(sim.time_value() >= Duration::from_millis(20));
    }
}

fn condition_probe(mode: u32, all: bool) -> (i32, u32, usize) {
    let locks = Locks::new();
    locks.take(mode);
    let timeout = locks.wait(mode, 0);
    let error = unsafe { GetLastError() };
    locks.release(mode);
    let (ready, ready_rx) = mpsc::channel();
    let count = if all { 3 } else { 1 };
    let mut waiters = Vec::new();
    for _ in 0..count {
        let locks = locks.clone();
        let ready = ready.clone();
        waiters.push(std::thread::spawn(move || {
            locks.take(mode);
            ready.send(()).unwrap();
            while locks.ready.load(Ordering::Acquire) == 0 {
                assert_ne!(locks.wait(mode, u32::MAX), 0);
            }
            locks.release(mode);
            1
        }));
    }
    for _ in 0..count {
        ready_rx.recv().unwrap();
    }
    let notify_mode = if mode == 0 { 0 } else { 1 };
    locks.take(notify_mode);
    locks.ready.store(1, Ordering::Release);
    unsafe {
        if all {
            WakeAllConditionVariable(locks.condition.get());
        } else {
            WakeConditionVariable(locks.condition.get());
        }
    }
    locks.release(notify_mode);
    (
        timeout,
        error,
        waiters
            .into_iter()
            .map(|waiter| waiter.join().unwrap())
            .sum(),
    )
}

#[test]
fn raw_condition_waits_atomically_unlock_and_reacquire_each_lock_mode() {
    for mode in 0..3 {
        for all in [false, true] {
            let native = condition_probe(mode, all);
            assert_eq!(native, (0, ERROR_TIMEOUT, if all { 3 } else { 1 }));
            for deterministic in [false, true] {
                let builder = Sim::builder();
                let sim = if deterministic {
                    builder.deterministic()
                } else {
                    builder
                }
                .build();
                let (model, domain) = sim.run(|| {
                    (
                        condition_probe(mode, all),
                        snare_interpose::Domain::current().unwrap(),
                    )
                });
                assert_eq!(model, native);
                assert_eq!(
                    domain.outside_wakes(),
                    0,
                    "mode={mode} all={all} deterministic={deterministic}"
                );
            }
        }
    }
}

#[test]
fn condition_timeouts_return_with_the_lock_reacquired() {
    for deterministic in [false, true] {
        let builder = Sim::builder();
        let sim = if deterministic {
            builder.deterministic()
        } else {
            builder
        }
        .build();
        sim.run(|| {
            for mode in 0..3 {
                let locks = Locks::new();
                locks.take(mode);
                let before = snare::sched::now();
                assert_eq!(locks.wait(mode, 25), 0);
                assert_eq!(unsafe { GetLastError() }, ERROR_TIMEOUT);
                assert!(snare::sched::now() - before >= Duration::from_millis(25));
                if mode != 0 {
                    assert!(!unsafe { TryAcquireSRWLockExclusive(locks.srw.get()) });
                } else {
                    assert!(unsafe { TryEnterCriticalSection(locks.cs.get()) } != 0);
                    locks.release(0);
                }
                locks.release(mode);
            }
        });
    }
}