tests: restore disabled tests and benches for BiLock (#2715)

futures-util/benches/bilock.rs

@@ -0,0 +1,68 @@
+#![feature(test)]
+#![cfg(feature = "bilock")]
+
+extern crate test;
+
+use futures::task::Poll;
+use futures_test::task::noop_context;
+use futures_util::lock::BiLock;
+
+use crate::test::Bencher;
+
+#[bench]
+fn contended(b: &mut Bencher) {
+ let mut context = noop_context();
+
+ b.iter(|| {
+ let (x, y) = BiLock::new(1);
+
+ for _ in 0..1000 {
+ let x_guard = match x.poll_lock(&mut context) {
+ Poll::Ready(guard) => guard,
+ _ => panic!(),
+ };
+
+ // Try poll second lock while first lock still holds the lock
+ match y.poll_lock(&mut context) {
+ Poll::Pending => (),
+ _ => panic!(),
+ };
+
+ drop(x_guard);
+
+ let y_guard = match y.poll_lock(&mut context) {
+ Poll::Ready(guard) => guard,
+ _ => panic!(),
+ };
+
+ drop(y_guard);
+ }
+ (x, y)
+ });
+}
+
+#[bench]
+fn lock_unlock(b: &mut Bencher) {
+ let mut context = noop_context();
+
+ b.iter(|| {
+ let (x, y) = BiLock::new(1);
+
+ for _ in 0..1000 {
+ let x_guard = match x.poll_lock(&mut context) {
+ Poll::Ready(guard) => guard,
+ _ => panic!(),
+ };
+
+ drop(x_guard);
+
+ let y_guard = match y.poll_lock(&mut context) {
+ Poll::Ready(guard) => guard,
+ _ => panic!(),
+ };
+
+ drop(y_guard);
+ }
+ (x, y)
+ })
+}

futures/tests_disabled/bilock.rs → futures/tests/bilock.rs

@@ -1,34 +1,38 @@
+#![cfg(feature = "bilock")]
+
+use futures::executor::block_on;
 use futures::future;
 use futures::stream;
-use futures::task;
+use futures::task::{Context, Poll};
+use futures::Future;
+use futures::StreamExt;
+use futures_test::task::noop_context;
 use futures_util::lock::BiLock;
+use std::pin::Pin;
 use std::thread;
 
-// mod support;
-// use support::*;
-
 #[test]
 fn smoke() {
- let future = future::lazy(|_| {
+ let future = future::lazy(|cx| {
  let (a, b) = BiLock::new(1);
 
  {
- let mut lock = match a.poll_lock() {
+ let mut lock = match a.poll_lock(cx) {
  Poll::Ready(l) => l,
  Poll::Pending => panic!("poll not ready"),
  };
  assert_eq!(*lock, 1);
  *lock = 2;
 
- assert!(b.poll_lock().is_pending());
- assert!(a.poll_lock().is_pending());
+ assert!(b.poll_lock(cx).is_pending());
+ assert!(a.poll_lock(cx).is_pending());
  }
 
- assert!(b.poll_lock().is_ready());
- assert!(a.poll_lock().is_ready());
+ assert!(b.poll_lock(cx).is_ready());
+ assert!(a.poll_lock(cx).is_ready());
 
  {
- let lock = match b.poll_lock() {
+ let lock = match b.poll_lock(cx) {
  Poll::Ready(l) => l,
  Poll::Pending => panic!("poll not ready"),
  };
@@ -40,34 +44,32 @@ fn smoke() {
  Ok::<(), ()>(())
  });
 
- assert!(task::spawn(future)
- .poll_future_notify(&notify_noop(), 0)
- .expect("failure in poll")
- .is_ready());
+ assert_eq!(block_on(future), Ok(()));
 }
 
 #[test]
 fn concurrent() {
  const N: usize = 10000;
+ let mut cx = noop_context();
  let (a, b) = BiLock::new(0);
 
  let a = Increment { a: Some(a), remaining: N };
- let b = stream::iter_ok(0..N).fold(b, |b, _n| {
- b.lock().map(|mut b| {
-  *b += 1;
-  b.unlock()
- })
+ let b = stream::iter(0..N).fold(b, |b, _n| async {
+ let mut g = b.lock().await;
+ *g += 1;
+ drop(g);
+ b
  });
 
- let t1 = thread::spawn(move || a.wait());
- let b = b.wait().expect("b error");
- let a = t1.join().unwrap().expect("a error");
+ let t1 = thread::spawn(move || block_on(a));
+ let b = block_on(b);
+ let a = t1.join().unwrap();
 
- match a.poll_lock() {
+ match a.poll_lock(&mut cx) {
  Poll::Ready(l) => assert_eq!(*l, 2 * N),
  Poll::Pending => panic!("poll not ready"),
  }
- match b.poll_lock() {
+ match b.poll_lock(&mut cx) {
  Poll::Ready(l) => assert_eq!(*l, 2 * N),
  Poll::Pending => panic!("poll not ready"),
  }
@@ -80,22 +82,22 @@ fn concurrent() {
  }
 
  impl Future for Increment {
- type Item = BiLock<usize>;
- type Error = ();
+ type Output = BiLock<usize>;
 
- fn poll(&mut self) -> Poll<BiLock<usize>, ()> {
+ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<BiLock<usize>> {
  loop {
  if self.remaining == 0 {
- return Ok(self.a.take().unwrap().into());
+ return self.a.take().unwrap().into();
  }
 
- let a = self.a.as_ref().unwrap();
- let mut a = match a.poll_lock() {
+ let a = self.a.as_mut().unwrap();
+ let mut a = match a.poll_lock(cx) {
  Poll::Ready(l) => l,
- Poll::Pending => return Ok(Poll::Pending),
+ Poll::Pending => return Poll::Pending,
  };
- self.remaining -= 1;
  *a += 1;
+ drop(a);
+ self.remaining -= 1;
  }
  }
  }