yash-executor 1.0.1

single-threaded concurrent task executor
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// This file is part of yash, an extended POSIX shell.
// Copyright (C) 2024 WATANABE Yuki

use std::cell::Cell;
use std::pin::pin;
use std::task::Context;
use std::task::Waker;
use yash_executor::forwarder::TryReceiveError;
use yash_executor::{Executor, Spawner};

mod spawn_pinned {
    use super::*;

    #[test]
    fn dead_spawner_does_nothing() {
        let run = Cell::new(false);
        let spawner = Spawner::dead();

        let result = unsafe { spawner.spawn_pinned(Box::pin(async { run.set(true) })) };
        assert!(!run.get());

        // Make sure the returned future is the same as the one passed in
        let mut future = result.unwrap_err().0;
        let mut context = Context::from_waker(Waker::noop());
        let poll = future.as_mut().poll(&mut context);
        assert!(poll.is_ready());
        assert!(run.get());
    }

    #[test]
    fn spawner_does_nothing_after_executor_was_dropped() {
        let run = Cell::new(false);
        let spawner = Executor::new().spawner();

        let result = unsafe { spawner.spawn_pinned(Box::pin(async { run.set(true) })) };
        assert!(!run.get());

        // Make sure the returned future is the same as the one passed in
        let mut future = result.unwrap_err().0;
        let mut context = Context::from_waker(Waker::noop());
        let poll = future.as_mut().poll(&mut context);
        assert!(poll.is_ready());
        assert!(run.get());
    }

    #[test]
    fn spawning_task_outside_task() {
        let run = Cell::new(false);
        let executor = Executor::new();
        let spawner = executor.spawner();

        let result = unsafe { spawner.spawn_pinned(Box::pin(async { run.set(true) })) };
        assert!(result.is_ok());
        assert!(!run.get());
        assert_eq!(executor.wake_count(), 1);

        executor.step();
        assert!(run.get());
    }

    #[test]
    fn spawning_task_inside_task() {
        let executor = Executor::new();
        let spawner = executor.spawner();
        unsafe {
            executor.spawn_pinned(Box::pin(async move {
                let result = spawner.spawn_pinned(Box::pin(async {}));
                assert!(result.is_ok());
            }));
        }

        assert_eq!(executor.run_until_stalled(), 2);
    }
}

mod spawn {
    use super::*;

    #[test]
    fn dead_spawner_does_nothing() {
        let run = Cell::new(false);
        let spawner = Spawner::dead();

        let result = unsafe { spawner.spawn(async { run.set(true) }) };
        assert!(!run.get());

        // Make sure the returned future is the same as the one passed in
        let mut future = pin!(result.unwrap_err().0);
        let mut context = Context::from_waker(Waker::noop());
        let poll = future.as_mut().poll(&mut context);
        assert!(poll.is_ready());
        assert!(run.get());
    }

    #[test]
    fn spawner_does_nothing_after_executor_was_dropped() {
        let run = Cell::new(false);
        let spawner = Executor::new().spawner();

        let result = unsafe { spawner.spawn(async { run.set(true) }) };
        assert!(!run.get());

        // Make sure the returned future is the same as the one passed in
        let mut future = pin!(result.unwrap_err().0);
        let mut context = Context::from_waker(Waker::noop());
        let poll = future.as_mut().poll(&mut context);
        assert!(poll.is_ready());
        assert!(run.get());
    }

    #[test]
    fn spawning_task_outside_task() {
        let executor = Executor::new();
        let spawner = executor.spawner();

        let receiver = unsafe { spawner.spawn(async { 123 }) }.unwrap();
        assert_eq!(executor.wake_count(), 1);
        assert_eq!(receiver.try_receive(), Err(TryReceiveError::NotSent));

        executor.step();
        assert_eq!(receiver.try_receive(), Ok(123));
    }

    #[test]
    fn spawning_task_inside_task() {
        let executor = Executor::new();
        let spawner = executor.spawner();
        unsafe {
            executor.spawn(async move {
                let result = spawner.spawn(async { 123 }).unwrap().await;
                assert_eq!(result, 123);
            });
        }

        assert_eq!(executor.run_until_stalled(), 2);
    }
}