Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
int
Rust
提交
f40190a6
R
Rust
项目概览
int
/
Rust
大约 1 年 前同步成功
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
Rust
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
f40190a6
编写于
8月 05, 2019
作者:
D
David Laban
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
test drop order for parameters when a future is dropped part-way through execution
上级
0a1bdd4a
变更
1
隐藏空白更改
内联
并排
Showing
1 changed file
with
307 addition
and
0 deletion
+307
-0
src/test/ui/async-await/drop-order/drop-order-when-cancelled.rs
...st/ui/async-await/drop-order/drop-order-when-cancelled.rs
+307
-0
未找到文件。
src/test/ui/async-await/drop-order/drop-order-when-cancelled.rs
0 → 100644
浏览文件 @
f40190a6
// aux-build:arc_wake.rs
// edition:2018
// run-pass
#![allow(unused_variables)]
#![feature(async_await)]
// Test that the drop order for parameters in a fn and async fn matches up. Also test that
// parameters (used or unused) are not dropped until the async fn is cancelled.
// This file is mostly copy-pasted from drop-order-for-async-fn-parameters.rs
extern
crate
arc_wake
;
use
arc_wake
::
ArcWake
;
use
std
::
cell
::
RefCell
;
use
std
::
future
::
Future
;
use
std
::
marker
::
PhantomData
;
use
std
::
pin
::
Pin
;
use
std
::
rc
::
Rc
;
use
std
::
sync
::
Arc
;
use
std
::
task
::{
Context
,
Poll
};
struct
EmptyWaker
;
impl
ArcWake
for
EmptyWaker
{
fn
wake
(
self
:
Arc
<
Self
>
)
{}
}
#[derive(Debug,
Eq,
PartialEq)]
enum
DropOrder
{
Function
,
Val
(
&
'static
str
),
}
type
DropOrderListPtr
=
Rc
<
RefCell
<
Vec
<
DropOrder
>>>
;
struct
D
(
&
'static
str
,
DropOrderListPtr
);
impl
Drop
for
D
{
fn
drop
(
&
mut
self
)
{
self
.1
.borrow_mut
()
.push
(
DropOrder
::
Val
(
self
.0
));
}
}
struct
NeverReady
;
impl
Future
for
NeverReady
{
type
Output
=
();
fn
poll
(
mut
self
:
Pin
<&
mut
Self
>
,
cx
:
&
mut
Context
)
->
Poll
<
Self
::
Output
>
{
Poll
::
Pending
}
}
/// Check that unused bindings are dropped after the function is polled.
async
fn
foo_async
(
x
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
foo_sync
(
x
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
/// Check that underscore patterns are dropped after the function is polled.
async
fn
bar_async
(
x
:
D
,
_
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
bar_sync
(
x
:
D
,
_
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
/// Check that underscore patterns within more complex patterns are dropped after the function
/// is polled.
async
fn
baz_async
((
x
,
_
):
(
D
,
D
))
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
baz_sync
((
x
,
_
):
(
D
,
D
))
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
/// Check that underscore and unused bindings within and outwith more complex patterns are dropped
/// after the function is polled.
async
fn
foobar_async
(
x
:
D
,
(
a
,
_
,
_
c
):
(
D
,
D
,
D
),
_
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
foobar_sync
(
x
:
D
,
(
a
,
_
,
_
c
):
(
D
,
D
,
D
),
_
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
struct
Foo
;
impl
Foo
{
/// Check that unused bindings are dropped after the method is polled.
async
fn
foo_async
(
x
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
foo_sync
(
x
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
/// Check that underscore patterns are dropped after the method is polled.
async
fn
bar_async
(
x
:
D
,
_
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
bar_sync
(
x
:
D
,
_
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
/// Check that underscore patterns within more complex patterns are dropped after the method
/// is polled.
async
fn
baz_async
((
x
,
_
):
(
D
,
D
))
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
baz_sync
((
x
,
_
):
(
D
,
D
))
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
/// Check that underscore and unused bindings within and outwith more complex patterns are
/// dropped after the method is polled.
async
fn
foobar_async
(
x
:
D
,
(
a
,
_
,
_
c
):
(
D
,
D
,
D
),
_
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
foobar_sync
(
x
:
D
,
(
a
,
_
,
_
c
):
(
D
,
D
,
D
),
_
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
}
struct
Bar
<
'a
>
(
PhantomData
<&
'a
()
>
);
impl
<
'a
>
Bar
<
'a
>
{
/// Check that unused bindings are dropped after the method with self is polled.
async
fn
foo_async
(
&
'a
self
,
x
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
foo_sync
(
&
'a
self
,
x
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
/// Check that underscore patterns are dropped after the method with self is polled.
async
fn
bar_async
(
&
'a
self
,
x
:
D
,
_
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
bar_sync
(
&
'a
self
,
x
:
D
,
_
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
/// Check that underscore patterns within more complex patterns are dropped after the method
/// with self is polled.
async
fn
baz_async
(
&
'a
self
,
(
x
,
_
):
(
D
,
D
))
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
baz_sync
(
&
'a
self
,
(
x
,
_
):
(
D
,
D
))
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
/// Check that underscore and unused bindings within and outwith more complex patterns are
/// dropped after the method with self is polled.
async
fn
foobar_async
(
&
'a
self
,
x
:
D
,
(
a
,
_
,
_
c
):
(
D
,
D
,
D
),
_
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
NeverReady
.await
;
}
fn
foobar_sync
(
&
'a
self
,
x
:
D
,
(
a
,
_
,
_
c
):
(
D
,
D
,
D
),
_
:
D
,
_
y
:
D
)
{
x
.1
.borrow_mut
()
.push
(
DropOrder
::
Function
);
}
}
fn
assert_drop_order_after_cancel
<
Fut
:
Future
<
Output
=
()
>>
(
f
:
impl
FnOnce
(
DropOrderListPtr
)
->
Fut
,
g
:
impl
FnOnce
(
DropOrderListPtr
),
)
{
let
empty
=
Arc
::
new
(
EmptyWaker
);
let
waker
=
ArcWake
::
into_waker
(
empty
);
let
mut
cx
=
Context
::
from_waker
(
&
waker
);
let
actual_order
=
Rc
::
new
(
RefCell
::
new
(
Vec
::
new
()));
let
mut
fut
=
Box
::
pin
(
f
(
actual_order
.clone
()));
let
_
=
fut
.as_mut
()
.poll
(
&
mut
cx
);
// Parameters are never dropped until the future completes.
assert_eq!
(
*
actual_order
.borrow
(),
vec!
[
DropOrder
::
Function
]);
drop
(
fut
);
let
expected_order
=
Rc
::
new
(
RefCell
::
new
(
Vec
::
new
()));
g
(
expected_order
.clone
());
assert_eq!
(
*
actual_order
.borrow
(),
*
expected_order
.borrow
());
}
fn
main
()
{
// Free functions (see doc comment on function for what it tests).
assert_drop_order_after_cancel
(
|
l
|
foo_async
(
D
(
"x"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
())),
|
l
|
foo_sync
(
D
(
"x"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
())),
);
assert_drop_order_after_cancel
(
|
l
|
bar_async
(
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
())),
|
l
|
bar_sync
(
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
())),
);
assert_drop_order_after_cancel
(
|
l
|
baz_async
((
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()))),
|
l
|
baz_sync
((
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()))),
);
assert_drop_order_after_cancel
(
|
l
|
{
foobar_async
(
D
(
"x"
,
l
.clone
()),
(
D
(
"a"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()),
D
(
"_c"
,
l
.clone
())),
D
(
"_"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
()),
)
},
|
l
|
{
foobar_sync
(
D
(
"x"
,
l
.clone
()),
(
D
(
"a"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()),
D
(
"_c"
,
l
.clone
())),
D
(
"_"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
()),
)
},
);
// Methods w/out self (see doc comment on function for what it tests).
assert_drop_order_after_cancel
(
|
l
|
Foo
::
foo_async
(
D
(
"x"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
())),
|
l
|
Foo
::
foo_sync
(
D
(
"x"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
())),
);
assert_drop_order_after_cancel
(
|
l
|
Foo
::
bar_async
(
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
())),
|
l
|
Foo
::
bar_sync
(
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
())),
);
assert_drop_order_after_cancel
(
|
l
|
Foo
::
baz_async
((
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()))),
|
l
|
Foo
::
baz_sync
((
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()))),
);
assert_drop_order_after_cancel
(
|
l
|
{
Foo
::
foobar_async
(
D
(
"x"
,
l
.clone
()),
(
D
(
"a"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()),
D
(
"_c"
,
l
.clone
())),
D
(
"_"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
()),
)
},
|
l
|
{
Foo
::
foobar_sync
(
D
(
"x"
,
l
.clone
()),
(
D
(
"a"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()),
D
(
"_c"
,
l
.clone
())),
D
(
"_"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
()),
)
},
);
// Methods (see doc comment on function for what it tests).
let
b
=
Bar
(
Default
::
default
());
assert_drop_order_after_cancel
(
|
l
|
b
.foo_async
(
D
(
"x"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
())),
|
l
|
b
.foo_sync
(
D
(
"x"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
())),
);
assert_drop_order_after_cancel
(
|
l
|
b
.bar_async
(
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
())),
|
l
|
b
.bar_sync
(
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
())),
);
assert_drop_order_after_cancel
(
|
l
|
b
.baz_async
((
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()))),
|
l
|
b
.baz_sync
((
D
(
"x"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()))),
);
assert_drop_order_after_cancel
(
|
l
|
{
b
.foobar_async
(
D
(
"x"
,
l
.clone
()),
(
D
(
"a"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()),
D
(
"_c"
,
l
.clone
())),
D
(
"_"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
()),
)
},
|
l
|
{
b
.foobar_sync
(
D
(
"x"
,
l
.clone
()),
(
D
(
"a"
,
l
.clone
()),
D
(
"_"
,
l
.clone
()),
D
(
"_c"
,
l
.clone
())),
D
(
"_"
,
l
.clone
()),
D
(
"_y"
,
l
.clone
()),
)
},
);
}
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录