anyspawn 0.5.0

A generic task spawner compatible with any async runtime.
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
138
139
140
141
142

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

#![allow(missing_docs, reason = "test code")]
#![cfg(not(miri))] // miri doesn't work well with `insta` snapshots

//! Tests for `Spawner` implementations.

use anyspawn::{BoxedBlockingTask, BoxedFuture, SpawnCustom, Spawner};
use thread_aware::ThreadAware;
use thread_aware::closure::ThreadAwareAsyncFnOnce;

static_assertions::assert_impl_all!(Spawner: Send, Sync);

#[tokio::test]
async fn tokio_spawn_and_await() {
    let spawner = Spawner::new_tokio();
    let result = spawner.spawn(async { 42 }).await;
    assert_eq!(result, 42);
}

#[tokio::test]
async fn tokio_spawn_fire_and_forget() {
    let spawner = Spawner::new_tokio();
    let (tx, rx) = tokio::sync::oneshot::channel();
    let () = spawner
        .spawn(async move {
            tx.send(42).unwrap();
        })
        .await;

    assert_eq!(rx.await.unwrap(), 42);
}

#[test]
fn tokio_with_handle_spawn_and_await() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let spawner = Spawner::new_tokio_with_handle(rt.handle().clone());

    // Spawning with an explicit handle works even outside a Tokio runtime context.
    let result = rt.block_on(spawner.spawn(async { 42 }));
    assert_eq!(result, 42);
}

#[test]
fn tokio_with_handle_spawner_debug() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let spawner = Spawner::new_tokio_with_handle(rt.handle().clone());
    let debug_str = format!("{spawner:?}");
    assert_eq!(debug_str, r#"Spawner("tokio(handle)")"#);
}

/// A simple spawner that runs futures on background threads.
#[derive(ThreadAware, Clone)]
struct ThreadPoolSpawner;
impl SpawnCustom for ThreadPoolSpawner {
    fn spawn(&self, task: BoxedFuture) {
        std::thread::spawn(move || futures::executor::block_on(task));
    }

    fn spawn_anywhere(&self, task: Box<dyn ThreadAwareAsyncFnOnce<()>>) {
        self.spawn(task.call_once());
    }

    fn spawn_blocking(&self, task: BoxedBlockingTask) {
        std::thread::spawn(task);
    }
}

#[test]
fn custom_spawn_and_await() {
    let spawner = Spawner::new_custom("threadpool", ThreadPoolSpawner);

    let result = futures::executor::block_on(spawner.spawn(async { 42 }));
    assert_eq!(result, 42);
}

#[tokio::test]
async fn custom_spawn_fire_and_forget() {
    let spawner = Spawner::new_custom("threadpool", ThreadPoolSpawner);

    let (tx, rx) = std::sync::mpsc::channel();

    let () = spawner
        .spawn(async move {
            tx.send(42).unwrap();
        })
        .await;

    assert_eq!(rx.recv().unwrap(), 42);
}

#[test]
fn custom_spawner_debug() {
    let spawner = Spawner::new_custom("noop", ThreadPoolSpawner);
    let debug_str = format!("{spawner:?}");
    assert!(debug_str.contains("noop"));
}

#[tokio::test]
async fn tokio_spawn_anywhere() {
    let spawner = Spawner::new_tokio();
    let result = spawner.spawn_anywhere(42_i32, |x| async move { x + 1 }).await;
    assert_eq!(result, 43);
}

#[test]
fn tokio_with_handle_spawn_anywhere() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let spawner = Spawner::new_tokio_with_handle(rt.handle().clone());
    let result = rt.block_on(spawner.spawn_anywhere(10_i32, |x| async move { x * 2 }));
    assert_eq!(result, 20);
}

#[tokio::test]
async fn tokio_spawner_debug() {
    let spawner = Spawner::new_tokio();
    let debug_str = format!("{spawner:?}");
    assert_eq!(debug_str, r#"Spawner("tokio")"#);
}

#[tokio::test]
async fn tokio_spawn_blocking() {
    let spawner = Spawner::new_tokio();
    let result = spawner.spawn_blocking(|| 21 * 2).await;
    assert_eq!(result, 42);
}

#[test]
fn tokio_with_handle_spawn_blocking() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let spawner = Spawner::new_tokio_with_handle(rt.handle().clone());
    let result = rt.block_on(spawner.spawn_blocking(|| 7 * 6));
    assert_eq!(result, 42);
}

#[test]
fn custom_spawn_blocking() {
    let spawner = Spawner::new_custom("threadpool", ThreadPoolSpawner);
    let result = futures::executor::block_on(spawner.spawn_blocking(|| 100 + 23));
    assert_eq!(result, 123);
}