test: unify MockTask and task::spawn (#1728)

Delete `MockTask` in favor of `task::spawn`. Both are functionally
equivalent.

1 files changed, 35 insertions, 50 deletions

diff --git a/tokio/tests/sync_semaphore.rs b/tokio/tests/sync_semaphore.rs
index 1b421248..93660532 100644
--- a/tokio/tests/sync_semaphore.rs
+++ b/tokio/tests/sync_semaphore.rs
@@ -1,53 +1,49 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::sync::semaphore::{Permit, Semaphore};
-use tokio_test::task::MockTask;
+use tokio_test::task;
 use tokio_test::{assert_pending, assert_ready_err, assert_ready_ok};
 
 #[test]
 fn available_permits() {
-    let mut t1 = MockTask::new();
-
     let s = Semaphore::new(100);
     assert_eq!(s.available_permits(), 100);
 
     // Polling for a permit succeeds immediately
-    let mut permit = Permit::new();
+    let mut permit = task::spawn(Permit::new());
     assert!(!permit.is_acquired());
 
-    assert_ready_ok!(t1.enter(|cx| permit.poll_acquire(cx, &s)));
+    assert_ready_ok!(permit.enter(|cx, mut p| p.poll_acquire(cx, &s)));
     assert_eq!(s.available_permits(), 99);
     assert!(permit.is_acquired());
 
     // Polling again on the same waiter does not claim a new permit
-    assert_ready_ok!(t1.enter(|cx| permit.poll_acquire(cx, &s)));
+    assert_ready_ok!(permit.enter(|cx, mut p| p.poll_acquire(cx, &s)));
     assert_eq!(s.available_permits(), 99);
     assert!(permit.is_acquired());
 }
 
 #[test]
 fn unavailable_permits() {
-    let mut t1 = MockTask::new();
-    let mut t2 = MockTask::new();
     let s = Semaphore::new(1);
 
-    let mut permit_1 = Permit::new();
-    let mut permit_2 = Permit::new();
+    let mut permit_1 = task::spawn(Permit::new());
+    let mut permit_2 = task::spawn(Permit::new());
 
     // Acquire the first permit
-    assert_ready_ok!(t1.enter(|cx| permit_1.poll_acquire(cx, &s)));
+    assert_ready_ok!(permit_1.enter(|cx, mut p| p.poll_acquire(cx, &s)));
     assert_eq!(s.available_permits(), 0);
 
-    t2.enter(|cx| {
+    permit_2.enter(|cx, mut p| {
         // Try to acquire the second permit
-        assert_pending!(permit_2.poll_acquire(cx, &s));
+        assert_pending!(p.poll_acquire(cx, &s));
     });
 
     permit_1.release(&s);
 
     assert_eq!(s.available_permits(), 0);
-    assert!(t2.is_woken());
-    assert_ready_ok!(t2.enter(|cx| permit_2.poll_acquire(cx, &s)));
+    assert!(permit_2.is_woken());
+    assert_ready_ok!(permit_2.enter(|cx, mut p| p.poll_acquire(cx, &s)));
 
     permit_2.release(&s);
     assert_eq!(s.available_permits(), 1);
@@ -55,22 +51,20 @@ fn unavailable_permits() {
 
 #[test]
 fn zero_permits() {
-    let mut t1 = MockTask::new();
-
     let s = Semaphore::new(0);
     assert_eq!(s.available_permits(), 0);
 
-    let mut permit = Permit::new();
+    let mut permit = task::spawn(Permit::new());
 
     // Try to acquire the permit
-    t1.enter(|cx| {
-        assert_pending!(permit.poll_acquire(cx, &s));
+    permit.enter(|cx, mut p| {
+        assert_pending!(p.poll_acquire(cx, &s));
     });
 
     s.add_permits(1);
 
-    assert!(t1.is_woken());
-    assert_ready_ok!(t1.enter(|cx| permit.poll_acquire(cx, &s)));
+    assert!(permit.is_woken());
+    assert_ready_ok!(permit.enter(|cx, mut p| p.poll_acquire(cx, &s)));
 }
 
 #[test]
@@ -82,62 +76,53 @@ fn validates_max_permits() {
 
 #[test]
 fn close_semaphore_prevents_acquire() {
-    let mut t1 = MockTask::new();
-
     let s = Semaphore::new(1);
     s.close();
 
     assert_eq!(1, s.available_permits());
 
-    let mut permit = Permit::new();
+    let mut permit = task::spawn(Permit::new());
 
-    assert_ready_err!(t1.enter(|cx| permit.poll_acquire(cx, &s)));
+    assert_ready_err!(permit.enter(|cx, mut p| p.poll_acquire(cx, &s)));
     assert_eq!(1, s.available_permits());
 }
 
 #[test]
 fn close_semaphore_notifies_permit1() {
-    let mut t1 = MockTask::new();
-
     let s = Semaphore::new(0);
-    let mut permit = Permit::new();
+    let mut permit = task::spawn(Permit::new());
 
-    assert_pending!(t1.enter(|cx| permit.poll_acquire(cx, &s)));
+    assert_pending!(permit.enter(|cx, mut p| p.poll_acquire(cx, &s)));
 
     s.close();
 
-    assert!(t1.is_woken());
-    assert_ready_err!(t1.enter(|cx| permit.poll_acquire(cx, &s)));
+    assert!(permit.is_woken());
+    assert_ready_err!(permit.enter(|cx, mut p| p.poll_acquire(cx, &s)));
 }
 
 #[test]
 fn close_semaphore_notifies_permit2() {
-    let mut t1 = MockTask::new();
-    let mut t2 = MockTask::new();
-    let mut t3 = MockTask::new();
-    let mut t4 = MockTask::new();
-
     let s = Semaphore::new(2);
 
-    let mut permit1 = Permit::new();
-    let mut permit2 = Permit::new();
-    let mut permit3 = Permit::new();
-    let mut permit4 = Permit::new();
+    let mut permit1 = task::spawn(Permit::new());
+    let mut permit2 = task::spawn(Permit::new());
+    let mut permit3 = task::spawn(Permit::new());
+    let mut permit4 = task::spawn(Permit::new());
 
     // Acquire a couple of permits
-    assert_ready_ok!(t1.enter(|cx| permit1.poll_acquire(cx, &s)));
-    assert_ready_ok!(t2.enter(|cx| permit2.poll_acquire(cx, &s)));
+    assert_ready_ok!(permit1.enter(|cx, mut p| p.poll_acquire(cx, &s)));
+    assert_ready_ok!(permit2.enter(|cx, mut p| p.poll_acquire(cx, &s)));
 
-    assert_pending!(t3.enter(|cx| permit3.poll_acquire(cx, &s)));
-    assert_pending!(t4.enter(|cx| permit4.poll_acquire(cx, &s)));
+    assert_pending!(permit3.enter(|cx, mut p| p.poll_acquire(cx, &s)));
+    assert_pending!(permit4.enter(|cx, mut p| p.poll_acquire(cx, &s)));
 
     s.close();
 
-    assert!(t3.is_woken());
-    assert!(t4.is_woken());
+    assert!(permit3.is_woken());
+    assert!(permit4.is_woken());
 
-    assert_ready_err!(t3.enter(|cx| permit3.poll_acquire(cx, &s)));
-    assert_ready_err!(t4.enter(|cx| permit4.poll_acquire(cx, &s)));
+    assert_ready_err!(permit3.enter(|cx, mut p| p.poll_acquire(cx, &s)));
+    assert_ready_err!(permit4.enter(|cx, mut p| p.poll_acquire(cx, &s)));
 
     assert_eq!(0, s.available_permits());
 
@@ -145,7 +130,7 @@ fn close_semaphore_notifies_permit2() {
 
     assert_eq!(1, s.available_permits());
 
-    assert_ready_err!(t1.enter(|cx| permit1.poll_acquire(cx, &s)));
+    assert_ready_err!(permit1.enter(|cx, mut p| p.poll_acquire(cx, &s)));
 
     permit2.release(&s);