use crate::Context;
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use super::{Drained, Pass, Resident, Staged, block_on};
use crate::{
AsyncOperator, Delivery, Emitter, Item, Operator, Payload, Unpolled,
drive::{Downstream, Inbox, ItemId, channel},
};
struct Counting(Arc<AtomicUsize>);
impl Operator for Counting {
type Error = core::convert::Infallible;
type In = u64;
type Out = u64;
fn accept(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
emitter: &mut Emitter<u64>,
) -> Result<(), Self::Error> {
for item in delivery.into_items() {
self.0.fetch_add(1, Ordering::SeqCst);
emitter.emit(item.into_value() * 2);
}
Ok(())
}
}
struct AwaitedCounting(Arc<AtomicUsize>);
impl AsyncOperator for AwaitedCounting {
type Error = core::convert::Infallible;
type In = u64;
type Out = u64;
async fn accept(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
emitter: &mut Emitter<u64>,
) -> Result<(), Self::Error> {
for item in delivery.into_items() {
let value = core::future::ready(item.into_value()).await;
self.0.fetch_add(1, Ordering::SeqCst);
emitter.emit(value * 2);
}
Ok(())
}
}
type Blocking = Resident<Counting, (), (), (), Unpolled, Downstream<u64>, Inbox<ItemId, u64>>;
fn one(value: u64) -> Delivery<u64> {
Delivery::in_custody(Payload::One(Item::new(ItemId::new(0), value)))
}
#[test]
fn the_blocking_middle_third_answers_a_staged_and_not_a_future() {
let process: fn(&mut Blocking, Delivery<u64>, &mut Drained) -> Staged<u64> = Blocking::process;
assert_eq!(
core::mem::size_of_val(&process),
core::mem::size_of::<fn()>(),
"a function pointer, which is what the coercion produced"
);
}
#[test]
fn the_blocking_middle_third_has_run_by_the_time_it_answers() {
let counted = Arc::new(AtomicUsize::new(0));
let (_feed, inbox) = channel::<ItemId, u64>(1);
let mut resident = Resident::new("count", Counting(Arc::clone(&counted)), inbox);
let mut report = Drained::default();
let staged = resident.process(one(21), &mut report);
assert_eq!(
counted.load(Ordering::SeqCst),
1,
"the body ran during the call"
);
assert_eq!(staged.outputs, [42]);
}
#[test]
fn the_awaited_middle_third_has_not_run_until_it_is_driven() {
let counted = Arc::new(AtomicUsize::new(0));
let (_feed, inbox) = channel::<ItemId, u64>(1);
let mut resident = Resident::new("count", AwaitedCounting(Arc::clone(&counted)), inbox);
let mut report = Drained::default();
let pending = resident.process(one(21), &mut report);
assert_eq!(
counted.load(Ordering::SeqCst),
0,
"nothing has run: the call answered a future"
);
let staged: Staged<u64> = block_on(pending);
assert_eq!(counted.load(Ordering::SeqCst), 1, "and this is what ran it");
assert_eq!(staged.outputs, [42]);
}
#[test]
fn a_pass_absorbs_an_item_the_same_way_for_either_face() {
let mut pass: Pass<u64> = Pass::opening(1);
let mut emitter = Emitter::new();
emitter.emit(42);
pass.absorb(
ItemId::new(7),
emitter,
Ok::<(), core::convert::Infallible>(()),
);
assert_eq!(pass.outputs, [42], "the emission was staged");
assert_eq!(pass.owner, [0], "attributed to the input that produced it");
assert_eq!(pass.verdict.tally.processed, 1);
assert_eq!(pass.verdict.tally.failed, 0);
}