vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use super::Shared;
use crate::{Error, RuntimeConfig};

#[test]
fn scope_admission_is_exclusive_and_shutdown_is_terminal() {
    let shared = Shared::new(RuntimeConfig::default());
    let scope = shared.begin_scope().expect("scope");
    assert!(matches!(shared.begin_scope(), Err(Error::RootScopeActive)));
    shared.finish_scope(scope);
    assert!(shared.begin_scope().is_ok());
    shared.request_stop();
    assert!(matches!(
        shared.submit(scope, "late".into(), || ()),
        Err(Error::ScopeClosed)
    ));
    assert!(matches!(shared.begin_scope(), Err(Error::RuntimeStopped)));
}

#[test]
fn snapshot_observation_does_not_block_admission_or_completion() {
    use crate::signal::lock;
    use std::sync::{Arc, mpsc};
    use std::time::Duration;

    let shared = Arc::new(Shared::new(RuntimeConfig::default()));
    let scope = shared.begin_scope().unwrap();
    let existing = shared.reserve(scope, "existing".into(), None).unwrap();
    let (observing, observed) = mpsc::channel();
    let (resume, resumed) = mpsc::channel();
    *lock(&shared.snapshot_observe_hook) = Some(Box::new(move || {
        observing.send(()).unwrap();
        resumed.recv().unwrap();
    }));
    let (done, completed) = mpsc::channel();
    let progress = std::thread::scope(|threads| {
        let snapshot = threads.spawn(|| shared.snapshot());
        observed.recv_timeout(Duration::from_secs(5)).unwrap();
        threads.spawn(|| {
            let new = shared.reserve(scope, "new".into(), None).unwrap();
            shared.complete(&existing, None);
            shared.complete(&new, None);
            done.send(()).unwrap();
        });
        let progress = completed.recv_timeout(Duration::from_secs(2));
        resume.send(()).unwrap();
        snapshot.join().unwrap();
        progress
    });
    assert!(
        progress.is_ok(),
        "snapshot observation held admission/completion lock"
    );
    assert_eq!(shared.snapshot().active, 0);
    shared.finish_scope(scope);
}

#[test]
fn running_carrier_publication_is_independent_of_admission() {
    use crate::{CarrierId, CarrierSnapshot, CarrierStatus, signal::lock};
    use std::sync::{Arc, mpsc};
    use std::time::Duration;

    let shared = Arc::new(Shared::new(RuntimeConfig::default()));
    let admission = lock(&shared.state);
    let publisher = Arc::clone(&shared);
    let (done, published) = mpsc::channel();
    let worker = std::thread::spawn(move || {
        let mut snapshot = CarrierSnapshot::new(CarrierId(0));
        snapshot.status = CarrierStatus::Running;
        publisher.publish(snapshot);
        done.send(()).unwrap();
    });
    let progress = published.recv_timeout(Duration::from_secs(1));
    drop(admission);
    worker.join().unwrap();

    assert!(progress.is_ok(), "carrier publication waited for admission");
}

#[test]
fn idle_carrier_publication_is_quiet_but_terminal_publication_signals() {
    use crate::{CarrierId, CarrierSnapshot, CarrierStatus};

    let shared = Shared::new(RuntimeConfig::default());
    let observed = shared.changed.version();
    let mut snapshot = CarrierSnapshot::new(CarrierId(0));
    snapshot.status = CarrierStatus::Idle;
    shared.publish(snapshot.clone());
    assert_eq!(shared.changed.version(), observed);

    snapshot.status = CarrierStatus::Stopped;
    shared.publish(snapshot);
    assert_ne!(shared.changed.version(), observed);
}