#![cfg(test)]
use std::sync::Arc;
use super::Token;
#[test]
fn a_fresh_token_is_uncancelled_however_it_was_built() {
for token in [Token::new(), Token::default()] {
assert!(!token.is_cancelled());
assert_eq!(format!("{token:?}"), "Token { cancelled: false }");
}
}
#[test]
fn every_clone_observes_one_cancellation_and_cancelling_twice_is_idempotent() {
let token = Token::new();
let clone = token.clone();
assert!(!clone.is_cancelled());
clone.cancel();
assert!(token.is_cancelled());
assert!(clone.is_cancelled());
assert_eq!(format!("{token:?}"), "Token { cancelled: true }");
token.cancel();
assert!(clone.is_cancelled());
}
#[test]
fn child_derivation_propagates_downward_only() {
let parent = Token::new();
let child = parent.child_token();
let grandchild = child.child_token();
grandchild.cancel();
assert!(grandchild.is_cancelled());
assert!(!child.is_cancelled());
assert!(!parent.is_cancelled());
let sibling = child.child_token();
parent.cancel();
assert!(child.is_cancelled());
assert!(sibling.is_cancelled());
assert!(parent.child_token().is_cancelled());
}
#[tokio::test]
async fn awaiting_cancellation_completes_for_an_already_cancelled_token() {
let token = Token::new();
token.cancel();
token.cancelled().await;
}
#[tokio::test]
async fn awaiting_cancellation_wakes_a_waiter_cancelled_by_a_parent() {
let parent = Token::new();
let child = Arc::new(parent.child_token());
let waiter = tokio::spawn({
let child = Arc::clone(&child);
async move {
child.cancelled().await;
child.is_cancelled()
}
});
tokio::task::yield_now().await;
assert!(!child.is_cancelled());
parent.cancel();
assert!(waiter.await.expect("the waiter task does not panic"));
}
#[tokio::test]
async fn dropping_a_cancellation_future_observes_nothing() {
let token = Token::new();
{
let pending = token.cancelled();
drop(pending);
}
assert!(!token.is_cancelled());
token.cancel();
token.cancelled().await;
}