af-core 0.1.8

A core library and async runtime for Rust applications.
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

// Copyright © 2021 Alexandra Frydl
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use af_core::task;
use af_core::test::prelude::*;
use event_listener::Event;

/// Test the `future` module.
pub fn test(cx: &mut test::Context) {
  test!(cx, "::catch_unwind()", timeout = immediate, {
    let output = future::catch_unwind(async move { panic!("Hello.") }).await;

    match output {
      Err(value) => {
        let value: Box<&'static str> = match value.downcast() {
          Ok(value) => value,
          Err(_) => fail!("Value was not a `&'static str`."),
        };

        fail::when!(*value != "Hello.", "Unexpected value: {:?}.", value);
      }

      _ => fail!("Did not panic."),
    }
  });

  test!(cx, "::forever()", timeout = "1 s", {
    let forever = future::forever::<()>();

    pin!(forever);

    // Obviously can't test that it waits forever, but can test that it waits.

    task::sleep(Duration::hz(60)).await;

    fail::when!(future::poll(&mut forever).is_some(), "Completed.");
  });

  cx.scope("::poll()", |cx| {
    test!(cx, "polls the future", timeout = immediate, {
      let event = Event::new();
      let listener = event.listen();
      let notify = async move { event.notify(1) };

      pin!(notify);

      future::poll(&mut notify);

      listener.await;
    });

    test!(cx, "returns output when ready", timeout = "1 s", {
      let ready = async { "hello" };

      pin!(ready);

      let ready = future::poll(&mut ready);

      fail::when!(ready.is_none());
      fail::when!(ready != "hello");
    });
  });

  cx.scope("::race()", |cx| {
    test!(cx, "returns the first ready output", timeout = "1 s", {
      let a = async {
        task::sleep(Duration::hours(1)).await;
        "a"
      };

      let b = async {
        task::yield_now().await;
        "b"
      };

      let output = future::race(a, b).await;

      fail::when!(output != "b");
    });

    test!(cx, "prefers the first future", timeout = "1 s", {
      let a = async { "a" };
      let b = async { "b" };

      let output = future::race(a, b).await;

      fail::when!(output != "a");
    });
  });

  cx.scope("::try_resolve()", |cx| {
    test!(cx, "polls the future", timeout = immediate, {
      let event = Event::new();
      let listener = event.listen();

      future::try_resolve(async move { event.notify(1) });

      listener.await;
    });

    test!(cx, "returns output when ready", timeout = "1 s", {
      let ready = future::try_resolve(async { "hello" });

      fail::when!(ready.is_none());
      fail::when!(ready != "hello");
    });
  });

  cx.scope("::TryFutureExt", |cx| {
    test!(cx, "::map_err()", timeout = immediate, {
      let fut = async {
        fail!("inner");

        #[allow(unreachable_code)]
        Ok(())
      };

      match fut.map_err(|err| fail::err!("outer {}", err)).await {
        Ok(_) => fail!("Succeeded."),
        Err(err) => {
          fail::when!(err.to_string() != "outer inner", "Unexpected output: {:?}.", err.to_string())
        }
      }
    });
  });
}