python3 compatibility

- __next__ for iterator interface - six.next() to get next item - list(dict.keys()) - popen2.popen4 -> subprocess - s2b -> b"..." literals - deprecated assertEquals -> assertEqual - hub_test test_fork using run_python - 1L -> 1 long literal - many PEP-8 fixes
author: Sergey Shepelev <temotor@gmail.com> 2014-04-24 17:51:27 +0400
committer: Sergey Shepelev <temotor@gmail.com> 2014-04-24 18:11:37 +0400
commit: cbd404d56e231ea5419f07795a12d7082dd70ec4 (patch)
tree: 7ad24a0f80e064b94108bb38b8c4a8a3eebafb44 /tests
parent: c467ded4a6e777518cd7a3888149510e3b31d334 (diff)
download: eventlet-cbd404d56e231ea5419f07795a12d7082dd70ec4.tar.gz
22 files changed, 463 insertions, 416 deletions
diff --git a/tests/__init__.py b/tests/__init__.py
index 66eb5b0..2234f0d 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -22,11 +22,6 @@ from eventlet import tpool
 main = unittest.main
 
 
-def s2b(s):
-    """portable way to convert string to bytes. In 3.x socket.send and recv require bytes"""
-    return s.encode()
-
-
 def skipped(func):
     """ Decorator that marks a function as skipped.  Uses nose's SkipTest exception
     if installed.  Without nose, this will count skipped tests as passing tests."""
diff --git a/tests/api_test.py b/tests/api_test.py
index 3ed98a8..2ee0886 100644
--- a/tests/api_test.py
+++ b/tests/api_test.py
@@ -4,12 +4,12 @@ from unittest import TestCase, main
 import warnings
 
 import eventlet
+from eventlet import greenio, util, hubs, greenthread, spawn
+from tests import skip_if_no_ssl
+
 warnings.simplefilter('ignore', DeprecationWarning)
 from eventlet import api
 warnings.simplefilter('default', DeprecationWarning)
-from eventlet import greenio, util, hubs, greenthread, spawn
-
-from tests import skip_if_no_ssl
 
 
 def check_hub():
@@ -57,7 +57,7 @@ class TestApi(TestCase):
         client.close()
         assert fd.readline() == b'hello\n'
 
-        assert fd.read() == ''
+        assert fd.read() == b''
         fd.close()
 
         check_hub()
@@ -85,7 +85,7 @@ class TestApi(TestCase):
 
         assert fd.readline() == b'hello\r\n'
         try:
-            self.assertEquals('', fd.read(10))
+            self.assertEqual(b'', fd.read(10))
         except greenio.SSL.ZeroReturnError:
             # if it's a GreenSSL object it'll do this
             pass
@@ -147,9 +147,7 @@ class TestApi(TestCase):
 
     def test_named(self):
         named_foo = api.named('tests.api_test.Foo')
-        self.assertEquals(
-            named_foo.__name__,
-            "Foo")
+        self.assertEqual(named_foo.__name__, "Foo")
 
     def test_naming_missing_class(self):
         self.assertRaises(
@@ -171,19 +169,25 @@ class TestApi(TestCase):
             # thus after the function's done, the control will go to the parent
             api.sleep(0)
             state.append('finished')
+
         g = api.spawn(test)
-        api.sleep(DELAY/2)
-        self.assertEquals(state, ['start'])
+        api.sleep(DELAY / 2)
+        self.assertEqual(state, ['start'])
         api.kill(g)
         # will not get there, unless switching is explicitly scheduled by kill
-        self.assertEquals(state, ['start', 'except'])
+        self.assertEqual(state, ['start', 'except'])
         api.sleep(DELAY)
-        self.assertEquals(state, ['start', 'except', 'finished'])
+        self.assertEqual(state, ['start', 'except', 'finished'])
 
     def test_nested_with_timeout(self):
         def func():
             return api.with_timeout(0.2, api.sleep, 2, timeout_value=1)
-        self.assertRaises(api.TimeoutError, api.with_timeout, 0.1, func)
+
+        try:
+            api.with_timeout(0.1, func)
+            self.fail(u'Expected api.TimeoutError')
+        except api.TimeoutError:
+            pass
 
 
 class Foo(object):
diff --git a/tests/backdoor_test.py b/tests/backdoor_test.py
index 8c6a424..5df6d35 100644
--- a/tests/backdoor_test.py
+++ b/tests/backdoor_test.py
@@ -18,11 +18,11 @@ class BackdoorTest(LimitedTestCase):
         f.readline()  # build info
         f.readline()  # help info
         self.assert_(b'InteractiveConsole' in f.readline())
-        self.assertEquals(b'>>> ', f.read(4))
+        self.assertEqual(b'>>> ', f.read(4))
         f.write(b'print("hi")\n')
         f.flush()
-        self.assertEquals(b'hi\n', f.readline())
-        self.assertEquals(b'>>> ', f.read(4))
+        self.assertEqual(b'hi\n', f.readline())
+        self.assertEqual(b'>>> ', f.read(4))
         f.close()
         client.close()
         serv.kill()
diff --git a/tests/convenience_test.py b/tests/convenience_test.py
index 82b58eb..1a2beda 100644
--- a/tests/convenience_test.py
+++ b/tests/convenience_test.py
@@ -1,10 +1,10 @@
 import os
 
 import eventlet
-from eventlet import event
+from eventlet import debug, event
 from eventlet.green import socket
 from eventlet.support import six
-from tests import LimitedTestCase, s2b, skip_if_no_ssl
+from tests import LimitedTestCase, skip_if_no_ssl
 
 
 certificate_file = os.path.join(os.path.dirname(__file__), 'test_server.crt')
@@ -14,43 +14,40 @@ private_key_file = os.path.join(os.path.dirname(__file__), 'test_server.key')
 class TestServe(LimitedTestCase):
     def setUp(self):
         super(TestServe, self).setUp()
-        from eventlet import debug
         debug.hub_exceptions(False)
 
     def tearDown(self):
         super(TestServe, self).tearDown()
-        from eventlet import debug
         debug.hub_exceptions(True)
 
     def test_exiting_server(self):
         # tests that the server closes the client sock on handle() exit
-        def closer(sock,addr):
+        def closer(sock, addr):
             pass
 
         l = eventlet.listen(('localhost', 0))
         gt = eventlet.spawn(eventlet.serve, l, closer)
         client = eventlet.connect(('localhost', l.getsockname()[1]))
-        client.sendall(s2b('a'))
+        client.sendall(b'a')
         self.assertFalse(client.recv(100))
         gt.kill()
 
-
     def test_excepting_server(self):
         # tests that the server closes the client sock on handle() exception
-        def crasher(sock,addr):
+        def crasher(sock, addr):
             sock.recv(1024)
             0//0
 
         l = eventlet.listen(('localhost', 0))
         gt = eventlet.spawn(eventlet.serve, l, crasher)
         client = eventlet.connect(('localhost', l.getsockname()[1]))
-        client.sendall(s2b('a'))
+        client.sendall(b'a')
         self.assertRaises(ZeroDivisionError, gt.wait)
         self.assertFalse(client.recv(100))
 
     def test_excepting_server_already_closed(self):
         # same as above but with explicit clsoe before crash
-        def crasher(sock,addr):
+        def crasher(sock, addr):
             sock.recv(1024)
             sock.close()
             0//0
@@ -58,14 +55,15 @@ class TestServe(LimitedTestCase):
         l = eventlet.listen(('localhost', 0))
         gt = eventlet.spawn(eventlet.serve, l, crasher)
         client = eventlet.connect(('localhost', l.getsockname()[1]))
-        client.sendall(s2b('a'))
+        client.sendall(b'a')
         self.assertRaises(ZeroDivisionError, gt.wait)
         self.assertFalse(client.recv(100))
 
     def test_called_for_each_connection(self):
         hits = [0]
+
         def counter(sock, addr):
-            hits[0]+=1
+            hits[0] += 1
         l = eventlet.listen(('localhost', 0))
         gt = eventlet.spawn(eventlet.serve, l, counter)
         for i in six.moves.range(100):
@@ -76,8 +74,9 @@ class TestServe(LimitedTestCase):
 
     def test_blocking(self):
         l = eventlet.listen(('localhost', 0))
-        x = eventlet.with_timeout(0.01,
-            eventlet.serve, l, lambda c,a: None,
+        x = eventlet.with_timeout(
+            0.01,
+            eventlet.serve, l, lambda c, a: None,
             timeout_value="timeout")
         self.assertEqual(x, "timeout")
 
@@ -86,50 +85,56 @@ class TestServe(LimitedTestCase):
             raise eventlet.StopServe()
         l = eventlet.listen(('localhost', 0))
         # connect to trigger a call to stopit
-        gt = eventlet.spawn(eventlet.connect,
-            ('localhost', l.getsockname()[1]))
+        gt = eventlet.spawn(eventlet.connect, ('localhost', l.getsockname()[1]))
         eventlet.serve(l, stopit)
         gt.wait()
 
     def test_concurrency(self):
         evt = event.Event()
+
         def waiter(sock, addr):
-            sock.sendall(s2b('hi'))
+            sock.sendall(b'hi')
             evt.wait()
         l = eventlet.listen(('localhost', 0))
-        gt = eventlet.spawn(eventlet.serve, l, waiter, 5)
+        eventlet.spawn(eventlet.serve, l, waiter, 5)
+
         def test_client():
             c = eventlet.connect(('localhost', l.getsockname()[1]))
             # verify the client is connected by getting data
-            self.assertEquals(s2b('hi'), c.recv(2))
+            self.assertEqual(b'hi', c.recv(2))
             return c
-        clients = [test_client() for i in range(5)]
+        [test_client() for i in range(5)]
         # very next client should not get anything
-        x = eventlet.with_timeout(0.01,
+        x = eventlet.with_timeout(
+            0.01,
             test_client,
             timeout_value="timed out")
-        self.assertEquals(x, "timed out")
+        self.assertEqual(x, "timed out")
 
     @skip_if_no_ssl
     def test_wrap_ssl(self):
-        server = eventlet.wrap_ssl(eventlet.listen(('localhost', 0)),
-                                    certfile=certificate_file,
-                                    keyfile=private_key_file, server_side=True)
+        server = eventlet.wrap_ssl(
+            eventlet.listen(('localhost', 0)),
+            certfile=certificate_file, keyfile=private_key_file,
+            server_side=True)
         port = server.getsockname()[1]
-        def handle(sock,addr):
+
+        def handle(sock, addr):
             sock.sendall(sock.recv(1024))
             raise eventlet.StopServe()
+
         eventlet.spawn(eventlet.serve, server, handle)
         client = eventlet.wrap_ssl(eventlet.connect(('localhost', port)))
         client.sendall("echo")
-        self.assertEquals("echo", client.recv(1024))
+        self.assertEqual("echo", client.recv(1024))
 
     def test_socket_reuse(self):
-        lsock1 = eventlet.listen(('localhost',0))
+        lsock1 = eventlet.listen(('localhost', 0))
         port = lsock1.getsockname()[1]
+
         def same_socket():
-            return eventlet.listen(('localhost',port))
-        self.assertRaises(socket.error,same_socket)
+            return eventlet.listen(('localhost', port))
+
+        self.assertRaises(socket.error, same_socket)
         lsock1.close()
         assert same_socket()
-
diff --git a/tests/db_pool_test.py b/tests/db_pool_test.py
index 160f53a..5c486ba 100644
--- a/tests/db_pool_test.py
+++ b/tests/db_pool_test.py
@@ -265,19 +265,19 @@ class DBConnectionPool(DBTester):
         conn = self.pool._unwrap_connection(self.connection)
         self.assert_(not isinstance(conn, db_pool.GenericConnectionWrapper))
 
-        self.assertEquals(None, self.pool._unwrap_connection(None))
-        self.assertEquals(None, self.pool._unwrap_connection(1))
+        self.assertEqual(None, self.pool._unwrap_connection(None))
+        self.assertEqual(None, self.pool._unwrap_connection(1))
 
         # testing duck typing here -- as long as the connection has a
         # _base attribute, it should be unwrappable
         x = Mock()
         x._base = 'hi'
-        self.assertEquals('hi', self.pool._unwrap_connection(x))
+        self.assertEqual('hi', self.pool._unwrap_connection(x))
         conn.close()
 
     def test_safe_close(self):
         self.pool._safe_close(self.connection, quiet=True)
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
 
         self.pool._safe_close(None)
         self.pool._safe_close(1)
@@ -301,7 +301,7 @@ class DBConnectionPool(DBTester):
         self.pool = self.create_pool(max_size=2, max_idle=0)
         self.connection = self.pool.get()
         self.connection.close()
-        self.assertEquals(len(self.pool.free_items), 0)
+        self.assertEqual(len(self.pool.free_items), 0)
 
     def test_zero_max_age(self):
         self.pool.put(self.connection)
@@ -309,7 +309,7 @@ class DBConnectionPool(DBTester):
         self.pool = self.create_pool(max_size=2, max_age=0)
         self.connection = self.pool.get()
         self.connection.close()
-        self.assertEquals(len(self.pool.free_items), 0)
+        self.assertEqual(len(self.pool.free_items), 0)
 
     @skipped
     def test_max_idle(self):
@@ -320,19 +320,19 @@ class DBConnectionPool(DBTester):
         self.pool = self.create_pool(max_size=2, max_idle=0.02)
         self.connection = self.pool.get()
         self.connection.close()
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         eventlet.sleep(0.01)  # not long enough to trigger the idle timeout
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         self.connection = self.pool.get()
         self.connection.close()
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         eventlet.sleep(0.01)  # idle timeout should have fired but done nothing
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         self.connection = self.pool.get()
         self.connection.close()
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         eventlet.sleep(0.03) # long enough to trigger idle timeout for real
-        self.assertEquals(len(self.pool.free_items), 0)
+        self.assertEqual(len(self.pool.free_items), 0)
 
     @skipped
     def test_max_idle_many(self):
@@ -344,11 +344,11 @@ class DBConnectionPool(DBTester):
         self.connection, conn2 = self.pool.get(), self.pool.get()
         self.connection.close()
         eventlet.sleep(0.01)
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         conn2.close()
-        self.assertEquals(len(self.pool.free_items), 2)
+        self.assertEqual(len(self.pool.free_items), 2)
         eventlet.sleep(0.02)  # trigger cleanup of conn1 but not conn2
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
 
     @skipped
     def test_max_age(self):
@@ -359,14 +359,14 @@ class DBConnectionPool(DBTester):
         self.pool = self.create_pool(max_size=2, max_age=0.05)
         self.connection = self.pool.get()
         self.connection.close()
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         eventlet.sleep(0.01)  # not long enough to trigger the age timeout
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         self.connection = self.pool.get()
         self.connection.close()
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         eventlet.sleep(0.05) # long enough to trigger age timeout
-        self.assertEquals(len(self.pool.free_items), 0)
+        self.assertEqual(len(self.pool.free_items), 0)
 
     @skipped
     def test_max_age_many(self):
@@ -377,13 +377,13 @@ class DBConnectionPool(DBTester):
         self.pool = self.create_pool(max_size=2, max_age=0.15)
         self.connection, conn2 = self.pool.get(), self.pool.get()
         self.connection.close()
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         eventlet.sleep(0)  # not long enough to trigger the age timeout
-        self.assertEquals(len(self.pool.free_items), 1)
+        self.assertEqual(len(self.pool.free_items), 1)
         eventlet.sleep(0.2) # long enough to trigger age timeout
-        self.assertEquals(len(self.pool.free_items), 0)
+        self.assertEqual(len(self.pool.free_items), 0)
         conn2.close()  # should not be added to the free items
-        self.assertEquals(len(self.pool.free_items), 0)
+        self.assertEqual(len(self.pool.free_items), 0)
 
     def test_waiters_get_woken(self):
         # verify that when there's someone waiting on an empty pool
@@ -394,8 +394,8 @@ class DBConnectionPool(DBTester):
         self.pool = self.create_pool(max_size=1, max_age=0)
 
         self.connection = self.pool.get()
-        self.assertEquals(self.pool.free(), 0)
-        self.assertEquals(self.pool.waiting(), 0)
+        self.assertEqual(self.pool.free(), 0)
+        self.assertEqual(self.pool.waiting(), 0)
         e = event.Event()
         def retrieve(pool, ev):
             c = pool.get()
@@ -403,14 +403,14 @@ class DBConnectionPool(DBTester):
         eventlet.spawn(retrieve, self.pool, e)
         eventlet.sleep(0) # these two sleeps should advance the retrieve
         eventlet.sleep(0) # coroutine until it's waiting in get()
-        self.assertEquals(self.pool.free(), 0)
-        self.assertEquals(self.pool.waiting(), 1)
+        self.assertEqual(self.pool.free(), 0)
+        self.assertEqual(self.pool.waiting(), 1)
         self.pool.put(self.connection)
         timer = eventlet.Timeout(1)
         conn = e.wait()
         timer.cancel()
-        self.assertEquals(self.pool.free(), 0)
-        self.assertEquals(self.pool.waiting(), 0)
+        self.assertEqual(self.pool.free(), 0)
+        self.assertEqual(self.pool.waiting(), 0)
         self.pool.put(conn)
 
     @skipped
@@ -440,7 +440,7 @@ class DBConnectionPool(DBTester):
         # not lose any connections
         self.pool = self.create_pool(max_size=1, module=RaisingDBModule())
         self.assertRaises(RuntimeError, self.pool.get)
-        self.assertEquals(self.pool.free(), 1)
+        self.assertEqual(self.pool.free(), 1)
 
 
 class DummyConnection(object):
diff --git a/tests/debug_test.py b/tests/debug_test.py
index e509c65..da6d7ab 100644
--- a/tests/debug_test.py
+++ b/tests/debug_test.py
@@ -3,7 +3,7 @@ from unittest import TestCase
 
 from eventlet import debug
 from eventlet.support import six
-from tests import LimitedTestCase, main, s2b
+from tests import LimitedTestCase, main
 import eventlet
 
 
@@ -113,7 +113,7 @@ class TestDebug(LimitedTestCase):
         try:
             gt = eventlet.spawn(hurl, client_2)
             eventlet.sleep(0)
-            client.send(s2b(' '))
+            client.send(b' ')
             eventlet.sleep(0)
             # allow the "hurl" greenlet to trigger the KeyError
             # not sure why the extra context switch is needed
@@ -124,7 +124,7 @@ class TestDebug(LimitedTestCase):
             debug.hub_exceptions(False)
         # look for the KeyError exception in the traceback
         self.assert_('KeyError: 1' in fake.getvalue(),
-            "Traceback not in:\n" + fake.getvalue())
+                     "Traceback not in:\n" + fake.getvalue())
 
 if __name__ == "__main__":
     main()
diff --git a/tests/greenio_test.py b/tests/greenio_test.py
index e167446..3432767 100644
--- a/tests/greenio_test.py
+++ b/tests/greenio_test.py
@@ -1,18 +1,26 @@
-import socket as _orig_sock
-from tests import LimitedTestCase, skip_with_pyevent, main, skipped, s2b, skip_if, skip_on_windows
-from eventlet import event, greenio, debug
-from eventlet.hubs import get_hub
-from eventlet.green import select, socket, time, ssl
-from eventlet.support import get_errno
-
 import array
 import errno
 import eventlet
-import gc
 import fcntl
+import gc
 import os
+import shutil
+import socket as _orig_sock
 import sys
-import tempfile, shutil
+import tempfile
+
+from eventlet import event, greenio, debug
+from eventlet.hubs import get_hub
+from eventlet.green import select, socket, time, ssl
+from eventlet.support import get_errno, six
+from tests import (
+    LimitedTestCase, main,
+    skip_with_pyevent, skipped, skip_if, skip_on_windows,
+)
+
+
+if six.PY3:
+    buffer = memoryview
 
 
 def bufsized(sock, size=1):
@@ -35,17 +43,17 @@ def min_buf_size():
 
 
 def using_epoll_hub(_f):
-        try:
-            return 'epolls' in type(get_hub()).__module__
-        except Exception:
-            return False
+    try:
+        return 'epolls' in type(get_hub()).__module__
+    except Exception:
+        return False
 
 
 def using_kqueue_hub(_f):
-        try:
-            return 'kqueue' in type(get_hub()).__module__
-        except Exception:
-            return False
+    try:
+        return 'kqueue' in type(get_hub()).__module__
+    except Exception:
+        return False
 
 
 class TestGreenSocket(LimitedTestCase):
@@ -95,7 +103,7 @@ class TestGreenSocket(LimitedTestCase):
         gs = greenio.GreenSocket(s)
         e = gs.connect_ex(('192.0.2.1', 80))
         if not e in (errno.EHOSTUNREACH, errno.ENETUNREACH):
-            self.assertEquals(e, errno.EAGAIN)
+            self.assertEqual(e, errno.EAGAIN)
 
     def test_recv_timeout(self):
         listener = greenio.GreenSocket(socket.socket())
@@ -142,7 +150,7 @@ class TestGreenSocket(LimitedTestCase):
             self.assertEqual(e.args[0], 'timed out')
 
     def test_recvfrom_into_timeout(self):
-        buf = buffer(array.array('B'))
+        buf = array.array('B')
 
         gs = greenio.GreenSocket(
             socket.socket(socket.AF_INET, socket.SOCK_DGRAM))
@@ -157,7 +165,7 @@ class TestGreenSocket(LimitedTestCase):
             self.assertEqual(e.args[0], 'timed out')
 
     def test_recv_into_timeout(self):
-        buf = buffer(array.array('B'))
+        buf = array.array('B')
 
         listener = greenio.GreenSocket(socket.socket())
         listener.bind(('', 0))
@@ -209,7 +217,7 @@ class TestGreenSocket(LimitedTestCase):
         client.connect(addr)
         try:
             client.settimeout(0.00001)
-            msg = s2b("A") * 100000  # large enough number to overwhelm most buffers
+            msg = b"A" * 100000  # large enough number to overwhelm most buffers
 
             total_sent = 0
             # want to exceed the size of the OS buffer so it'll block in a
@@ -245,7 +253,7 @@ class TestGreenSocket(LimitedTestCase):
         client.connect(addr)
 
         try:
-            msg = s2b("A") * (8 << 20)
+            msg = b"A" * (8 << 20)
 
             # want to exceed the size of the OS buffer so it'll block
             client.sendall(msg)
@@ -265,10 +273,10 @@ class TestGreenSocket(LimitedTestCase):
                 conn, addr = listener.accept()
                 fd = conn.makefile('w')
                 conn.close()
-                fd.write('hello\n')
+                fd.write(b'hello\n')
                 fd.close()
                 self.assertWriteToClosedFileRaises(fd)
-                self.assertRaises(socket.error, conn.send, s2b('b'))
+                self.assertRaises(socket.error, conn.send, b'b')
             finally:
                 listener.close()
 
@@ -278,12 +286,12 @@ class TestGreenSocket(LimitedTestCase):
             try:
                 conn, addr = listener.accept()
                 fd = conn.makefile('w')
-                fd.write('hello')
+                fd.write(b'hello')
                 fd.close()
-                conn.send(s2b('\n'))
+                conn.send(b'\n')
                 conn.close()
                 self.assertWriteToClosedFileRaises(fd)
-                self.assertRaises(socket.error, conn.send, s2b('b'))
+                self.assertRaises(socket.error, conn.send, b'b')
             finally:
                 listener.close()
 
@@ -292,8 +300,8 @@ class TestGreenSocket(LimitedTestCase):
             client.connect(('127.0.0.1', server.getsockname()[1]))
             fd = client.makefile()
             client.close()
-            assert fd.readline() == 'hello\n'
-            assert fd.read() == ''
+            assert fd.readline() == b'hello\n'
+            assert fd.read() == b''
             fd.close()
 
         server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -320,7 +328,7 @@ class TestGreenSocket(LimitedTestCase):
             try:
                 conn, addr = listener.accept()
                 conn = conn.makefile('w')
-                conn.write('hello\n')
+                conn.write(b'hello\n')
                 conn.close()
                 gc.collect()
                 self.assertWriteToClosedFileRaises(conn)
@@ -336,13 +344,13 @@ class TestGreenSocket(LimitedTestCase):
         client.connect(('127.0.0.1', server.getsockname()[1]))
         fd = client.makefile()
         client.close()
-        assert fd.read() == 'hello\n'
-        assert fd.read() == ''
+        assert fd.read() == b'hello\n'
+        assert fd.read() == b''
 
         killer.wait()
 
     def test_full_duplex(self):
-        large_data = s2b('*') * 10 * min_buf_size()
+        large_data = b'*' * 10 * min_buf_size()
         listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         listener.bind(('127.0.0.1', 0))
@@ -356,7 +364,7 @@ class TestGreenSocket(LimitedTestCase):
             result = sock.recv(len(large_data))
             while len(result) < len(large_data):
                 result += sock.recv(len(large_data))
-            self.assertEquals(result, large_data)
+            self.assertEqual(result, large_data)
 
         def server():
             (sock, addr) = listener.accept()
@@ -364,10 +372,10 @@ class TestGreenSocket(LimitedTestCase):
             send_large_coro = eventlet.spawn(send_large, sock)
             eventlet.sleep(0)
             result = sock.recv(10)
-            expected = s2b('hello world')
+            expected = b'hello world'
             while len(result) < len(expected):
                 result += sock.recv(10)
-            self.assertEquals(result, expected)
+            self.assertEqual(result, expected)
             send_large_coro.wait()
 
         server_evt = eventlet.spawn(server)
@@ -376,7 +384,7 @@ class TestGreenSocket(LimitedTestCase):
         bufsized(client)
         large_evt = eventlet.spawn(read_large, client)
         eventlet.sleep(0)
-        client.sendall(s2b('hello world'))
+        client.sendall(b'hello world')
         server_evt.wait()
         large_evt.wait()
         client.close()
@@ -393,8 +401,8 @@ class TestGreenSocket(LimitedTestCase):
             def sender(listener):
                 (sock, addr) = listener.accept()
                 sock = bufsized(sock, size=bufsize)
-                sock.sendall(s2b('x') * many_bytes)
-                sock.sendall(s2b('y') * second_bytes)
+                sock.sendall(b'x' * many_bytes)
+                sock.sendall(b'y' * second_bytes)
 
             listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
@@ -447,12 +455,13 @@ class TestGreenSocket(LimitedTestCase):
             eventlet.sleep(0.02)
             wrap_wfile.write('hi')
             s2.close()
-            evt.send('sent via event')
+            evt.send(b'sent via event')
 
         evt = event.Event()
         eventlet.spawn(sender, evt)
-        eventlet.sleep(0)  # lets the socket enter accept mode, which
-                      # is necessary for connect to succeed on windows
+        # lets the socket enter accept mode, which
+        # is necessary for connect to succeed on windows
+        eventlet.sleep(0)
         try:
             # try and get some data off of this pipe
             # but bail before any is sent
@@ -466,7 +475,7 @@ class TestGreenSocket(LimitedTestCase):
             pass
 
         result = evt.wait()
-        self.assertEquals(result, 'sent via event')
+        self.assertEqual(result, b'sent via event')
         server.close()
         client.close()
 
@@ -476,7 +485,7 @@ class TestGreenSocket(LimitedTestCase):
 
         def handle(sock, addr):
             sock.recv(1)
-            sock.sendall("a")
+            sock.sendall(b"a")
             raise eventlet.StopServe()
 
         listener = eventlet.listen(('127.0.0.1', 0))
@@ -489,7 +498,7 @@ class TestGreenSocket(LimitedTestCase):
         a = eventlet.spawn(reader, s)
         eventlet.sleep(0)
         self.assertRaises(RuntimeError, s.recv, 1)
-        s.sendall('b')
+        s.sendall(b'b')
         a.wait()
 
     @skip_with_pyevent
@@ -500,7 +509,7 @@ class TestGreenSocket(LimitedTestCase):
             sock = eventlet.connect(address)
             while True:
                 try:
-                    sock.sendall('hello world')
+                    sock.sendall(b'hello world')
                 except socket.error as e:
                     if get_errno(e) == errno.EPIPE:
                         return
@@ -628,8 +637,8 @@ class TestGreenPipe(LimitedTestCase):
         for i in range(5):
             line = rf.readline()
             eventlet.sleep(0.01)
-            self.assertEquals(line, one_line)
-        self.assertEquals(rf.readline(), '')
+            self.assertEqual(line, one_line)
+        self.assertEqual(rf.readline(), '')
 
     def test_pipe_read(self):
         # ensure that 'readline' works properly on GreenPipes when data is not
@@ -654,10 +663,10 @@ class TestGreenPipe(LimitedTestCase):
         eventlet.sleep(0)
 
         line = r.readline()
-        self.assertEquals(line, 'line\n')
+        self.assertEqual(line, 'line\n')
 
         line = r.readline()
-        self.assertEquals(line, 'line\r\n')
+        self.assertEqual(line, 'line\r\n')
 
         gt.wait()
 
@@ -678,26 +687,27 @@ class TestGreenPipe(LimitedTestCase):
         for i in range(65):
             buf = r.read(1024)
             expected = 1024 * chr(i)
-            self.assertEquals(buf, expected,
+            self.assertEqual(
+                buf, expected,
                 "expected=%r..%r, found=%r..%r iter=%d"
                 % (expected[:4], expected[-4:], buf[:4], buf[-4:], i))
         gt.wait()
 
     def test_seek_on_buffered_pipe(self):
         f = greenio.GreenPipe(self.tempdir + "/TestFile", 'w+', 1024)
-        self.assertEquals(f.tell(), 0)
+        self.assertEqual(f.tell(), 0)
         f.seek(0, 2)
-        self.assertEquals(f.tell(), 0)
+        self.assertEqual(f.tell(), 0)
         f.write('1234567890')
         f.seek(0, 2)
-        self.assertEquals(f.tell(), 10)
+        self.assertEqual(f.tell(), 10)
         f.seek(0)
         value = f.read(1)
         self.assertEqual(value, '1')
-        self.assertEquals(f.tell(), 1)
+        self.assertEqual(f.tell(), 1)
         value = f.read(1)
         self.assertEqual(value, '2')
-        self.assertEquals(f.tell(), 2)
+        self.assertEqual(f.tell(), 2)
         f.seek(0, 1)
         self.assertEqual(f.readline(), '34567890')
         f.seek(-5, 1)
@@ -711,7 +721,7 @@ class TestGreenPipe(LimitedTestCase):
         f = greenio.GreenPipe(self.tempdir + "/TestFile", 'w+', 1024)
         f.write('1234567890')
         f.truncate(9)
-        self.assertEquals(f.tell(), 9)
+        self.assertEqual(f.tell(), 9)
 
 
 class TestGreenIoLong(LimitedTestCase):
@@ -762,7 +772,7 @@ class TestGreenIoLong(LimitedTestCase):
             bufsized(client, size=sendsize)
         else:
             bufsized(client)
-        client.sendall(s2b('*') * sendsize)
+        client.sendall(b'*' * sendsize)
         client.close()
         server_coro.wait()
         listener.close()
@@ -831,7 +841,7 @@ class TestGreenIoStarvation(LimitedTestCase):
             bufsized(client, size=sendsize)
 
             for i in range(sendloops):
-                client.sendall(s2b('*') * sendsize)
+                client.sendall(b'*' * sendsize)
             client.close()
             os._exit(0)
 
@@ -864,12 +874,15 @@ class TestGreenIoStarvation(LimitedTestCase):
 
         # assert that the last task started before the first task ended
         # (our no-starvation condition)
-        assert starttimes[-1] < endtimes[0], "Not overlapping: starts %s ends %s" % (starttimes, endtimes)
+        assert starttimes[-1] < endtimes[0], \
+            "Not overlapping: starts %s ends %s" % (starttimes, endtimes)
 
         maxstartdiff = starttimes[-1] - starttimes[0]
 
-        assert maxstartdiff * 2 < runlengths[0], "Largest difference in starting times more than twice the shortest running time!"
-        assert runlengths[0] * 2 > runlengths[-1], "Longest runtime more than twice as long as shortest!"
+        assert maxstartdiff * 2 < runlengths[0], \
+            "Largest difference in starting times more than twice the shortest running time!"
+        assert runlengths[0] * 2 > runlengths[-1], \
+            "Longest runtime more than twice as long as shortest!"
 
 
 def test_set_nonblocking():
diff --git a/tests/greenpool_test.py b/tests/greenpool_test.py
index efdc5ed..90b2bfa 100644
--- a/tests/greenpool_test.py
+++ b/tests/greenpool_test.py
@@ -1,11 +1,9 @@
 import gc
-import itertools
 import os
 import random
 
 import eventlet
-from eventlet import debug
-from eventlet import hubs, greenpool, coros, event
+from eventlet import hubs, greenpool, event, pools
 from eventlet.support import greenlets as greenlet, six
 import tests
 
@@ -17,7 +15,7 @@ def passthru(a):
 
 def passthru2(a, b):
     eventlet.sleep(0.01)
-    return a,b
+    return a, b
 
 
 def raiser(exc):
@@ -31,24 +29,28 @@ class GreenPool(tests.LimitedTestCase):
         for i in range(10):
             waiters.append(p.spawn(passthru, i))
         results = [waiter.wait() for waiter in waiters]
-        self.assertEquals(results, list(range(10)))
+        self.assertEqual(results, list(range(10)))
 
     def test_spawn_n(self):
         p = greenpool.GreenPool(4)
         results_closure = []
+
         def do_something(a):
             eventlet.sleep(0.01)
             results_closure.append(a)
+
         for i in range(10):
             p.spawn(do_something, i)
         p.waitall()
-        self.assertEquals(results_closure, list(range(10)))
+        self.assertEqual(results_closure, list(range(10)))
 
     def test_waiting(self):
         pool = greenpool.GreenPool(1)
         done = event.Event()
+
         def consume():
             done.wait()
+
         def waiter(pool):
             gt = pool.spawn(consume)
             gt.wait()
@@ -74,9 +76,11 @@ class GreenPool(tests.LimitedTestCase):
     def test_multiple_coros(self):
         evt = event.Event()
         results = []
+
         def producer():
             results.append('prod')
             evt.send()
+
         def consumer():
             results.append('cons1')
             evt.wait()
@@ -86,25 +90,29 @@ class GreenPool(tests.LimitedTestCase):
         done = pool.spawn(consumer)
         pool.spawn_n(producer)
         done.wait()
-        self.assertEquals(['cons1', 'prod', 'cons2'], results)
+        self.assertEqual(['cons1', 'prod', 'cons2'], results)
 
     def test_timer_cancel(self):
         # this test verifies that local timers are not fired
         # outside of the context of the spawn
         timer_fired = []
+
         def fire_timer():
             timer_fired.append(True)
+
         def some_work():
             hubs.get_hub().schedule_call_local(0, fire_timer)
+
         pool = greenpool.GreenPool(2)
         worker = pool.spawn(some_work)
         worker.wait()
         eventlet.sleep(0)
         eventlet.sleep(0)
-        self.assertEquals(timer_fired, [])
+        self.assertEqual(timer_fired, [])
 
     def test_reentrant(self):
         pool = greenpool.GreenPool(1)
+
         def reenter():
             waiter = pool.spawn(lambda a: a, 'reenter')
             self.assertEqual('reenter', waiter.wait())
@@ -113,17 +121,20 @@ class GreenPool(tests.LimitedTestCase):
         outer_waiter.wait()
 
         evt = event.Event()
+
         def reenter_async():
             pool.spawn_n(lambda a: a, 'reenter')
             evt.send('done')
 
         pool.spawn_n(reenter_async)
-        self.assertEquals('done', evt.wait())
+        self.assertEqual('done', evt.wait())
 
     def assert_pool_has_free(self, pool, num_free):
-        self.assertEquals(pool.free(), num_free)
+        self.assertEqual(pool.free(), num_free)
+
         def wait_long_time(e):
             e.wait()
+
         timer = eventlet.Timeout(1)
         try:
             evt = event.Event()
@@ -150,12 +161,14 @@ class GreenPool(tests.LimitedTestCase):
     def test_resize(self):
         pool = greenpool.GreenPool(2)
         evt = event.Event()
+
         def wait_long_time(e):
             e.wait()
+
         pool.spawn(wait_long_time, evt)
         pool.spawn(wait_long_time, evt)
-        self.assertEquals(pool.free(), 0)
-        self.assertEquals(pool.running(), 2)
+        self.assertEqual(pool.free(), 0)
+        self.assertEqual(pool.running(), 2)
         self.assert_pool_has_free(pool, 0)
 
         # verify that the pool discards excess items put into it
@@ -167,28 +180,28 @@ class GreenPool(tests.LimitedTestCase):
         eventlet.sleep(0)
         eventlet.sleep(0)
 
-        self.assertEquals(pool.free(), 1)
-        self.assertEquals(pool.running(), 0)
+        self.assertEqual(pool.free(), 1)
+        self.assertEqual(pool.running(), 0)
         self.assert_pool_has_free(pool, 1)
 
         # resize larger and assert that there are more free items
         pool.resize(2)
-        self.assertEquals(pool.free(), 2)
-        self.assertEquals(pool.running(), 0)
+        self.assertEqual(pool.free(), 2)
+        self.assertEqual(pool.running(), 0)
         self.assert_pool_has_free(pool, 2)
 
     def test_pool_smash(self):
         # The premise is that a coroutine in a Pool tries to get a token out
         # of a token pool but times out before getting the token.  We verify
         # that neither pool is adversely affected by this situation.
-        from eventlet import pools
         pool = greenpool.GreenPool(1)
         tp = pools.TokenPool(max_size=1)
-        token = tp.get()  # empty out the pool
+        tp.get()  # empty out the pool
+
         def do_receive(tp):
             timer = eventlet.Timeout(0, RuntimeError())
             try:
-                t = tp.get()
+                tp.get()
                 self.fail("Shouldn't have recieved anything from the pool")
             except RuntimeError:
                 return 'timed out'
@@ -198,7 +211,7 @@ class GreenPool(tests.LimitedTestCase):
         # the spawn makes the token pool expect that coroutine, but then
         # immediately cuts bait
         e1 = pool.spawn(do_receive, tp)
-        self.assertEquals(e1.wait(), 'timed out')
+        self.assertEqual(e1.wait(), 'timed out')
 
         # the pool can get some random item back
         def send_wakeup(tp):
@@ -210,18 +223,20 @@ class GreenPool(tests.LimitedTestCase):
         def resume():
             return 'resumed'
         e2 = pool.spawn(resume)
-        self.assertEquals(e2.wait(), 'resumed')
+        self.assertEqual(e2.wait(), 'resumed')
 
         # we should be able to get out the thing we put in there, too
-        self.assertEquals(tp.get(), 'wakeup')
+        self.assertEqual(tp.get(), 'wakeup')
         gt.wait()
 
     def test_spawn_n_2(self):
         p = greenpool.GreenPool(2)
         self.assertEqual(p.free(), 2)
         r = []
+
         def foo(a):
             r.append(a)
+
         gt = p.spawn(foo, 1)
         self.assertEqual(p.free(), 1)
         gt.wait()
@@ -239,9 +254,9 @@ class GreenPool(tests.LimitedTestCase):
         self.assertEqual(r, [1])
 
         p.spawn_n(foo, 4)
-        self.assertEqual(set(r), set([1,2,3]))
+        self.assertEqual(set(r), set([1, 2, 3]))
         eventlet.sleep(0)
-        self.assertEqual(set(r), set([1,2,3,4]))
+        self.assertEqual(set(r), set([1, 2, 3, 4]))
 
     def test_exceptions(self):
         p = greenpool.GreenPool(2)
@@ -259,7 +274,7 @@ class GreenPool(tests.LimitedTestCase):
     def test_imap(self):
         p = greenpool.GreenPool(4)
         result_list = list(p.imap(passthru, range(10)))
-        self.assertEquals(result_list, list(range(10)))
+        self.assertEqual(result_list, list(range(10)))
 
     def test_empty_imap(self):
         p = greenpool.GreenPool(4)
@@ -269,38 +284,40 @@ class GreenPool(tests.LimitedTestCase):
     def test_imap_nonefunc(self):
         p = greenpool.GreenPool(4)
         result_list = list(p.imap(None, range(10)))
-        self.assertEquals(result_list, [(x,) for x in range(10)])
+        self.assertEqual(result_list, [(x,) for x in range(10)])
 
     def test_imap_multi_args(self):
         p = greenpool.GreenPool(4)
         result_list = list(p.imap(passthru2, range(10), range(10, 20)))
-        self.assertEquals(result_list, list(zip(range(10), range(10,20))))
+        self.assertEqual(result_list, list(zip(range(10), range(10, 20))))
 
     def test_imap_raises(self):
         # testing the case where the function raises an exception;
         # both that the caller sees that exception, and that the iterator
         # continues to be usable to get the rest of the items
         p = greenpool.GreenPool(4)
+
         def raiser(item):
             if item == 1 or item == 7:
                 raise RuntimeError("intentional error")
             else:
                 return item
+
         it = p.imap(raiser, range(10))
         results = []
         while True:
             try:
-                results.append(it.next())
+                results.append(six.next(it))
             except RuntimeError:
                 results.append('r')
             except StopIteration:
                 break
-        self.assertEquals(results, [0,'r',2,3,4,5,6,'r',8,9])
+        self.assertEqual(results, [0, 'r', 2, 3, 4, 5, 6, 'r', 8, 9])
 
     def test_starmap(self):
         p = greenpool.GreenPool(4)
         result_list = list(p.starmap(passthru, [(x,) for x in range(10)]))
-        self.assertEquals(result_list, list(range(10)))
+        self.assertEqual(result_list, list(range(10)))
 
     def test_waitall_on_nothing(self):
         p = greenpool.GreenPool()
@@ -318,7 +335,7 @@ class GreenPile(tests.LimitedTestCase):
         for i in range(10):
             p.spawn(passthru, i)
         result_list = list(p)
-        self.assertEquals(result_list, list(range(10)))
+        self.assertEqual(result_list, list(range(10)))
 
     def test_pile_spawn_times_out(self):
         p = greenpool.GreenPile(4)
@@ -329,28 +346,32 @@ class GreenPile(tests.LimitedTestCase):
         self.assertRaises(eventlet.Timeout, p.spawn, passthru, "time out")
         # verify that the spawn breakage didn't interrupt the sequence
         # and terminates properly
-        for i in range(4,10):
+        for i in range(4, 10):
             p.spawn(passthru, i)
-        self.assertEquals(list(p), list(range(10)))
+        self.assertEqual(list(p), list(range(10)))
 
     def test_constructing_from_pool(self):
         pool = greenpool.GreenPool(2)
         pile1 = greenpool.GreenPile(pool)
         pile2 = greenpool.GreenPile(pool)
+
         def bunch_of_work(pile, unique):
             for i in range(10):
                 pile.spawn(passthru, i + unique)
+
         eventlet.spawn(bunch_of_work, pile1, 0)
         eventlet.spawn(bunch_of_work, pile2, 100)
         eventlet.sleep(0)
-        self.assertEquals(list(pile2), list(range(100,110)))
-        self.assertEquals(list(pile1), list(range(10)))
+        self.assertEqual(list(pile2), list(range(100, 110)))
+        self.assertEqual(list(pile1), list(range(10)))
 
 
 class StressException(Exception):
     pass
 
 r = random.Random(0)
+
+
 def pressure(arg):
     while r.random() < 0.5:
         eventlet.sleep(r.random() * 0.001)
@@ -359,18 +380,22 @@ def pressure(arg):
     else:
         raise StressException(arg)
 
+
 def passthru(arg):
     while r.random() < 0.5:
         eventlet.sleep(r.random() * 0.001)
     return arg
 
+
 class Stress(tests.LimitedTestCase):
     # tests will take extra-long
-    TEST_TIMEOUT=60
+    TEST_TIMEOUT = 60
+
     @tests.skip_unless(os.environ.get('RUN_STRESS_TESTS') == 'YES')
     def spawn_order_check(self, concurrency):
         # checks that piles are strictly ordered
         p = greenpool.GreenPile(concurrency)
+
         def makework(count, unique):
             for i in six.moves.range(count):
                 token = (unique, i)
@@ -380,13 +405,13 @@ class Stress(tests.LimitedTestCase):
         eventlet.spawn(makework, iters, 1)
         eventlet.spawn(makework, iters, 2)
         eventlet.spawn(makework, iters, 3)
-        p.spawn(pressure, (0,0))
+        p.spawn(pressure, (0, 0))
         latest = [-1] * 4
         received = 0
         it = iter(p)
         while True:
             try:
-                i = it.next()
+                i = six.next(it)
             except StressException as exc:
                 i = exc.args[0]
             except StopIteration:
@@ -398,7 +423,7 @@ class Stress(tests.LimitedTestCase):
             self.assert_(latest[unique] < order)
             latest[unique] = order
         for l in latest[1:]:
-            self.assertEquals(l, iters - 1)
+            self.assertEqual(l, iters - 1)
 
     @tests.skip_unless(os.environ.get('RUN_STRESS_TESTS') == 'YES')
     def test_ordering_5(self):
@@ -417,7 +442,7 @@ class Stress(tests.LimitedTestCase):
         latest = -1
         while True:
             try:
-                i = it.next()
+                i = six.next(it)
             except StopIteration:
                 break
 
@@ -433,7 +458,7 @@ class Stress(tests.LimitedTestCase):
                 objs_created = len(gc.get_objects()) - initial_obj_count
                 self.assert_(objs_created < 25 * concurrency, objs_created)
         # make sure we got to the end
-        self.assertEquals(latest, count - 1)
+        self.assertEqual(latest, count - 1)
 
     @tests.skip_unless(os.environ.get('RUN_STRESS_TESTS') == 'YES')
     def test_imap_50(self):
@@ -445,7 +470,6 @@ class Stress(tests.LimitedTestCase):
 
     @tests.skip_unless(os.environ.get('RUN_STRESS_TESTS') == 'YES')
     def test_with_intpool(self):
-        from eventlet import pools
         class IntPool(pools.Pool):
             def create(self):
                 self.current_integer = getattr(self, 'current_integer', 0) + 1
diff --git a/tests/greenthread_test.py b/tests/greenthread_test.py
index 3433373..9f0be11 100644
--- a/tests/greenthread_test.py
+++ b/tests/greenthread_test.py
@@ -27,22 +27,22 @@ class Spawn(LimitedTestCase, Asserts):
         
     def test_simple(self):
         gt = greenthread.spawn(passthru, 1, b=2)
-        self.assertEquals(gt.wait(), ((1,),{'b':2}))
-        self.assertEquals(_g_results, [((1,),{'b':2})])
+        self.assertEqual(gt.wait(), ((1,),{'b':2}))
+        self.assertEqual(_g_results, [((1,),{'b':2})])
         
     def test_n(self):
         gt = greenthread.spawn_n(passthru, 2, b=3)
         self.assert_(not gt.dead)
         greenthread.sleep(0)
         self.assert_(gt.dead)
-        self.assertEquals(_g_results, [((2,),{'b':3})])
+        self.assertEqual(_g_results, [((2,),{'b':3})])
         
     def test_kill(self):
         gt = greenthread.spawn(passthru, 6)
         greenthread.kill(gt)
         self.assert_dead(gt)
         greenthread.sleep(0.001)
-        self.assertEquals(_g_results, [])
+        self.assertEqual(_g_results, [])
         greenthread.kill(gt)
         self.assert_dead(gt)
         
@@ -51,7 +51,7 @@ class Spawn(LimitedTestCase, Asserts):
         gt.kill()
         self.assert_dead(gt)
         greenthread.sleep(0.001)
-        self.assertEquals(_g_results, [])
+        self.assertEqual(_g_results, [])
         gt.kill()
         self.assert_dead(gt)
         
@@ -60,7 +60,7 @@ class Spawn(LimitedTestCase, Asserts):
         greenthread.kill(gt)
         self.assert_dead(gt)
         greenthread.sleep(0.001)
-        self.assertEquals(_g_results, [])
+        self.assertEqual(_g_results, [])
         greenthread.kill(gt)
         self.assert_dead(gt)
     
@@ -72,8 +72,8 @@ class Spawn(LimitedTestCase, Asserts):
             results.append(kw)
         gt = greenthread.spawn(passthru, 5)
         gt.link(link_func, 4, b=5)
-        self.assertEquals(gt.wait(), ((5,), {}))
-        self.assertEquals(results, [gt, (4,), {'b':5}])
+        self.assertEqual(gt.wait(), ((5,), {}))
+        self.assertEqual(results, [gt, (4,), {'b':5}])
         
     def test_link_after_exited(self):
         results = []
@@ -82,9 +82,9 @@ class Spawn(LimitedTestCase, Asserts):
             results.append(a)
             results.append(kw)
         gt = greenthread.spawn(passthru, 5)
-        self.assertEquals(gt.wait(), ((5,), {}))
+        self.assertEqual(gt.wait(), ((5,), {}))
         gt.link(link_func, 4, b=5)
-        self.assertEquals(results, [gt, (4,), {'b':5}])
+        self.assertEqual(results, [gt, (4,), {'b':5}])
 
     def test_link_relinks(self):
         # test that linking in a linked func doesn't cause infinite recursion.
@@ -99,12 +99,12 @@ class Spawn(LimitedTestCase, Asserts):
         gt = greenthread.spawn(passthru)
         gt.link(link_func)
         gt.wait()
-        self.assertEquals(called, [True])
+        self.assertEqual(called, [True])
 
 class SpawnAfter(Spawn):
     def test_basic(self):
         gt = greenthread.spawn_after(0.1, passthru, 20)
-        self.assertEquals(gt.wait(), ((20,), {}))
+        self.assertEqual(gt.wait(), ((20,), {}))
         
     def test_cancel(self):
         gt = greenthread.spawn_after(0.1, passthru, 21)
@@ -115,7 +115,7 @@ class SpawnAfter(Spawn):
         gt = greenthread.spawn_after(0, waiter, 22)
         greenthread.sleep(0)
         gt.cancel()
-        self.assertEquals(gt.wait(), 22)
+        self.assertEqual(gt.wait(), 22)
         
     def test_kill_already_started(self):
         gt = greenthread.spawn_after(0, waiter, 22)
diff --git a/tests/hub_test.py b/tests/hub_test.py
index a3aae7f..b7f307d 100644
--- a/tests/hub_test.py
+++ b/tests/hub_test.py
@@ -1,12 +1,12 @@
 from __future__ import with_statement
 import sys
 
+import tests
 from tests import LimitedTestCase, main, skip_with_pyevent, skip_if_no_itimer, skip_unless
 from tests.patcher_test import ProcessBase
 import time
 import eventlet
 from eventlet import hubs
-from eventlet.green import socket
 from eventlet.event import Event
 from eventlet.semaphore import Semaphore
 from eventlet.support import greenlets, six
@@ -108,7 +108,7 @@ class TestScheduleCall(LimitedTestCase):
         hubs.get_hub().schedule_call_global(DELAY, lst.append, 2)
         while len(lst) < 3:
             eventlet.sleep(DELAY)
-        self.assertEquals(lst, [1, 2, 3])
+        self.assertEqual(lst, [1, 2, 3])
 
 
 class TestDebug(LimitedTestCase):
@@ -250,6 +250,8 @@ class TestHubBlockingDetector(LimitedTestCase):
 
 class TestSuspend(LimitedTestCase):
     TEST_TIMEOUT = 3
+    longMessage = True
+    maxDiff = None
 
     def test_suspend_doesnt_crash(self):
         import os
@@ -279,8 +281,8 @@ except eventlet.Timeout:
         os.kill(p.pid, signal.SIGSTOP)  # suspend and resume to generate EINTR
         os.kill(p.pid, signal.SIGCONT)
         output, _ = p.communicate()
-        lines = [l for l in output.split("\n") if l]
-        self.assert_("exited correctly" in lines[-1])
+        lines = output.decode('utf-8', 'replace').splitlines()
+        self.assert_("exited correctly" in lines[-1], output)
         shutil.rmtree(self.tempdir)
 
 
@@ -293,39 +295,13 @@ class TestBadFilenos(LimitedTestCase):
         self.assertRaises(ValueError, select.select, [-1], [], [])
 
 
-class TestFork(ProcessBase):
+class TestFork(LimitedTestCase):
 
     @skip_with_pyevent
     def test_fork(self):
-        new_mod = """
-import os
-import eventlet
-server = eventlet.listen(('localhost', 12345))
-t = eventlet.Timeout(0.01)
-try:
-    new_sock, address = server.accept()
-except eventlet.Timeout as t:
-    pass
-
-pid = os.fork()
-if not pid:
-    t = eventlet.Timeout(0.1)
-    try:
-        new_sock, address = server.accept()
-    except eventlet.Timeout as t:
-        print("accept blocked")
-
-else:
-    kpid, status = os.wait()
-    assert kpid == pid
-    assert status == 0
-    print("child died ok")
-"""
-        self.write_to_tempfile("newmod", new_mod)
-        output, lines = self.launch_subprocess('newmod.py')
-        self.assertEqual(len(lines), 3, output)
-        self.assert_("accept blocked" in lines[0])
-        self.assert_("child died ok" in lines[1])
+        output = tests.run_python('tests/hub_test_fork.py')
+        lines = output.splitlines()
+        self.assertEqual(lines, ["accept blocked", "child died ok"], output)
 
 
 class TestDeadRunLoop(LimitedTestCase):
diff --git a/tests/hub_test_fork.py b/tests/hub_test_fork.py
new file mode 100644
index 0000000..f886a96
--- /dev/null
+++ b/tests/hub_test_fork.py
@@ -0,0 +1,25 @@
+# no standard tests in this file, ignore
+__test__ = False
+
+if __name__ == '__main__':
+    import os
+    import eventlet
+    server = eventlet.listen(('localhost', 12345))
+    t = eventlet.Timeout(0.01)
+    try:
+        new_sock, address = server.accept()
+    except eventlet.Timeout as t:
+        pass
+
+    pid = os.fork()
+    if not pid:
+        t = eventlet.Timeout(0.1)
+        try:
+            new_sock, address = server.accept()
+        except eventlet.Timeout as t:
+            print("accept blocked")
+    else:
+        kpid, status = os.wait()
+        assert kpid == pid
+        assert status == 0
+        print("child died ok")
diff --git a/tests/mysqldb_test.py b/tests/mysqldb_test.py
index cfc9940..c4a77b0 100644
--- a/tests/mysqldb_test.py
+++ b/tests/mysqldb_test.py
@@ -122,14 +122,18 @@ class TestMySQLdb(LimitedTestCase):
         gt = eventlet.spawn(tick)
         curs.execute("select 1")
         rows = curs.fetchall()
-        self.assertEqual(rows, ((1L,),))
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(len(rows[0]), 1)
+        self.assertEqual(rows[0][0], 1)
         self.assert_(counter[0] > 0, counter[0])
         gt.kill()
 
     def assert_cursor_works(self, cursor):
         cursor.execute("select 1")
         rows = cursor.fetchall()
-        self.assertEqual(rows, ((1L,),))
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(len(rows[0]), 1)
+        self.assertEqual(rows[0][0], 1)
         self.assert_cursor_yields(cursor)
 
     def assert_connection_works(self, conn):
diff --git a/tests/pools_test.py b/tests/pools_test.py
index f53d018..7ace0dc 100644
--- a/tests/pools_test.py
+++ b/tests/pools_test.py
@@ -28,17 +28,17 @@ class TestIntPool(TestCase):
 
         # with self.pool.some_api_name() as thing:
         #     # do stuff
-        self.assertEquals(self.pool.get(), 1)
-        self.assertEquals(self.pool.get(), 2)
-        self.assertEquals(self.pool.get(), 3)
-        self.assertEquals(self.pool.get(), 4)
+        self.assertEqual(self.pool.get(), 1)
+        self.assertEqual(self.pool.get(), 2)
+        self.assertEqual(self.pool.get(), 3)
+        self.assertEqual(self.pool.get(), 4)
 
     def test_free(self):
-        self.assertEquals(self.pool.free(), 4)
+        self.assertEqual(self.pool.free(), 4)
         gotten = self.pool.get()
-        self.assertEquals(self.pool.free(), 3)
+        self.assertEqual(self.pool.free(), 3)
         self.pool.put(gotten)
-        self.assertEquals(self.pool.free(), 4)
+        self.assertEqual(self.pool.free(), 4)
 
     def test_exhaustion(self):
         waiter = Queue(0)
@@ -53,7 +53,7 @@ class TestIntPool(TestCase):
 
         one, two, three, four = (
             self.pool.get(), self.pool.get(), self.pool.get(), self.pool.get())
-        self.assertEquals(self.pool.free(), 0)
+        self.assertEqual(self.pool.free(), 0)
 
         # Let consumer run; nothing will be in the pool, so he will wait
         eventlet.sleep(0)
@@ -62,7 +62,7 @@ class TestIntPool(TestCase):
         self.pool.put(one)
 
         # wait for the consumer
-        self.assertEquals(waiter.get(), one)
+        self.assertEqual(waiter.get(), one)
 
     def test_blocks_on_pool(self):
         waiter = Queue(0)
@@ -72,7 +72,7 @@ class TestIntPool(TestCase):
             self.pool.get()
             self.pool.get()
             # No one should be waiting yet.
-            self.assertEquals(self.pool.waiting(), 0)
+            self.assertEqual(self.pool.waiting(), 0)
             # The call to the next get will unschedule this routine.
             self.pool.get()
             # So this put should never be called.
@@ -81,13 +81,13 @@ class TestIntPool(TestCase):
         killable = eventlet.spawn(greedy)
 
         # no one should be waiting yet.
-        self.assertEquals(self.pool.waiting(), 0)
+        self.assertEqual(self.pool.waiting(), 0)
 
         ## Wait for greedy
         eventlet.sleep(0)
 
         ## Greedy should be blocking on the last get
-        self.assertEquals(self.pool.waiting(), 1)
+        self.assertEqual(self.pool.waiting(), 1)
 
         ## Send will never be called, so balance should be 0.
         self.assertFalse(not waiter.full())
@@ -100,8 +100,8 @@ class TestIntPool(TestCase):
         one, two = self.pool.get(), self.pool.get()
         self.pool.put(one)
         self.pool.put(two)
-        self.assertEquals(self.pool.get(), one)
-        self.assertEquals(self.pool.get(), two)
+        self.assertEqual(self.pool.get(), one)
+        self.assertEqual(self.pool.get(), two)
 
     def test_putting_to_queue(self):
         timer = eventlet.Timeout(0.1)
@@ -128,17 +128,17 @@ class TestIntPool(TestCase):
         pool = IntPool(max_size=2)
         a = pool.get()
         b = pool.get()
-        self.assertEquals(pool.free(), 0)
+        self.assertEqual(pool.free(), 0)
 
         # verify that the pool discards excess items put into it
         pool.resize(1)
         pool.put(a)
         pool.put(b)
-        self.assertEquals(pool.free(), 1)
+        self.assertEqual(pool.free(), 1)
 
         # resize larger and assert that there are more free items
         pool.resize(2)
-        self.assertEquals(pool.free(), 2)
+        self.assertEqual(pool.free(), 2)
 
     def test_create_contention(self):
         creates = [0]
@@ -151,14 +151,14 @@ class TestIntPool(TestCase):
 
         def do_get():
             x = p.get()
-            self.assertEquals(x, "slept")
+            self.assertEqual(x, "slept")
             p.put(x)
 
         gp = eventlet.GreenPool()
         for i in six.moves.range(100):
             gp.spawn_n(do_get)
         gp.waitall()
-        self.assertEquals(creates[0], 4)
+        self.assertEqual(creates[0], 4)
 
 
 class TestAbstract(TestCase):
@@ -176,11 +176,11 @@ class TestIntPool2(TestCase):
         self.pool = IntPool(min_size=3, max_size=3)
 
     def test_something(self):
-        self.assertEquals(len(self.pool.free_items), 3)
+        self.assertEqual(len(self.pool.free_items), 3)
         ## Cover the clause in get where we get from the free list instead of creating
         ## an item on get
         gotten = self.pool.get()
-        self.assertEquals(gotten, 1)
+        self.assertEqual(gotten, 1)
 
 
 class TestOrderAsStack(TestCase):
@@ -193,8 +193,8 @@ class TestOrderAsStack(TestCase):
         one, two = self.pool.get(), self.pool.get()
         self.pool.put(one)
         self.pool.put(two)
-        self.assertEquals(self.pool.get(), two)
-        self.assertEquals(self.pool.get(), one)
+        self.assertEqual(self.pool.get(), two)
+        self.assertEqual(self.pool.get(), one)
 
 
 class RaisePool(pools.Pool):
@@ -208,9 +208,9 @@ class TestCreateRaises(TestCase):
         self.pool = RaisePool(max_size=3)
 
     def test_it(self):
-        self.assertEquals(self.pool.free(), 3)
+        self.assertEqual(self.pool.free(), 3)
         self.assertRaises(RuntimeError, self.pool.get)
-        self.assertEquals(self.pool.free(), 3)
+        self.assertEqual(self.pool.free(), 3)
 
 
 ALWAYS = RuntimeError('I always fail')
diff --git a/tests/processes_test.py b/tests/processes_test.py
index 0169739..a5eef89 100644
--- a/tests/processes_test.py
+++ b/tests/processes_test.py
@@ -20,7 +20,7 @@ class TestEchoPool(LimitedTestCase):
             result = proc.read()
         finally:
             self.pool.put(proc)
-        self.assertEquals(result, 'hello\n')
+        self.assertEqual(result, 'hello\n')
 
     @skip_on_windows
     def test_read_eof(self):
@@ -34,7 +34,7 @@ class TestEchoPool(LimitedTestCase):
     @skip_on_windows    
     def test_empty_echo(self):
         p = processes.Process('echo', ['-n'])
-        self.assertEquals('', p.read())
+        self.assertEqual('', p.read())
         self.assertRaises(processes.DeadProcess, p.read)
             
 
@@ -56,7 +56,7 @@ class TestCatPool(LimitedTestCase):
         finally:
             self.pool.put(proc)
 
-        self.assertEquals(result, 'goodbye')
+        self.assertEqual(result, 'goodbye')
 
     @skip_on_windows
     def test_write_to_dead(self):
@@ -95,7 +95,7 @@ class TestDyingProcessesLeavePool(LimitedTestCase):
         try:
             try:
                 result = proc.read()
-                self.assertEquals(result, 'hello\n')
+                self.assertEqual(result, 'hello\n')
                 result = proc.read()
             except processes.DeadProcess:
                 pass
diff --git a/tests/queue_test.py b/tests/queue_test.py
index dea7192..60527a2 100644
--- a/tests/queue_test.py
+++ b/tests/queue_test.py
@@ -14,12 +14,12 @@ class TestQueue(LimitedTestCase):
     def test_send_first(self):
         q = eventlet.Queue()
         q.put('hi')
-        self.assertEquals(q.get(), 'hi')
+        self.assertEqual(q.get(), 'hi')
 
     def test_send_last(self):
         q = eventlet.Queue()
         def waiter(q):
-            self.assertEquals(q.get(), 'hi2')
+            self.assertEqual(q.get(), 'hi2')
 
         gt = eventlet.spawn(eventlet.with_timeout, 0.1, waiter, q)
         eventlet.sleep(0)
@@ -41,12 +41,12 @@ class TestQueue(LimitedTestCase):
 
         gt = eventlet.spawn(putter, q)
         eventlet.sleep(0)
-        self.assertEquals(results, ['a', 'b'])
-        self.assertEquals(q.get(), 'a')
+        self.assertEqual(results, ['a', 'b'])
+        self.assertEqual(q.get(), 'a')
         eventlet.sleep(0)
-        self.assertEquals(results, ['a', 'b', 'c'])
-        self.assertEquals(q.get(), 'b')
-        self.assertEquals(q.get(), 'c')
+        self.assertEqual(results, ['a', 'b', 'c'])
+        self.assertEqual(q.get(), 'b')
+        self.assertEqual(q.get(), 'c')
         gt.wait()
 
     def test_zero_max_size(self):
@@ -64,8 +64,8 @@ class TestQueue(LimitedTestCase):
         eventlet.sleep(0)
         self.assert_(not evt.ready())
         gt2 = eventlet.spawn(receiver, q)
-        self.assertEquals(gt2.wait(),'hi')
-        self.assertEquals(evt.wait(),'done')
+        self.assertEqual(gt2.wait(),'hi')
+        self.assertEqual(evt.wait(),'done')
         gt.wait()
 
     def test_resize_up(self):
@@ -90,10 +90,10 @@ class TestQueue(LimitedTestCase):
         for i in range(5):
             q.put(i)
 
-        self.assertEquals(list(q.queue), list(range(5)))
+        self.assertEqual(list(q.queue), list(range(5)))
         q.resize(1)
         eventlet.sleep(0)
-        self.assertEquals(list(q.queue), list(range(5)))
+        self.assertEqual(list(q.queue), list(range(5)))
 
     def test_resize_to_Unlimited(self):
         q = eventlet.Queue(0)
@@ -127,21 +127,21 @@ class TestQueue(LimitedTestCase):
         results = set()
         for i, gt in enumerate(gts):
             results.add(gt.wait())
-        self.assertEquals(results, set(sendings))
+        self.assertEqual(results, set(sendings))
 
     def test_waiters_that_cancel(self):
         q = eventlet.Queue()
 
         gt = eventlet.spawn(do_bail, q)
-        self.assertEquals(gt.wait(), 'timed out')
+        self.assertEqual(gt.wait(), 'timed out')
 
         q.put('hi')
-        self.assertEquals(q.get(), 'hi')
+        self.assertEqual(q.get(), 'hi')
 
     def test_getting_before_sending(self):
         q = eventlet.Queue()
         gt = eventlet.spawn(q.put, 'sent')
-        self.assertEquals(q.get(), 'sent')
+        self.assertEqual(q.get(), 'sent')
         gt.wait()
 
     def test_two_waiters_one_dies(self):
@@ -153,8 +153,8 @@ class TestQueue(LimitedTestCase):
         waiting = eventlet.spawn(waiter, q)
         eventlet.sleep(0)
         q.put('hi')
-        self.assertEquals(dying.wait(), 'timed out')
-        self.assertEquals(waiting.wait(), 'hi')
+        self.assertEqual(dying.wait(), 'timed out')
+        self.assertEqual(waiting.wait(), 'hi')
 
     def test_two_bogus_waiters(self):
         q = eventlet.Queue()
@@ -162,20 +162,20 @@ class TestQueue(LimitedTestCase):
         gt2 = eventlet.spawn(do_bail, q)
         eventlet.sleep(0)
         q.put('sent')
-        self.assertEquals(gt1.wait(), 'timed out')
-        self.assertEquals(gt2.wait(), 'timed out')
-        self.assertEquals(q.get(), 'sent')
+        self.assertEqual(gt1.wait(), 'timed out')
+        self.assertEqual(gt2.wait(), 'timed out')
+        self.assertEqual(q.get(), 'sent')
                 
     def test_waiting(self):
         q = eventlet.Queue()
         gt1 = eventlet.spawn(q.get)
         eventlet.sleep(0)
-        self.assertEquals(1, q.getting())
+        self.assertEqual(1, q.getting())
         q.put('hi')
         eventlet.sleep(0)
-        self.assertEquals(0, q.getting())
-        self.assertEquals('hi', gt1.wait())
-        self.assertEquals(0, q.getting())
+        self.assertEqual(0, q.getting())
+        self.assertEqual('hi', gt1.wait())
+        self.assertEqual(0, q.getting())
 
     def test_channel_send(self):
         channel = eventlet.Queue(0)
@@ -222,7 +222,7 @@ class TestQueue(LimitedTestCase):
         w2 = eventlet.spawn(c.get)
         w3 = eventlet.spawn(c.get)
         eventlet.sleep(0)
-        self.assertEquals(c.getting(), 3)
+        self.assertEqual(c.getting(), 3)
         s1 = eventlet.spawn(c.put, 1)
         s2 = eventlet.spawn(c.put, 2)
         s3 = eventlet.spawn(c.put, 3)
@@ -230,10 +230,10 @@ class TestQueue(LimitedTestCase):
         s1.wait()
         s2.wait()
         s3.wait()
-        self.assertEquals(c.getting(), 0)
+        self.assertEqual(c.getting(), 0)
         # NOTE: we don't guarantee that waiters are served in order
         results = sorted([w1.wait(), w2.wait(), w3.wait()])
-        self.assertEquals(results, [1,2,3])
+        self.assertEqual(results, [1,2,3])
         
     def test_channel_sender_timing_out(self):
         from eventlet import queue
diff --git a/tests/ssl_test.py b/tests/ssl_test.py
index a50ed17..73b9b43 100644
--- a/tests/ssl_test.py
+++ b/tests/ssl_test.py
@@ -46,7 +46,7 @@ class SSLTest(LimitedTestCase):
 
         client = util.wrap_ssl(eventlet.connect(('127.0.0.1', sock.getsockname()[1])))
         client.write(b'line 1\r\nline 2\r\n\r\n')
-        self.assertEquals(client.read(8192), b'response')
+        self.assertEqual(client.read(8192), b'response')
         server_coro.wait()
 
     @skip_if_no_ssl
@@ -55,7 +55,7 @@ class SSLTest(LimitedTestCase):
             sock, addr = listener.accept()
             sock.read(8192)
             try:
-                self.assertEquals(b"", sock.read(8192))
+                self.assertEqual(b"", sock.read(8192))
             except greenio.SSL.ZeroReturnError:
                 pass
 
@@ -90,13 +90,13 @@ class SSLTest(LimitedTestCase):
     def test_ssl_unwrap(self):
         def serve():
             sock, addr = listener.accept()
-            self.assertEquals(sock.recv(6), b'before')
+            self.assertEqual(sock.recv(6), b'before')
             sock_ssl = util.wrap_ssl(sock, certificate_file, private_key_file,
                                      server_side=True)
             sock_ssl.do_handshake()
-            self.assertEquals(sock_ssl.read(6), b'during')
+            self.assertEqual(sock_ssl.read(6), b'during')
             sock2 = sock_ssl.unwrap()
-            self.assertEquals(sock2.recv(5), b'after')
+            self.assertEqual(sock2.recv(5), b'after')
             sock2.close()
 
         listener = eventlet.listen(('127.0.0.1', 0))
@@ -160,8 +160,8 @@ class SSLTest(LimitedTestCase):
         listener = listen_ssl_socket(('', 0))
         eventlet.spawn(serve, listener)
         client = ssl(eventlet.connect(('localhost', listener.getsockname()[1])))
-        self.assertEquals(client.read(1024), b'content')
-        self.assertEquals(client.read(1024), b'')
+        self.assertEqual(client.read(1024), b'content')
+        self.assertEqual(client.read(1024), b'')
 
     @skip_if_no_ssl
     def test_regression_gh_17(self):
diff --git a/tests/test__coros_queue.py b/tests/test__coros_queue.py
index 3ebf441..9cb8663 100644
--- a/tests/test__coros_queue.py
+++ b/tests/test__coros_queue.py
@@ -11,7 +11,7 @@ class TestQueue(LimitedTestCase):
     def test_send_first(self):
         q = coros.queue()
         q.send('hi')
-        self.assertEquals(q.wait(), 'hi')
+        self.assertEqual(q.wait(), 'hi')
 
     @silence_warnings
     def test_send_exception_first(self):
@@ -24,7 +24,7 @@ class TestQueue(LimitedTestCase):
         q = coros.queue()
         def waiter(q):
             timer = eventlet.Timeout(0.1)
-            self.assertEquals(q.wait(), 'hi2')
+            self.assertEqual(q.wait(), 'hi2')
             timer.cancel()
 
         spawn(waiter, q)
@@ -47,12 +47,12 @@ class TestQueue(LimitedTestCase):
 
         spawn(putter, q)
         sleep(0)
-        self.assertEquals(results, ['a', 'b'])
-        self.assertEquals(q.wait(), 'a')
+        self.assertEqual(results, ['a', 'b'])
+        self.assertEqual(q.wait(), 'a')
         sleep(0)
-        self.assertEquals(results, ['a', 'b', 'c'])
-        self.assertEquals(q.wait(), 'b')
-        self.assertEquals(q.wait(), 'c')
+        self.assertEqual(results, ['a', 'b', 'c'])
+        self.assertEqual(q.wait(), 'b')
+        self.assertEqual(q.wait(), 'c')
 
     @silence_warnings
     def test_zero_max_size(self):
@@ -72,8 +72,8 @@ class TestQueue(LimitedTestCase):
         sleep(0)
         self.assert_(not e1.ready())
         spawn(receiver, e2, q)
-        self.assertEquals(e2.wait(),'hi')
-        self.assertEquals(e1.wait(),'done')
+        self.assertEqual(e2.wait(),'hi')
+        self.assertEqual(e1.wait(),'done')
 
     @silence_warnings
     def test_multiple_waiters(self):
@@ -93,7 +93,7 @@ class TestQueue(LimitedTestCase):
         results = set()
         for i, gt in enumerate(gts):
             results.add(gt.wait())
-        self.assertEquals(results, set(sendings))
+        self.assertEqual(results, set(sendings))
 
     @silence_warnings
     def test_waiters_that_cancel(self):
@@ -110,10 +110,10 @@ class TestQueue(LimitedTestCase):
 
         evt = Event()
         spawn(do_receive, q, evt)
-        self.assertEquals(evt.wait(), 'timed out')
+        self.assertEqual(evt.wait(), 'timed out')
 
         q.send('hi')
-        self.assertEquals(q.wait(), 'hi')
+        self.assertEqual(q.wait(), 'hi')
 
     @silence_warnings
     def test_senders_that_die(self):
@@ -123,7 +123,7 @@ class TestQueue(LimitedTestCase):
             q.send('sent')
 
         spawn(do_send, q)
-        self.assertEquals(q.wait(), 'sent')
+        self.assertEqual(q.wait(), 'sent')
 
     @silence_warnings
     def test_two_waiters_one_dies(self):
@@ -144,8 +144,8 @@ class TestQueue(LimitedTestCase):
         spawn(waiter, q, waiting_evt)
         sleep(0)
         q.send('hi')
-        self.assertEquals(dying_evt.wait(), 'timed out')
-        self.assertEquals(waiting_evt.wait(), 'hi')
+        self.assertEqual(dying_evt.wait(), 'timed out')
+        self.assertEqual(waiting_evt.wait(), 'hi')
 
     @silence_warnings
     def test_two_bogus_waiters(self):
@@ -164,9 +164,9 @@ class TestQueue(LimitedTestCase):
         spawn(do_receive, q, e2)
         sleep(0)
         q.send('sent')
-        self.assertEquals(e1.wait(), 'timed out')
-        self.assertEquals(e2.wait(), 'timed out')
-        self.assertEquals(q.wait(), 'sent')
+        self.assertEqual(e1.wait(), 'timed out')
+        self.assertEqual(e2.wait(), 'timed out')
+        self.assertEqual(q.wait(), 'sent')
                 
     @silence_warnings
     def test_waiting(self):
@@ -178,12 +178,12 @@ class TestQueue(LimitedTestCase):
         e1 = Event()
         spawn(do_wait, q, e1)
         sleep(0)
-        self.assertEquals(1, q.waiting())
+        self.assertEqual(1, q.waiting())
         q.send('hi')
         sleep(0)
-        self.assertEquals(0, q.waiting())
-        self.assertEquals('hi', e1.wait())
-        self.assertEquals(0, q.waiting())
+        self.assertEqual(0, q.waiting())
+        self.assertEqual('hi', e1.wait())
+        self.assertEqual(0, q.waiting())
 
 
 class TestChannel(LimitedTestCase):
@@ -240,19 +240,19 @@ class TestChannel(LimitedTestCase):
         w2 = eventlet.spawn(c.wait)
         w3 = eventlet.spawn(c.wait)
         sleep(0)
-        self.assertEquals(c.waiting(), 3)
+        self.assertEqual(c.waiting(), 3)
         s1 = eventlet.spawn(c.send, 1)
         s2 = eventlet.spawn(c.send, 2)
         s3 = eventlet.spawn(c.send, 3)
         sleep(0)  # this gets all the sends into a waiting state
-        self.assertEquals(c.waiting(), 0)
+        self.assertEqual(c.waiting(), 0)
 
         s1.wait()
         s2.wait()
         s3.wait()
         # NOTE: we don't guarantee that waiters are served in order
         results = sorted([w1.wait(), w2.wait(), w3.wait()])
-        self.assertEquals(results, [1,2,3])
+        self.assertEqual(results, [1,2,3])
 
 if __name__=='__main__':
     main()
diff --git a/tests/test__pool.py b/tests/test__pool.py
index 94482c0..ab2d969 100644
--- a/tests/test__pool.py
+++ b/tests/test__pool.py
@@ -68,7 +68,7 @@ class TestCoroutinePool(LimitedTestCase):
         done = pool.execute(consumer)
         pool.execute_async(producer)
         done.wait()
-        self.assertEquals(['cons1', 'prod', 'cons2'], results)
+        self.assertEqual(['cons1', 'prod', 'cons2'], results)
 
     def test_timer_cancel(self):
         # this test verifies that local timers are not fired
@@ -82,7 +82,7 @@ class TestCoroutinePool(LimitedTestCase):
         worker = pool.execute(some_work)
         worker.wait()
         api.sleep(0)
-        self.assertEquals(timer_fired, [])
+        self.assertEqual(timer_fired, [])
 
     def test_reentrant(self):
         pool = self.klass(0,1)
@@ -131,7 +131,7 @@ class TestCoroutinePool(LimitedTestCase):
             e.wait()
         pool.execute(wait_long_time, evt)
         pool.execute(wait_long_time, evt)
-        self.assertEquals(pool.free(), 0)
+        self.assertEqual(pool.free(), 0)
         self.assert_pool_has_free(pool, 0)
 
         # verify that the pool discards excess items put into it
@@ -143,12 +143,12 @@ class TestCoroutinePool(LimitedTestCase):
         api.sleep(0)
         api.sleep(0)
 
-        self.assertEquals(pool.free(), 1)
+        self.assertEqual(pool.free(), 1)
         self.assert_pool_has_free(pool, 1)
 
         # resize larger and assert that there are more free items
         pool.resize(2)
-        self.assertEquals(pool.free(), 2)
+        self.assertEqual(pool.free(), 2)
         self.assert_pool_has_free(pool, 2)
 
     def test_stderr_raising(self):
@@ -199,7 +199,7 @@ class TestCoroutinePool(LimitedTestCase):
             api.sleep(0.1)
             return 'ok'
         pool.execute(slow)
-        self.assertEquals(pool.wait(), 'ok')
+        self.assertEqual(pool.wait(), 'ok')
 
     def test_pool_smash(self):
         # The premise is that a coroutine in a Pool tries to get a token out
@@ -220,7 +220,7 @@ class TestCoroutinePool(LimitedTestCase):
         # the execute makes the token pool expect that coroutine, but then
         # immediately cuts bait
         e1 = pool.execute(do_receive, tp)
-        self.assertEquals(e1.wait(), 'timed out')
+        self.assertEqual(e1.wait(), 'timed out')
 
         # the pool can get some random item back
         def send_wakeup(tp):
@@ -232,10 +232,10 @@ class TestCoroutinePool(LimitedTestCase):
         def resume():
             return 'resumed'
         e2 = pool.execute(resume)
-        self.assertEquals(e2.wait(), 'resumed')
+        self.assertEqual(e2.wait(), 'resumed')
 
         # we should be able to get out the thing we put in there, too
-        self.assertEquals(tp.get(), 'wakeup')
+        self.assertEqual(tp.get(), 'wakeup')
 
 
 class PoolBasicTests(LimitedTestCase):
diff --git a/tests/thread_test.py b/tests/thread_test.py
index 98665cf..e54f022 100644
--- a/tests/thread_test.py
+++ b/tests/thread_test.py
@@ -84,16 +84,16 @@ class Locals(LimitedTestCase):
 
         my_local = Caller()
         my_local.foo = "foo1"
-        self.assertEquals("foo1", my_local.callme())
+        self.assertEqual("foo1", my_local.callme())
 
         def do_something():
             my_local.foo = "foo2"
-            self.assertEquals("foo2", my_local.callme())
+            self.assertEqual("foo2", my_local.callme())
 
         eventlet.spawn(do_something).wait()
 
         my_local.foo = "foo3"
-        self.assertEquals("foo3", my_local.callme())
+        self.assertEqual("foo3", my_local.callme())
 
     def test_no_leaking(self):
         refs = weakref.WeakKeyDictionary()
diff --git a/tests/tpool_test.py b/tests/tpool_test.py
index 5423b54..a699309 100644
--- a/tests/tpool_test.py
+++ b/tests/tpool_test.py
@@ -14,17 +14,15 @@
 # limitations under the License.
 from __future__ import print_function
 
-import itertools
+import gc
 import random
-from sys import stdout
-import time
 import re
-import gc
-from tests import skipped, skip_with_pyevent, LimitedTestCase, main
+import time
 
-from eventlet import tpool, debug
-from eventlet.support import six
 import eventlet
+from eventlet import tpool
+from eventlet.support import six
+from tests import LimitedTestCase, skipped, skip_with_pyevent, main
 
 
 one = 1
@@ -68,8 +66,10 @@ class TestTpool(LimitedTestCase):
     @skip_with_pyevent
     def test_wrap_uniterable(self):
         prox = tpool.Proxy([])
+
         def index():
             prox[0]
+
         def key():
             prox['a']
 
@@ -78,7 +78,7 @@ class TestTpool(LimitedTestCase):
 
     @skip_with_pyevent
     def test_wrap_dict(self):
-        my_object = {'a':1}
+        my_object = {'a': 1}
         prox = tpool.Proxy(my_object)
         self.assertEqual('a', prox.keys()[0])
         self.assertEqual(1, prox['a'])
@@ -111,9 +111,9 @@ class TestTpool(LimitedTestCase):
     def test_wrap_hash(self):
         prox1 = tpool.Proxy(''+'A')
         prox2 = tpool.Proxy('A'+'')
-        self.assert_(prox1=='A')
-        self.assert_('A'==prox2)
-        #self.assert_(prox1==prox2) FIXME - could __eq__ unwrap rhs if it is other proxy?
+        self.assert_(prox1 == 'A')
+        self.assert_('A' == prox2)
+        #self.assert_(prox1 == prox2) FIXME - could __eq__ unwrap rhs if it is other proxy?
         self.assertEqual(hash(prox1), hash(prox2))
         proxList = tpool.Proxy([])
         self.assertRaises(TypeError, hash, proxList)
@@ -130,19 +130,19 @@ class TestTpool(LimitedTestCase):
     def test_multiple_wraps(self):
         prox1 = tpool.Proxy(re)
         prox2 = tpool.Proxy(re)
-        x1 = prox1.compile('.')
+        prox1.compile('.')
         x2 = prox1.compile('.')
         del x2
-        x3 = prox2.compile('.')
+        prox2.compile('.')
 
     @skip_with_pyevent
     def test_wrap_getitem(self):
-        prox = tpool.Proxy([0,1,2])
+        prox = tpool.Proxy([0, 1, 2])
         self.assertEqual(prox[0], 0)
 
     @skip_with_pyevent
     def test_wrap_setitem(self):
-        prox = tpool.Proxy([0,1,2])
+        prox = tpool.Proxy([0, 1, 2])
         prox[1] = 2
         self.assertEqual(prox[1], 2)
 
@@ -153,11 +153,12 @@ class TestTpool(LimitedTestCase):
         result = []
         for i in prox:
             result.append(i)
-        self.assertEquals(list(range(10)), result)
+        self.assertEqual(list(range(10)), result)
 
     @skip_with_pyevent
     def test_wrap_iterator2(self):
         self.reset_timeout(5)  # might take a while due to imprecise sleeping
+
         def foo():
             import time
             for x in range(2):
@@ -165,9 +166,10 @@ class TestTpool(LimitedTestCase):
                 time.sleep(0.001)
 
         counter = [0]
+
         def tick():
             for i in six.moves.range(20000):
-                counter[0]+=1
+                counter[0] += 1
                 if counter[0] % 20 == 0:
                     eventlet.sleep(0.0001)
                 else:
@@ -185,6 +187,7 @@ class TestTpool(LimitedTestCase):
     @skip_with_pyevent
     def test_raising_exceptions(self):
         prox = tpool.Proxy(re)
+
         def nofunc():
             prox.never_name_a_function_like_this()
         self.assertRaises(AttributeError, nofunc)
@@ -197,8 +200,8 @@ class TestTpool(LimitedTestCase):
     def test_variable_and_keyword_arguments_with_function_calls(self):
         import optparse
         parser = tpool.Proxy(optparse.OptionParser())
-        z = parser.add_option('-n', action='store', type='string', dest='n')
-        opts,args = parser.parse_args(["-nfoo"])
+        parser.add_option('-n', action='store', type='string', dest='n')
+        opts, args = parser.parse_args(["-nfoo"])
         self.assertEqual(opts.n, 'foo')
 
     @skip_with_pyevent
@@ -207,11 +210,11 @@ class TestTpool(LimitedTestCase):
         prox = tpool.Proxy(tpool_test)
 
         pile = eventlet.GreenPile(4)
-        pile.spawn(lambda: self.assertEquals(prox.one, 1))
-        pile.spawn(lambda: self.assertEquals(prox.two, 2))
-        pile.spawn(lambda: self.assertEquals(prox.three, 3))
+        pile.spawn(lambda: self.assertEqual(prox.one, 1))
+        pile.spawn(lambda: self.assertEqual(prox.two, 2))
+        pile.spawn(lambda: self.assertEqual(prox.three, 3))
         results = list(pile)
-        self.assertEquals(len(results), 3)
+        self.assertEqual(len(results), 3)
 
     @skip_with_pyevent
     def test_timeout(self):
@@ -227,7 +230,7 @@ class TestTpool(LimitedTestCase):
 
     @skip_with_pyevent
     def test_autowrap(self):
-        x = tpool.Proxy({'a':1, 'b':2}, autowrap=(int,))
+        x = tpool.Proxy({'a': 1, 'b': 2}, autowrap=(int,))
         self.assert_(isinstance(x.get('a'), tpool.Proxy))
         self.assert_(not isinstance(x.items(), tpool.Proxy))
         # attributes as well as callables
@@ -238,7 +241,7 @@ class TestTpool(LimitedTestCase):
 
     @skip_with_pyevent
     def test_autowrap_names(self):
-        x = tpool.Proxy({'a':1, 'b':2}, autowrap_names=('get',))
+        x = tpool.Proxy({'a': 1, 'b': 2}, autowrap_names=('get',))
         self.assert_(isinstance(x.get('a'), tpool.Proxy))
         self.assert_(not isinstance(x.items(), tpool.Proxy))
         from tests import tpool_test
@@ -259,11 +262,11 @@ class TestTpool(LimitedTestCase):
         def wrapped(arg):
             return arg
         x = tpool.Proxy(wrapped)
-        self.assertEquals(4, x(4))
+        self.assertEqual(4, x(4))
         # verify that it wraps return values if specified
         x = tpool.Proxy(wrapped, autowrap_names=('__call__',))
         self.assert_(isinstance(x(4), tpool.Proxy))
-        self.assertEquals("4", str(x(4)))
+        self.assertEqual("4", str(x(4)))
 
     @skip_with_pyevent
     def test_callable_iterator(self):
@@ -274,7 +277,7 @@ class TestTpool(LimitedTestCase):
 
         x = tpool.Proxy(wrapped, autowrap_names=('__call__',))
         for r in x(3):
-            self.assertEquals(3, r)
+            self.assertEqual(3, r)
 
     @skip_with_pyevent
     def test_eventlet_timeout(self):
@@ -285,15 +288,18 @@ class TestTpool(LimitedTestCase):
     @skip_with_pyevent
     def test_tpool_set_num_threads(self):
         tpool.set_num_threads(5)
-        self.assertEquals(5, tpool._nthreads)
+        self.assertEqual(5, tpool._nthreads)
+
 
 class TpoolLongTests(LimitedTestCase):
-    TEST_TIMEOUT=60
+    TEST_TIMEOUT = 60
+
     @skip_with_pyevent
     def test_a_buncha_stuff(self):
         assert_ = self.assert_
+
         class Dummy(object):
-            def foo(self,when,token=None):
+            def foo(self, when, token=None):
                 assert_(token is not None)
                 time.sleep(random.random()/200.0)
                 return token
@@ -305,16 +311,16 @@ class TpoolLongTests(LimitedTestCase):
                 eventlet.sleep(random.random()/200.0)
                 now = time.time()
                 token = loopnum * count + n
-                rv = obj.foo(now,token=token)
-                self.assertEquals(token, rv)
+                rv = obj.foo(now, token=token)
+                self.assertEqual(token, rv)
                 eventlet.sleep(random.random()/200.0)
 
         cnt = 10
         pile = eventlet.GreenPile(cnt)
         for i in six.moves.range(cnt):
-            pile.spawn(sender_loop,i)
+            pile.spawn(sender_loop, i)
         results = list(pile)
-        self.assertEquals(len(results), cnt)
+        self.assertEqual(len(results), cnt)
         tpool.killall()
 
     @skipped
diff --git a/tests/wsgi_test.py b/tests/wsgi_test.py
index 53206a8..5bc71b0 100644
--- a/tests/wsgi_test.py
+++ b/tests/wsgi_test.py
@@ -447,7 +447,7 @@ class TestHttpd(_TestBase):
         sock = eventlet.wrap_ssl(sock)
         sock.write('POST /foo HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nContent-length:3\r\n\r\nabc')
         result = sock.read(8192)
-        self.assertEquals(result[-3:], 'abc')
+        self.assertEqual(result[-3:], 'abc')
 
     @skip_if_no_ssl
     def test_013_empty_return(self):
@@ -467,7 +467,7 @@ class TestHttpd(_TestBase):
         sock = eventlet.wrap_ssl(sock)
         sock.write('GET /foo HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
         result = sock.read(8192)
-        self.assertEquals(result[-4:], '\r\n\r\n')
+        self.assertEqual(result[-4:], '\r\n\r\n')
 
     def test_014_chunked_post(self):
         self.site.application = chunked_post
@@ -544,7 +544,7 @@ class TestHttpd(_TestBase):
                 break
             else:
                 header_lines.append(line)
-        self.assertEquals(1, len(
+        self.assertEqual(1, len(
             [l for l in header_lines if l.lower().startswith('content-length')]))
 
     @skip_if_no_ssl
@@ -748,8 +748,8 @@ class TestHttpd(_TestBase):
         fd.write('PUT / HTTP/1.1\r\nHost: localhost\r\nContent-length: 1025\r\nExpect: 100-continue\r\n\r\n')
         fd.flush()
         result = read_http(sock)
-        self.assertEquals(result.status, 'HTTP/1.1 417 Expectation Failed')
-        self.assertEquals(result.body, 'failure')
+        self.assertEqual(result.status, 'HTTP/1.1 417 Expectation Failed')
+        self.assertEqual(result.body, 'failure')
         fd.write('PUT / HTTP/1.1\r\nHost: localhost\r\nContent-length: 7\r\nExpect: 100-continue\r\n\r\ntesting')
         fd.flush()
         header_lines = []
@@ -768,7 +768,7 @@ class TestHttpd(_TestBase):
             else:
                 header_lines.append(line)
         self.assert_(header_lines[0].startswith('HTTP/1.1 200 OK'))
-        self.assertEquals(fd.read(7), 'testing')
+        self.assertEqual(fd.read(7), 'testing')
         fd.close()
         sock.close()
 
@@ -787,7 +787,7 @@ class TestHttpd(_TestBase):
                 eventlet.connect(('localhost', self.port))
                 self.fail("Didn't expect to connect")
             except socket.error as exc:
-                self.assertEquals(get_errno(exc), errno.ECONNREFUSED)
+                self.assertEqual(get_errno(exc), errno.ECONNREFUSED)
 
             self.assert_('Invalid argument' in self.logfile.getvalue(),
                          self.logfile.getvalue())
@@ -815,7 +815,7 @@ class TestHttpd(_TestBase):
         result = read_http(sock)
         self.assertEqual(result.headers_lower['connection'], 'close')
         self.assertNotEqual(result.headers_lower.get('transfer-encoding'), 'chunked')
-        self.assertEquals(result.body, "thisischunked")
+        self.assertEqual(result.body, "thisischunked")
 
     def test_minimum_chunk_size_parameter_leaves_httpprotocol_class_member_intact(self):
         start_size = wsgi.HttpProtocol.minimum_chunk_size
@@ -922,11 +922,11 @@ class TestHttpd(_TestBase):
         posthook2_count = [0]
 
         def posthook1(env, value, multiplier=1):
-            self.assertEquals(env['local.test'], 'test_029_posthooks')
+            self.assertEqual(env['local.test'], 'test_029_posthooks')
             posthook1_count[0] += value * multiplier
 
         def posthook2(env, value, divisor=1):
-            self.assertEquals(env['local.test'], 'test_029_posthooks')
+            self.assertEqual(env['local.test'], 'test_029_posthooks')
             posthook2_count[0] += value / divisor
 
         def one_posthook_app(env, start_response):
@@ -944,11 +944,11 @@ class TestHttpd(_TestBase):
         fp = sock.makefile('rw')
         fp.write('GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
         fp.flush()
-        self.assertEquals(fp.readline(), 'HTTP/1.1 200 OK\r\n')
+        self.assertEqual(fp.readline(), 'HTTP/1.1 200 OK\r\n')
         fp.close()
         sock.close()
-        self.assertEquals(posthook1_count[0], 6)
-        self.assertEquals(posthook2_count[0], 0)
+        self.assertEqual(posthook1_count[0], 6)
+        self.assertEqual(posthook2_count[0], 0)
 
         def two_posthook_app(env, start_response):
             env['local.test'] = 'test_029_posthooks'
@@ -967,11 +967,11 @@ class TestHttpd(_TestBase):
         fp = sock.makefile('rw')
         fp.write('GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
         fp.flush()
-        self.assertEquals(fp.readline(), 'HTTP/1.1 200 OK\r\n')
+        self.assertEqual(fp.readline(), 'HTTP/1.1 200 OK\r\n')
         fp.close()
         sock.close()
-        self.assertEquals(posthook1_count[0], 26)
-        self.assertEquals(posthook2_count[0], 25)
+        self.assertEqual(posthook1_count[0], 26)
+        self.assertEqual(posthook2_count[0], 25)
 
     def test_030_reject_long_header_lines(self):
         sock = eventlet.connect(('localhost', self.port))
@@ -981,7 +981,7 @@ class TestHttpd(_TestBase):
         fd.write(request)
         fd.flush()
         result = read_http(sock)
-        self.assertEquals(result.status, 'HTTP/1.0 400 Header Line Too Long')
+        self.assertEqual(result.status, 'HTTP/1.0 400 Header Line Too Long')
         fd.close()
 
     def test_031_reject_large_headers(self):
@@ -992,7 +992,7 @@ class TestHttpd(_TestBase):
         fd.write(request)
         fd.flush()
         result = read_http(sock)
-        self.assertEquals(result.status, 'HTTP/1.0 400 Headers Too Large')
+        self.assertEqual(result.status, 'HTTP/1.0 400 Headers Too Large')
         fd.close()
 
     def test_032_wsgi_input_as_iterable(self):
@@ -1019,9 +1019,9 @@ class TestHttpd(_TestBase):
         fd.write(request)
         fd.flush()
         result = read_http(sock)
-        self.assertEquals(result.body, upload_data)
+        self.assertEqual(result.body, upload_data)
         fd.close()
-        self.assertEquals(g[0], 1)
+        self.assertEqual(g[0], 1)
 
     def test_zero_length_chunked_response(self):
         def zero_chunked_app(env, start_response):
@@ -1400,7 +1400,7 @@ class TestChunkedInput(_TestBase):
 
     def ping(self, fd):
         fd.sendall("GET /ping HTTP/1.1\r\n\r\n")
-        self.assertEquals(read_http(fd).body, "pong")
+        self.assertEqual(read_http(fd).body, "pong")
 
     def test_short_read_with_content_length(self):
         body = self.body()
@@ -1408,7 +1408,7 @@ class TestChunkedInput(_TestBase):
 
         fd = self.connect()
         fd.sendall(req)
-        self.assertEquals(read_http(fd).body, "this is ch")
+        self.assertEqual(read_http(fd).body, "this is ch")
 
         self.ping(fd)
         fd.close()
@@ -1418,7 +1418,7 @@ class TestChunkedInput(_TestBase):
         req = "POST /short-read HTTP/1.1\r\ntransfer-encoding: Chunked\r\nContent-Length:0\r\n\r\n" + body
         fd = self.connect()
         fd.sendall(req)
-        self.assertEquals(read_http(fd).body, "this is ch")
+        self.assertEqual(read_http(fd).body, "this is ch")
 
         self.ping(fd)
         fd.close()
@@ -1429,7 +1429,7 @@ class TestChunkedInput(_TestBase):
 
         fd = self.connect()
         fd.sendall(req)
-        self.assertEquals(read_http(fd).body, "this is ch")
+        self.assertEqual(read_http(fd).body, "this is ch")
 
         self.ping(fd)
         fd.close()
@@ -1440,7 +1440,7 @@ class TestChunkedInput(_TestBase):
 
         fd = self.connect()
         fd.sendall(req)
-        self.assertEquals(read_http(fd).body, "pong")
+        self.assertEqual(read_http(fd).body, "pong")
 
         self.ping(fd)
         fd.close()
@@ -1451,7 +1451,7 @@ class TestChunkedInput(_TestBase):
 
         fd = self.connect()
         fd.sendall(req)
-        self.assertEquals(read_http(fd).body, 'this is chunked\nline 2\nline3')
+        self.assertEqual(read_http(fd).body, 'this is chunked\nline 2\nline3')
         fd.close()
 
     def test_chunked_readline_wsgi_override_minimum_chunk_size(self):
@@ -1466,7 +1466,7 @@ class TestChunkedInput(_TestBase):
                 resp_so_far += one_byte
                 if resp_so_far.endswith('\r\n\r\n'):
                     break
-            self.assertEquals(fd.recv(1), ' ')
+            self.assertEqual(fd.recv(1), ' ')
         try:
             with eventlet.Timeout(.1):
                 fd.recv(1)
@@ -1477,7 +1477,7 @@ class TestChunkedInput(_TestBase):
         self.yield_next_space = True
 
         with eventlet.Timeout(.1):
-            self.assertEquals(fd.recv(1), ' ')
+            self.assertEqual(fd.recv(1), ' ')
 
     def test_chunked_readline_wsgi_not_override_minimum_chunk_size(self):
 
@@ -1492,7 +1492,7 @@ class TestChunkedInput(_TestBase):
                     resp_so_far += one_byte
                     if resp_so_far.endswith('\r\n\r\n'):
                         break
-                self.assertEquals(fd.recv(1), ' ')
+                self.assertEqual(fd.recv(1), ' ')
         except eventlet.Timeout:
             pass
         else:
diff --git a/tests/zmq_test.py b/tests/zmq_test.py
index a31e8dd..283eef8 100644
--- a/tests/zmq_test.py
+++ b/tests/zmq_test.py
@@ -1,12 +1,9 @@
 from __future__ import with_statement
 
-from eventlet import event, spawn, sleep, patcher, semaphore
-from eventlet.hubs import get_hub, _threadlocal, use_hub
+from eventlet import event, spawn, sleep, semaphore
 from nose.tools import *
-from tests import check_idle_cpu_usage, mock, LimitedTestCase, using_pyevent, skip_unless
-from unittest import TestCase
+from tests import check_idle_cpu_usage, LimitedTestCase, using_pyevent, skip_unless
 
-from threading import Thread
 try:
     from eventlet.green import zmq
 except ImportError:
@@ -197,7 +194,7 @@ class TestUpstreamDownStream(LimitedTestCase):
 
         def tx(sock):
             for i in range(1, 1001):
-                msg = "sub%s %s" % ([2,1][i % 2], i)
+                msg = "sub%s %s" % ([2, 1][i % 2], i)
                 sock.send(msg)
                 sleep()
             sock.send('sub1 LAST')
@@ -312,7 +309,6 @@ class TestUpstreamDownStream(LimitedTestCase):
         for evt in done_evts:
             self.assertEqual(evt.wait(), 0)
 
-
     @skip_unless(zmq_supported)
     def test_send_during_recv_multipart(self):
         sender, receiver, port = self.create_bound_pair(zmq.XREQ, zmq.XREQ)
@@ -349,14 +345,12 @@ class TestUpstreamDownStream(LimitedTestCase):
             final_i = done_evts[i].wait()
             self.assertEqual(final_i, 0)
 
-
     # Need someway to ensure a thread is blocked on send... This isn't working
     @skip_unless(zmq_supported)
     def test_recv_during_send(self):
         sender, receiver, port = self.create_bound_pair(zmq.XREQ, zmq.XREQ)
         sleep()
 
-        num_recvs = 30
         done = event.Event()
 
         try:
@@ -480,12 +474,12 @@ class TestQueueLock(LimitedTestCase):
         spawn(lock, 3)
         sleep()
 
-        self.assertEquals(results, [])
+        self.assertEqual(results, [])
         q.release()
         s.acquire()
         s.acquire()
         s.acquire()
-        self.assertEquals(results, [1,2,3])
+        self.assertEqual(results, [1, 2, 3])
 
     @skip_unless(zmq_supported)
     def test_count(self):
@@ -520,6 +514,7 @@ class TestQueueLock(LimitedTestCase):
 
         s = semaphore.Semaphore(0)
         results = []
+
         def lock(x):
             with q:
                 results.append(x)
@@ -527,15 +522,15 @@ class TestQueueLock(LimitedTestCase):
 
         spawn(lock, 1)
         sleep()
-        self.assertEquals(results, [])
+        self.assertEqual(results, [])
         q.release()
         sleep()
-        self.assertEquals(results, [])
+        self.assertEqual(results, [])
         self.assertTrue(q)
         q.release()
 
         s.acquire()
-        self.assertEquals(results, [1])
+        self.assertEqual(results, [1])
 
 
 class TestBlockedThread(LimitedTestCase):
author	Sergey Shepelev <temotor@gmail.com>	2014-04-24 17:51:27 +0400
committer	Sergey Shepelev <temotor@gmail.com>	2014-04-24 18:11:37 +0400
commit	cbd404d56e231ea5419f07795a12d7082dd70ec4 (patch)
tree	7ad24a0f80e064b94108bb38b8c4a8a3eebafb44 /tests
parent	c467ded4a6e777518cd7a3888149510e3b31d334 (diff)
download	eventlet-cbd404d56e231ea5419f07795a12d7082dd70ec4.tar.gz