update test__greenletset.py and test__pool.py

greentest/test__greenletset.py

@@ -37,30 +37,30 @@ class Test(greentest.TestCase):
         s.spawn(gevent.sleep, DELAY*2)
         assert len(s)==2, s
         start = time.time()
-        s.joinall(raise_error=True)
+        s.join(raise_error=True)
         delta = time.time() - start
         assert not s, s
         assert len(s)==0, s
         assert DELAY*2 < delta < DELAY*2.5, delta
 
-    def test_killall_wait(self):
+    def test_kill_block(self):
         s = pool.GreenletSet()
         s.spawn(gevent.sleep, DELAY)
         s.spawn(gevent.sleep, DELAY*2)
         assert len(s)==2, s
         start = time.time()
-        s.killall(block=True)
+        s.kill(block=True)
         assert not s, s
         assert len(s)==0, s
         delta = time.time() - start
         assert delta < DELAY*0.5, delta
 
-    def test_killall_nowait(self):
+    def test_kill_noblock(self):
         s = pool.GreenletSet()
         s.spawn(gevent.sleep, DELAY)
         s.spawn(gevent.sleep, DELAY*2)
         assert len(s)==2, s
-        s.killall()
+        s.kill(block=False)
         assert len(s)==2, s
         gevent.sleep(0)
         assert not s, s
@@ -73,30 +73,30 @@ class Test(greentest.TestCase):
         p2 = gevent.spawn(u2)
         s = pool.GreenletSet([p1, p2])
         assert u1.shot_count == 0, u1.shot_count
-        s.kill(p1)
+        s.killonce(p1)
         assert u1.shot_count == 0, u1.shot_count
         gevent.sleep(0)
         assert u1.shot_count == 1, u1.shot_count
-        s.kill(p1)
+        s.killonce(p1)
         assert u1.shot_count == 1, u1.shot_count
-        s.kill(p1)
+        s.killonce(p1)
         assert u2.shot_count == 0, u2.shot_count
-        s.killall()
-        s.killall()
-        s.killall()
+        s.kill()
+        s.kill()
+        s.kill()
         assert u1.shot_count == 1, u1.shot_count
         assert u2.shot_count == 0, u2.shot_count
         gevent.sleep(DELAY)
         assert u1.shot_count == 1, u1.shot_count
         assert u2.shot_count == 1, u2.shot_count
         X = object()
-        assert X is gevent.with_timeout(DELAY, s.killall, block=True, timeout_value=X)
+        assert X is gevent.with_timeout(DELAY, s.kill, block=True, timeout_value=X)
 
     def test_killall_subclass(self):
         p1 = GreenletSubclass.spawn(lambda : 1/0)
         p2 = GreenletSubclass.spawn(lambda : gevent.sleep(10))
         s = pool.GreenletSet([p1, p2])
-        s.killall(block=True)
+        s.kill(block=True)
 
 
 class GreenletSubclass(gevent.Greenlet):

greentest/test__pool.py

@@ -6,23 +6,23 @@ from greentest import TestCase, main
 class TestCoroutinePool(TestCase):
     klass = pool.Pool
 
-    def test_execute_async(self):
+    def test_apply_async(self):
         done = Event()
         def some_work(x):
             print 'puttin'
             done.put()
             print 'done putting'
         pool = self.klass(2)
-        pool.execute_async(some_work, 'x')
+        pool.apply_async(some_work, ('x', ))
         done.get()
 
-    def test_execute(self):
+    def test_apply(self):
         value = 'return value'
         def some_work():
             return value
         pool = self.klass(2)
-        worker = pool.execute(some_work)
-        self.assertEqual(value, worker.get())
+        result = pool.apply(some_work)
+        self.assertEqual(value, result)
 
     def test_multiple_coros(self):
         evt = Event()
@@ -37,8 +37,8 @@ class TestCoroutinePool(TestCase):
             results.append('cons2')
 
         pool = self.klass(2)
-        done = pool.execute(consumer)
-        pool.execute_async(producer)
+        done = pool.spawn(consumer)
+        pool.apply_async(producer)
         done.get()
         self.assertEquals(['cons1', 'prod', 'cons2'], results)
 
@@ -49,26 +49,24 @@ class TestCoroutinePool(TestCase):
         def some_work():
             gevent.timer(0, fire_timer)
         pool = self.klass(2)
-        worker = pool.execute(some_work)
-        worker.get()
+        pool.apply(some_work)
         gevent.sleep(0)
         self.assertEquals(timer_fired, [])
 
     def test_reentrant(self):
         pool = self.klass(1)
         def reenter():
-            waiter = pool.execute(lambda a: a, 'reenter')
-            self.assertEqual('reenter', waiter.get())
+            result = pool.apply(lambda a: a, ('reenter', ))
+            self.assertEqual('reenter', result)
 
-        outer_waiter = pool.execute(reenter)
-        outer_waiter.get()
+        pool.apply(reenter)
 
         evt = Event()
         def reenter_async():
-            pool.execute_async(lambda a: a, 'reenter')
+            pool.apply_async(lambda a: a, ('reenter', ))
             evt.put('done')
 
-        pool.execute_async(reenter_async)
+        pool.apply_async(reenter_async)
         evt.get()
 
     def test_stderr_raising(self):
@@ -87,7 +85,7 @@ class TestCoroutinePool(TestCase):
         normal_err = sys.stderr
         try:
             sys.stderr = FakeFile()
-            waiter = pool.execute(crash)
+            waiter = pool.spawn(crash)
             self.assertRaises(RuntimeError, waiter.get)
             # the pool should have something free at this point since the
             # waiter returned
@@ -100,7 +98,7 @@ class TestCoroutinePool(TestCase):
             # shouldn't block when trying to get
             t = gevent.Timeout(0.1)
             try:
-                pool.execute(gevent.sleep, 1)
+                pool.spawn(gevent.sleep, (1, ))
             finally:
                 t.cancel()
         finally:
@@ -116,32 +114,32 @@ class PoolBasicTests(TestCase):
         r = []
         def foo(a):
             r.append(a)
-        evt = p.execute(foo, 1)
+        first = p.spawn(foo, 1)
         self.assertEqual(p.free_count(), 1)
-        evt.get()
+        first.get()
         self.assertEqual(r, [1])
         gevent.sleep(0)
         self.assertEqual(p.free_count(), 2)
 
         #Once the pool is exhausted, calling an execute forces a yield.
 
-        p.execute_async(foo, 2)
+        p.apply_async(foo, (2, ))
         self.assertEqual(1, p.free_count())
         self.assertEqual(r, [1])
 
-        p.execute_async(foo, 3)
+        p.apply_async(foo, (3, ))
         self.assertEqual(0, p.free_count())
         self.assertEqual(r, [1])
 
-        p.execute_async(foo, 4)
+        p.apply_async(foo, (4, ))
         self.assertEqual(r, [1])
         gevent.sleep(0.01)
         self.assertEqual(r, [1,2,3,4])
 
     def test_execute(self):
         p = self.klass()
-        evt = p.execute(lambda a: ('foo', a), 1)
-        self.assertEqual(evt.get(), ('foo', 1))
+        result = p.apply(lambda a: ('foo', a), (1, ))
+        self.assertEqual(result, ('foo', 1))
 
 
 if __name__=='__main__':