arty 0.5.0

Single-threaded, thread-aware application 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

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

//! Borrowing factories and pinned futures are destroyed before a root join returns.

#![cfg(feature = "rt")]
#![cfg(test)]

mod panic_support;

use std::cell::Cell;
use std::error::Error as _;
use std::marker::PhantomPinned;
use std::pin::Pin;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::task::{Context, Poll};

use panic_support::runtime;

testing_aids::init_tracing!();

struct BorrowedTask<'a> {
    drops: &'a AtomicUsize,
    address: Cell<Option<usize>>,
    panic_poll: bool,
    panic_drop: bool,
    _pinned: PhantomPinned,
}

impl Future for BorrowedTask<'_> {
    type Output = u32;

    fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<u32> {
        let this = self.as_ref().get_ref();
        this.address.set(Some(std::ptr::from_ref(this).addr()));
        assert!(!this.panic_poll, "borrowed pinned task poll");
        Poll::Ready(42)
    }
}

impl Drop for BorrowedTask<'_> {
    fn drop(&mut self) {
        assert_eq!(Some(std::ptr::from_ref(self).addr()), self.address.get());
        self.drops.fetch_add(1, Ordering::SeqCst);
        assert!(!self.panic_drop, "borrowed pinned task destructor");
    }
}

#[test]
fn pinned_borrowing_future_teardown_precedes_root_return() {
    let runtime = runtime();
    for (panic_poll, panic_drop) in [(false, false), (true, false), (false, true)] {
        let drops = AtomicUsize::new(0);
        let result = runtime.scheduler().block_on(|_| BorrowedTask {
            drops: &drops,
            address: Cell::new(None),
            panic_poll,
            panic_drop,
            _pinned: PhantomPinned,
        });
        assert_eq!(drops.load(Ordering::SeqCst), 1);
        if panic_poll || panic_drop {
            assert!(
                result
                    .unwrap_err()
                    .source()
                    .unwrap()
                    .downcast_ref::<arty::task::JoinError>()
                    .unwrap()
                    .is_panic()
            );
        } else {
            assert_eq!(result.unwrap(), 42);
        }
        assert_eq!(runtime.scheduler().block_on(async |_| 7).unwrap(), 7);
    }
    runtime.stop().unwrap();
}

#[test]
fn borrowed_factory_capture_drop_panic_is_reported_after_destruction() {
    struct Capture<'a>(&'a AtomicUsize);

    impl Drop for Capture<'_> {
        fn drop(&mut self) {
            self.0.fetch_add(1, Ordering::SeqCst);
            panic!("borrowed factory capture destructor");
        }
    }

    let runtime = runtime();
    let drops = AtomicUsize::new(0);
    let capture = Capture(&drops);
    let result = runtime.scheduler().block_on(move |_| {
        drop(capture);
        std::future::ready(42)
    });
    assert_eq!(drops.load(Ordering::SeqCst), 1);
    assert!(
        result
            .unwrap_err()
            .source()
            .unwrap()
            .downcast_ref::<arty::task::JoinError>()
            .unwrap()
            .is_panic()
    );
    assert_eq!(runtime.scheduler().block_on(async |_| 7).unwrap(), 7);
    runtime.stop().unwrap();
}