lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

tasks_tests.rs (5316B)


      1 use super::*;
      2 use futures::{
      3     FutureExt,
      4     channel::oneshot,
      5     executor::{LocalPool, block_on},
      6     task::LocalSpawnExt,
      7 };
      8 use std::sync::{
      9     Arc,
     10     atomic::{AtomicUsize, Ordering},
     11 };
     12 
     13 fn started(pool: &LocalPool) -> Shared<OwnedTasks> {
     14     let tasks = Shared::new(OwnedTasks::default());
     15     let spawn = pool.spawner();
     16     tasks
     17         .start(|task| spawn.spawn_local(task).unwrap())
     18         .unwrap();
     19     tasks
     20 }
     21 #[test]
     22 fn startup_quiesce_and_empty_close_are_permanent_and_unpolled_close_is_inert() {
     23     let mut pool = LocalPool::new();
     24     let tasks = Shared::new(OwnedTasks::default());
     25     assert!(tasks.submit(Box::pin(async {})).is_err());
     26     drop(tasks.close());
     27     let spawn = pool.spawner();
     28     tasks
     29         .start(|task| spawn.spawn_local(task).unwrap())
     30         .unwrap();
     31     tasks.start(|_| panic!("second owner")).unwrap();
     32     tasks.quiesce().unwrap();
     33     assert!(tasks.submit(Box::pin(async {})).is_err());
     34     pool.run_until(tasks.close()).unwrap();
     35     block_on(tasks.close()).unwrap();
     36     assert!(tasks.start(|_| panic!("restart")).is_err());
     37     let unopened = OwnedTasks::default();
     38     block_on(unopened.close()).unwrap();
     39     assert!(unopened.start(|_| panic!("closed before start")).is_err());
     40 }
     41 #[test]
     42 fn bounded_original_jobs_survive_cancelled_drain_and_close_observers() {
     43     let mut pool = LocalPool::new();
     44     let tasks = started(&pool);
     45     let (release, blocked) = oneshot::channel::<()>();
     46     tasks
     47         .submit(Box::pin(async move {
     48             blocked.await.unwrap();
     49         }))
     50         .unwrap();
     51     pool.run_until_stalled();
     52     let count = Arc::new(AtomicUsize::new(0));
     53     for _ in 1..CAPACITY {
     54         let count = count.clone();
     55         tasks
     56             .submit(Box::pin(async move {
     57                 count.fetch_add(1, Ordering::SeqCst);
     58             }))
     59             .unwrap();
     60     }
     61     assert!(
     62         tasks
     63             .submit(Box::pin(async { panic!("refused task polled") }))
     64             .is_err()
     65     );
     66     let mut drain = Box::pin(tasks.drain());
     67     assert!(drain.as_mut().now_or_never().is_none());
     68     drop(drain);
     69     let mut close = Box::pin(tasks.close());
     70     assert!(close.as_mut().now_or_never().is_none());
     71     drop(close);
     72     assert!(
     73         tasks
     74             .submit(Box::pin(async { panic!("closed admission") }))
     75             .is_err()
     76     );
     77     release.send(()).unwrap();
     78     pool.run_until(tasks.close()).unwrap();
     79     assert_eq!(count.load(Ordering::SeqCst), CAPACITY - 1);
     80     block_on(tasks.drain()).unwrap();
     81 }
     82 #[test]
     83 fn an_idle_owner_wakes_and_drain_waits_for_queued_then_running_original_work() {
     84     let mut pool = LocalPool::new();
     85     let tasks = started(&pool);
     86     pool.run_until_stalled();
     87     let count = Arc::new(AtomicUsize::new(0));
     88     let completed = count.clone();
     89     let (release, blocked) = oneshot::channel::<()>();
     90     tasks
     91         .submit(Box::pin(async move {
     92             blocked.await.unwrap();
     93             completed.fetch_add(1, Ordering::SeqCst);
     94         }))
     95         .unwrap();
     96     let mut drain = Box::pin(tasks.drain());
     97     assert!(drain.as_mut().now_or_never().is_none());
     98     assert_eq!(count.load(Ordering::SeqCst), 0);
     99     pool.run_until_stalled();
    100     assert!(drain.as_mut().now_or_never().is_none());
    101     release.send(()).unwrap();
    102     pool.run_until(drain).unwrap();
    103     assert_eq!(count.load(Ordering::SeqCst), 1);
    104     let completed = count.clone();
    105     tasks
    106         .submit(Box::pin(async move {
    107             completed.fetch_add(1, Ordering::SeqCst);
    108         }))
    109         .unwrap();
    110     pool.run_until_stalled();
    111     pool.run_until(tasks.close()).unwrap();
    112     assert_eq!(count.load(Ordering::SeqCst), 2);
    113 }
    114 #[test]
    115 fn losing_last_host_observer_still_drains_accepted_work_and_drops_outside_lock() {
    116     struct ReentrantDrop(Shared<OwnedTasks>, Arc<AtomicUsize>);
    117     impl Drop for ReentrantDrop {
    118         fn drop(&mut self) {
    119             self.0.quiesce().unwrap();
    120             self.1.fetch_add(1, Ordering::SeqCst);
    121         }
    122     }
    123     let mut pool = LocalPool::new();
    124     let tasks = started(&pool);
    125     let count = Arc::new(AtomicUsize::new(0));
    126     let probe = ReentrantDrop(tasks.clone(), count.clone());
    127     tasks.quiesce().unwrap();
    128     assert!(
    129         tasks
    130             .submit(Box::pin(async move {
    131                 let _probe = probe;
    132             }))
    133             .is_err()
    134     );
    135     assert_eq!(count.load(Ordering::SeqCst), 1);
    136     pool.run_until(tasks.close()).unwrap();
    137     let tasks = started(&pool);
    138     let count2 = count.clone();
    139     tasks
    140         .submit(Box::pin(async move {
    141             count2.fetch_add(1, Ordering::SeqCst);
    142         }))
    143         .unwrap();
    144     drop(tasks);
    145     pool.run();
    146     assert_eq!(count.load(Ordering::SeqCst), 2);
    147 }
    148 #[test]
    149 fn poisoned_bookkeeping_never_reports_successful_completion() {
    150     let tasks = OwnedTasks::default();
    151     let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
    152         let _guard = tasks.inner.state.lock().unwrap();
    153         panic!("intentional poison");
    154     }));
    155     assert!(tasks.start(|_| panic!("poisoned start")).is_err());
    156     assert!(
    157         tasks
    158             .submit(Box::pin(async { panic!("poisoned admission") }))
    159             .is_err()
    160     );
    161     assert!(tasks.quiesce().is_err());
    162     assert!(block_on(tasks.drain()).is_err());
    163     assert!(block_on(tasks.close()).is_err());
    164 }