vthread 0.0.1

Bounded carrier-affine virtual threads for Rust
Documentation
use super::super::{Entry, Permit, State};
use crate::{ThreadComponent, control::Shared, signal::lock, support_test::until};
use std::sync::{Arc, atomic::Ordering};

#[test]
fn failed_claims_retain_the_entry_before_and_after_join() {
    for phase in [2, 3] {
        let state = Arc::new(State::default());
        let shared = Arc::new(Shared::new(crate::RuntimeConfig::default()));
        let worker = std::thread::spawn(|| {});
        until(|| worker.is_finished());
        Permit::reserve(Arc::clone(&state))
            .unwrap()
            .install(Entry {
                worker: crate::join_slot::JoinSlot::new(worker),
                shared: Arc::clone(&shared),
                resources: Arc::default(),
            })
            .unwrap();
        state.fail_at.store(phase, Ordering::Release);
        super::run(Arc::clone(&state));
        let slots = lock(&state.slots);
        assert_eq!(slots.occupied, 1);
        assert_eq!(slots.entries.len(), 1);
        assert!(slots.failure.is_some());
        assert_eq!(slots.entries[0].worker.joined(), phase == 3);
        slots.entries[0]
            .worker
            .join(&Arc::downgrade(&shared), ThreadComponent::Coordinator);
        drop(slots);
        assert_eq!(
            lock(&shared.failures).entries()[0].component(),
            ThreadComponent::LifecycleOwner
        );
        assert!(!shared.snapshot().accepting());
    }
}

#[test]
fn failure_racing_installation_keeps_the_reserved_handle_and_rejects_new_work() {
    let state = Arc::new(State::default());
    let permit = Permit::reserve(Arc::clone(&state)).unwrap();
    state.fail(super::stopped_failure());
    let shared = Arc::new(Shared::new(crate::RuntimeConfig::default()));
    let result = permit.install(Entry {
        worker: crate::join_slot::JoinSlot::new(std::thread::spawn(|| {})),
        shared: Arc::clone(&shared),
        resources: Arc::default(),
    });
    assert!(matches!(result, Err(crate::Error::LifecycleFailed(_))));
    assert!(matches!(
        Permit::reserve(Arc::clone(&state)),
        Err(crate::Error::LifecycleFailed(_))
    ));
    let slots = lock(&state.slots);
    assert_eq!(slots.occupied, 1);
    assert_eq!(slots.entries.len(), 1);
    slots.entries[0]
        .worker
        .join(&Arc::downgrade(&shared), ThreadComponent::Coordinator);
    assert_eq!(
        lock(&shared.failures).entries()[0].component(),
        ThreadComponent::LifecycleOwner
    );
}