Skip to content

Commit

Permalink
Reduce noise and document test case.
Browse files Browse the repository at this point in the history 
This commit introduces a `assert_drop_order_after_poll` helper function
to the test case for this case to reduce repetitive noise and documents
what each function aims to test.
  • Loading branch information
@davidtwco
davidtwco committed Apr 23, 2019
1 parent 09c707f commit 119e67a
Showing 1 changed file with 83 additions and 91 deletions.
174 changes: 83 additions & 91 deletions src/test/run-pass/issue-54716.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,7 @@ use std::cell::RefCell;
use std::future::Future;
use std::marker::PhantomData;
use std::sync::Arc;
use std::rc::Rc;
use std::task::Context;

struct EmptyWaker;
Expand All @@ -26,45 +27,59 @@ enum DropOrder {
Val(&'static str),
}

struct D(&'static str, Arc<RefCell<Vec<DropOrder>>>);
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));
}
}

/// Check that unused bindings are dropped after the function is polled.
async fn foo(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(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((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(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(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(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((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(x: D, (a, _, _c): (D, D, D), _: D, _y: D) {
x.1.borrow_mut().push(DropOrder::Function);
}
Expand All @@ -73,120 +88,97 @@ impl Foo {
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(&'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(&'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(&'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(&'a self, x: D, (a, _, _c): (D, D, D), _: D, _y: D) {
x.1.borrow_mut().push(DropOrder::Function);
}
}

fn main() {
fn assert_drop_order_after_poll<Fut: Future<Output = ()>>(
f: impl FnOnce(DropOrderListPtr) -> Fut,
expected_order: &[DropOrder],
) {
let empty = Arc::new(EmptyWaker);
let waker = ArcWake::into_waker(empty);
let mut cx = Context::from_waker(&waker);

use DropOrder::*;

// Currently, the `bar` and `foobar` tests do not output the same order as the equivalent
// non-async functions. This is because the drop order of captured variables doesn't match the
// drop order of arguments in a function.

// Free functions

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(foo(D("x", af.clone()), D("_y", af.clone())));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[Function, Val("_y"), Val("x")]);

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(bar(D("x", af.clone()), D("_", af.clone())));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[Function, Val("x"), Val("_")]);

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(baz((D("x", af.clone()), D("_", af.clone()))));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[Function, Val("x"), Val("_")]);

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(foobar(
D("x", af.clone()),
(D("a", af.clone()), D("_", af.clone()), D("_c", af.clone())),
D("_", af.clone()),
D("_y", af.clone()),
));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[
Function, Val("_y"), Val("_c"), Val("a"), Val("x"), Val("_"), Val("_"),
]);

// Methods w/out self

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(Foo::foo(D("x", af.clone()), D("_y", af.clone())));
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);
assert_eq!(*af.borrow(), &[Function, Val("_y"), Val("x")]);

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(Foo::bar(D("x", af.clone()), D("_", af.clone())));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[Function, Val("x"), Val("_")]);

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(Foo::baz((D("x", af.clone()), D("_", af.clone()))));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[Function, Val("x"), Val("_")]);

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(Foo::foobar(
D("x", af.clone()),
(D("a", af.clone()), D("_", af.clone()), D("_c", af.clone())),
D("_", af.clone()),
D("_y", af.clone()),
));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[
Function, Val("_y"), Val("_c"), Val("a"), Val("x"), Val("_"), Val("_"),
]);
assert_eq!(*actual_order.borrow(), expected_order);
}

// Methods
fn main() {
use DropOrder::*;

// At time of writing (23/04/19), the `bar` and `foobar` tests do not output the same order as
// the equivalent non-async functions. This is because the drop order of captured variables
// doesn't match the drop order of arguments in a function.

// Free functions (see doc comment on function for what it tests).
assert_drop_order_after_poll(|l| foo(D("x", l.clone()), D("_y", l.clone())),
&[Function, Val("_y"), Val("x")]);
assert_drop_order_after_poll(|l| bar(D("x", l.clone()), D("_", l.clone())),
&[Function, Val("x"), Val("_")]);
assert_drop_order_after_poll(|l| baz((D("x", l.clone()), D("_", l.clone()))),
&[Function, Val("x"), Val("_")]);
assert_drop_order_after_poll(|l| {
foobar(
D("x", l.clone()),
(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
D("_", l.clone()),
D("_y", l.clone()),
)
}, &[Function, Val("_y"), Val("_c"), Val("a"), Val("x"), Val("_"), Val("_")]);

// Methods w/out self (see doc comment on function for what it tests).
assert_drop_order_after_poll(|l| Foo::foo(D("x", l.clone()), D("_y", l.clone())),
&[Function, Val("_y"), Val("x")]);
assert_drop_order_after_poll(|l| Foo::bar(D("x", l.clone()), D("_", l.clone())),
&[Function, Val("x"), Val("_")]);
assert_drop_order_after_poll(|l| Foo::baz((D("x", l.clone()), D("_", l.clone()))),
&[Function, Val("x"), Val("_")]);
assert_drop_order_after_poll(|l| {
Foo::foobar(
D("x", l.clone()),
(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
D("_", l.clone()),
D("_y", l.clone()),
)
}, &[Function, Val("_y"), Val("_c"), Val("a"), Val("x"), Val("_"), Val("_")]);

// Methods (see doc comment on function for what it tests).
let b = Bar(Default::default());

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(b.foo(D("x", af.clone()), D("_y", af.clone())));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[Function, Val("_y"), Val("x")]);

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(b.bar(D("x", af.clone()), D("_", af.clone())));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[Function, Val("x"), Val("_")]);

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(b.baz((D("x", af.clone()), D("_", af.clone()))));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[Function, Val("x"), Val("_")]);

let af = Arc::new(RefCell::new(Vec::new()));
let mut fut = Box::pin(b.foobar(
D("x", af.clone()),
(D("a", af.clone()), D("_", af.clone()), D("_c", af.clone())),
D("_", af.clone()),
D("_y", af.clone()),
));
let _ = fut.as_mut().poll(&mut cx);
assert_eq!(*af.borrow(), &[
Function, Val("_y"), Val("_c"), Val("a"), Val("x"), Val("_"), Val("_"),
]);
assert_drop_order_after_poll(|l| b.foo(D("x", l.clone()), D("_y", l.clone())),
&[Function, Val("_y"), Val("x")]);
assert_drop_order_after_poll(|l| b.bar(D("x", l.clone()), D("_", l.clone())),
&[Function, Val("x"), Val("_")]);
assert_drop_order_after_poll(|l| b.baz((D("x", l.clone()), D("_", l.clone()))),
&[Function, Val("x"), Val("_")]);
assert_drop_order_after_poll(|l| {
b.foobar(
D("x", l.clone()),
(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
D("_", l.clone()),
D("_y", l.clone()),
)
}, &[Function, Val("_y"), Val("_c"), Val("a"), Val("x"), Val("_"), Val("_")]);
}

0 comments on commit 119e67a

Please sign in to comment.