susync 0.2.0

An util crate to complete futures through a handle. Its main purpose is to bridge async Rust and callback-based APIs.
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use susync::sus;
use susync::SuspendFuture;

// ********************** HELPER FUNCTIONS **********************
// **************************************************************

fn test_fn_empty(_a: i32, func: impl FnOnce()) {
    func();
}

fn test_multiple(a: i32, func: impl FnOnce(i32, f32)) {
    func(a, 69.0);
}

fn test_return(a: i32, func: impl FnOnce(i32) -> i32) {
    assert_eq!(func(a), a);
}

fn test_multiple_closures(a: impl FnOnce(i32, i32), b: impl FnOnce(i32)) {
    a(42, 69);
    b(42);
}

fn test_closure_with_str(func: impl FnOnce(i32, &str)) {
    func(42, "test");
}

#[derive(Clone, Debug)]
struct RefArgMock {
    member: i32,
}

fn test_ref(a: i32, func: impl FnOnce(i32, &RefArgMock)) -> i32 {
    func(a, &RefArgMock { member: a });
    a
}

fn test_single_ref(a: i32, func: impl FnOnce(&RefArgMock)) -> i32 {
    func(&RefArgMock { member: a });
    a
}

// **************************** TESTS ***************************
// **************************************************************

#[tokio::test]
async fn macro_empty_args() {
    let fut: SuspendFuture<()> = sus!(test_fn_empty(42, || { println!() }));
    fut.await.expect("result must be Ok");
}

#[tokio::test]
async fn macro_multiple_args() {
    let fut: SuspendFuture<(i32, f32)> = sus!(test_multiple(42, |integer, float| {
        println!("args: ({}, {})", integer, float);
    }));

    let res = fut.await.expect("result must be Ok");
    assert_eq!(res, (42, 69.0));
}

#[tokio::test]
async fn macro_name_collision() {
    let _fut: SuspendFuture<(i32, f32)> = sus!(test_multiple(42, |handle, float| {
        println!("args: ({}, {})", handle, float);
    }));
}

#[tokio::test]
async fn macro_ignore_arg() {
    let fut: SuspendFuture<i32> = sus!(test_multiple(42, |integer, _| {
        println!("args: ({}, _)", integer);
    }));
    let res = fut.await.expect("result must be OK");
    assert_eq!(res, 42);
}

#[tokio::test]
async fn macro_ignore_all_args() {
    let fut = sus!(test_multiple(42, |_, _| {
        println!("args: (_, _)");
    }));
    fut.await.expect("result must be OK");
}

#[tokio::test]
async fn macro_assert_return() {
    let fut: SuspendFuture<i32> = sus!(test_return(42, |integer| {
        println!("args: {}", integer);
        integer
    }));
    let res = fut.await.expect("result must be OK");
    assert_eq!(res, 42);
}

#[tokio::test]
async fn macro_closure_no_braces() {
    let fut = sus!(test_return(42, |x| x));
    let res = fut.await.expect("result must be OK");
    assert_eq!(res, 42);
}

#[tokio::test]
async fn macro_closure_no_body() {
    let fut = sus!(test_multiple(42, |a, b| {}));
    let res = fut.await.expect("result must be OK");
    assert_eq!(res, (42, 69.0));
}

#[tokio::test]
async fn macro_move_closure() {
    let fut = sus!(test_multiple(42, move |_, _| {
        println!("args: (_, _)");
    }));
    fut.await.expect("result must be OK");
}

#[tokio::test]
async fn macro_last_closure() {
    let fut = sus!(test_multiple_closures(
        |_a, _b| {},
        |x| {
            println!("args: {x}");
        }
    ));
    let res = fut.await.expect("result must be Ok");
    assert_eq!(res, 42);
}

#[tokio::test]
async fn macro_str_arg() {
    let fut = sus!(test_closure_with_str(|a, b| {
        println!("args: ({a}, {b})");
    }));
    let res = fut.await.expect("result must be Ok");
    assert_eq!(res, (42, "test".to_owned()));
}

#[tokio::test]
async fn macro_ref_args() {
    let fut = sus!(test_ref(42, |integer, reference| {
        println!("args: ({}, {:?})", integer, reference);
    }));
    let (integer, reference) = fut.await.expect("result must be OK");
    assert_eq!(integer, 42);
    assert_eq!(reference.member, 42);
}

#[tokio::test]
async fn macro_ref_single_arg() {
    let fut = sus!(test_single_ref(42, |reference| {
        println!("args: {:?}", reference);
    }));
    let reference = fut.await.expect("result must be OK");
    assert_eq!(reference.member, 42);
}