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 }