Skip to content

Commit 40bfa7e

Browse files
nurmohammed840nurmohammed840
committed
test with miri
1 parent 620b2a9 commit 40bfa7e

File tree

4 files changed

+170
-141
lines changed

4 files changed

+170
-141
lines changed

‎.github/workflows/test.yml

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,5 +19,5 @@ jobs:
1919
run: cargo clippy
2020
- name: Run tests
2121
run: cargo test
22-
- name: Run Benchmark
23-
run: cargo bench
22+
- name: Run miri test
23+
run: cargo +nightly miri test --test stream --test try_stream

‎Cargo.toml

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -28,4 +28,5 @@ futures-util = "0.3"
2828
tokio = { version = "1", features = ["full"] }
2929

3030
async-stream = "*"
31-
criterion = "*"
31+
criterion = "*"
32+
futures = { version = "*", features = ["default"] }

‎tests/stream.rs

Lines changed: 141 additions & 118 deletions
Original file line numberDiff line numberDiff line change
@@ -1,159 +1,182 @@
11
use async_gen::{gen, GeneratorState};
2+
use futures::executor::block_on;
23
use futures_core::Stream;
34
use futures_util::stream::StreamExt;
45
use std::pin::pin;
56

6-
#[tokio::test]
7-
async fn noop_stream() {
8-
let mut gen = pin!(gen! {});
9-
assert_eq!(gen.resume().await, GeneratorState::Complete(()));
10-
}
11-
12-
#[tokio::test]
13-
async fn empty_stream() {
14-
let mut ran = false;
15-
{
16-
let r = &mut ran;
17-
let mut gen = pin!(gen! {
18-
*r = true;
19-
println!("hello world!");
20-
});
7+
#[test]
8+
fn noop_stream() {
9+
block_on(async {
10+
let mut gen = pin!(gen! {});
2111
assert_eq!(gen.resume().await, GeneratorState::Complete(()));
22-
}
23-
assert!(ran);
12+
})
2413
}
2514

26-
#[tokio::test]
27-
async fn yield_single_value() {
28-
let mut s = pin!(gen! {
29-
yield "hello";
15+
#[test]
16+
fn empty_stream() {
17+
block_on(async {
18+
let mut ran = false;
19+
{
20+
let r = &mut ran;
21+
let mut gen = pin!(gen! {
22+
*r = true;
23+
println!("hello world!");
24+
});
25+
assert_eq!(gen.resume().await, GeneratorState::Complete(()));
26+
}
27+
assert!(ran);
3028
});
31-
assert_eq!(s.resume().await, GeneratorState::Yielded("hello"));
32-
assert_eq!(s.resume().await, GeneratorState::Complete(()));
3329
}
3430

35-
#[tokio::test]
36-
async fn yield_multi_value() {
37-
let mut s = pin!(gen! {
38-
yield "hello";
39-
yield "world";
40-
yield "dizzy";
41-
});
42-
assert_eq!(s.resume().await, GeneratorState::Yielded("hello"));
43-
assert_eq!(s.resume().await, GeneratorState::Yielded("world"));
44-
assert_eq!(s.resume().await, GeneratorState::Yielded("dizzy"));
45-
assert_eq!(s.resume().await, GeneratorState::Complete(()));
31+
#[test]
32+
fn yield_single_value() {
33+
block_on(async {
34+
let mut s = pin!(gen! {
35+
yield "hello";
36+
});
37+
assert_eq!(s.resume().await, GeneratorState::Yielded("hello"));
38+
assert_eq!(s.resume().await, GeneratorState::Complete(()));
39+
})
4640
}
4741

48-
#[tokio::test]
49-
async fn return_stream() {
50-
fn build_stream() -> impl Stream<Item = i32> {
51-
gen! {
52-
yield 1;
53-
yield 2;
54-
yield 3;
42+
#[test]
43+
fn yield_multi_value() {
44+
block_on(async {
45+
let mut s = pin!(gen! {
46+
yield "hello";
47+
yield "world";
48+
yield "dizzy";
49+
});
50+
assert_eq!(s.resume().await, GeneratorState::Yielded("hello"));
51+
assert_eq!(s.resume().await, GeneratorState::Yielded("world"));
52+
assert_eq!(s.resume().await, GeneratorState::Yielded("dizzy"));
53+
assert_eq!(s.resume().await, GeneratorState::Complete(()));
54+
})
55+
}
56+
57+
#[test]
58+
fn return_stream() {
59+
block_on(async {
60+
fn build_stream() -> impl Stream<Item = i32> {
61+
gen! {
62+
yield 1;
63+
yield 2;
64+
yield 3;
65+
}
5566
}
56-
}
57-
let s = build_stream();
58-
59-
let values: Vec<_> = s.collect().await;
60-
assert_eq!(3, values.len());
61-
assert_eq!(1, values[0]);
62-
assert_eq!(2, values[1]);
63-
assert_eq!(3, values[2]);
67+
let s = build_stream();
68+
69+
let values: Vec<_> = s.collect().await;
70+
assert_eq!(3, values.len());
71+
assert_eq!(1, values[0]);
72+
assert_eq!(2, values[1]);
73+
assert_eq!(3, values[2]);
74+
})
6475
}
6576

66-
#[tokio::test]
67-
async fn consume_channel() {
68-
let (tx, mut rx) = tokio::sync::mpsc::channel(10);
69-
let mut s = pin!(gen! {
70-
while let Some(v) = rx.recv().await {
71-
yield v;
77+
#[test]
78+
fn consume_channel() {
79+
block_on(async {
80+
let (tx, mut rx) = tokio::sync::mpsc::channel(10);
81+
let mut s = pin!(gen! {
82+
while let Some(v) = rx.recv().await {
83+
yield v;
84+
}
85+
});
86+
for i in 0..3 {
87+
assert!(tx.send(i).await.is_ok());
88+
assert_eq!(Some(i), s.next().await);
7289
}
90+
drop(tx);
91+
assert_eq!(None, s.next().await);
7392
});
74-
for i in 0..3 {
75-
assert!(tx.send(i).await.is_ok());
76-
assert_eq!(Some(i), s.next().await);
77-
}
78-
drop(tx);
79-
assert_eq!(None, s.next().await);
8093
}
8194

82-
#[tokio::test]
83-
async fn borrow_self() {
84-
struct Data(String);
95+
#[test]
96+
fn borrow_self() {
97+
block_on(async {
98+
struct Data(String);
8599

86-
impl Data {
87-
fn stream(&self) -> impl Stream<Item = &str> + '_ {
88-
gen! {
89-
yield &self.0[..];
100+
impl Data {
101+
fn stream(&self) -> impl Stream<Item = &str> + '_ {
102+
gen! {
103+
yield &self.0[..];
104+
}
90105
}
91106
}
92-
}
93107

94-
let data = Data("hello".to_string());
95-
let mut s = pin!(data.stream());
96-
assert_eq!(Some("hello"), s.next().await);
108+
let data = Data("hello".to_string());
109+
let mut s = pin!(data.stream());
110+
assert_eq!(Some("hello"), s.next().await);
111+
})
97112
}
98113

99-
#[tokio::test]
100-
async fn stream_in_stream() {
101-
let s = gen! {
102-
let mut s = pin!(gen! {
103-
for i in 0..3 {
104-
yield i;
114+
#[test]
115+
fn stream_in_stream() {
116+
block_on(async {
117+
let s = gen! {
118+
let mut s = pin!(gen! {
119+
for i in 0..3 {
120+
yield i;
121+
}
122+
});
123+
while let Some(v) = s.next().await {
124+
yield v;
105125
}
106-
});
107-
while let Some(v) = s.next().await {
108-
yield v;
109-
}
110-
};
111-
let values: Vec<_> = s.collect().await;
112-
assert_eq!(3, values.len());
126+
};
127+
let values: Vec<_> = s.collect().await;
128+
assert_eq!(3, values.len());
129+
})
113130
}
114131

115-
#[tokio::test]
116-
async fn yield_non_unpin_value() {
117-
let s: Vec<_> = gen! {
118-
for i in 0..3 {
119-
yield async move { i };
132+
#[test]
133+
fn yield_non_unpin_value() {
134+
block_on(async {
135+
let s: Vec<_> = gen! {
136+
for i in 0..3 {
137+
yield async move { i };
138+
}
120139
}
121-
}
122-
.buffered(1)
123-
.collect()
124-
.await;
140+
.buffered(1)
141+
.collect()
142+
.await;
125143

126-
assert_eq!(s, vec![0, 1, 2]);
144+
assert_eq!(s, vec![0, 1, 2]);
145+
})
127146
}
128147

129-
#[tokio::test]
130-
async fn unit_yield_in_select() {
131-
async fn do_stuff_async() {}
148+
#[test]
149+
fn unit_yield_in_select() {
150+
block_on(async {
151+
async fn do_stuff_async() {}
132152

133-
let s = gen! {
134-
tokio::select! {
135-
_ = do_stuff_async() => { yield },
136-
else => { yield },
153+
let s = gen! {
154+
tokio::select! {
155+
_ = do_stuff_async() => { yield },
156+
else => { yield },
157+
};
137158
};
138-
};
139-
let values: Vec<_> = s.collect().await;
140-
assert_eq!(values.len(), 1);
159+
let values: Vec<_> = s.collect().await;
160+
assert_eq!(values.len(), 1);
161+
})
141162
}
142163

143-
#[tokio::test]
144-
async fn yield_with_select() {
145-
async fn do_stuff_async() {}
146-
async fn more_async_work() {}
147-
148-
let s = gen! {
149-
tokio::select! {
150-
_ = do_stuff_async() => { yield "hey" },
151-
_ = more_async_work() => { yield "hey" },
152-
else => { yield "hey" },
164+
#[test]
165+
fn yield_with_select() {
166+
block_on(async {
167+
async fn do_stuff_async() {}
168+
async fn more_async_work() {}
169+
170+
let s = gen! {
171+
tokio::select! {
172+
_ = do_stuff_async() => { yield "hey" },
173+
_ = more_async_work() => { yield "hey" },
174+
else => { yield "hey" },
175+
};
153176
};
154-
};
155-
let values: Vec<_> = s.collect().await;
156-
assert_eq!(values, vec!["hey"]);
177+
let values: Vec<_> = s.collect().await;
178+
assert_eq!(values, vec!["hey"]);
179+
})
157180
}
158181

159182
// #[test]

‎tests/try_stream.rs

Lines changed: 25 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,26 +1,31 @@
11
use async_gen::{gen, GeneratorState};
2+
use futures::executor::block_on;
23
use std::pin::pin;
34

4-
#[tokio::test]
5-
async fn single_err() {
6-
let mut s = pin!(gen! {
7-
if true {
8-
Err("hello")?;
9-
} else {
10-
yield "world";
11-
}
12-
Result::<_, &str>::Ok(())
13-
});
14-
assert_eq!(s.resume().await, GeneratorState::Complete(Err("hello")));
5+
#[test]
6+
fn single_err() {
7+
block_on(async {
8+
let mut s = pin!(gen! {
9+
if true {
10+
Err("hello")?;
11+
} else {
12+
yield "world";
13+
}
14+
Result::<_, &str>::Ok(())
15+
});
16+
assert_eq!(s.resume().await, GeneratorState::Complete(Err("hello")));
17+
})
1518
}
1619

17-
#[tokio::test]
18-
async fn yield_then_err() {
19-
let mut s = pin!(gen! {
20-
yield "hello";
21-
Err("world")?;
22-
Result::<_, &str>::Ok(())
23-
});
24-
assert_eq!(s.resume().await, GeneratorState::Yielded("hello"));
25-
assert_eq!(s.resume().await, GeneratorState::Complete(Err("world")));
20+
#[test]
21+
fn yield_then_err() {
22+
block_on(async {
23+
let mut s = pin!(gen! {
24+
yield "hello";
25+
Err("world")?;
26+
Result::<_, &str>::Ok(())
27+
});
28+
assert_eq!(s.resume().await, GeneratorState::Yielded("hello"));
29+
assert_eq!(s.resume().await, GeneratorState::Complete(Err("world")));
30+
})
2631
}

0 commit comments

Comments
 (0)