Index: eventlet-0.33.0/setup.py

===================================================================

--- eventlet-0.33.0.orig/setup.py

+++ eventlet-0.33.0/setup.py

@@ -27,7 +27,7 @@ setuptools.setup(

             'README.rst'

         )

     ).read(),

-    test_suite='nose.collector',

+    test_suite='tests',

     classifiers=[

         "Development Status :: 4 - Beta",

         "Intended Audience :: Developers",

Index: eventlet-0.33.0/eventlet.egg-info/SOURCES.txt

===================================================================

--- eventlet-0.33.0.orig/eventlet.egg-info/SOURCES.txt

+++ eventlet-0.33.0/eventlet.egg-info/SOURCES.txt

@@ -175,7 +175,6 @@ tests/greenthread_test.py

 tests/hub_test.py

 tests/mock.py

 tests/mysqldb_test.py

-tests/nosewrapper.py

 tests/openssl_test.py

 tests/os_test.py

 tests/parse_results.py

@@ -275,4 +274,4 @@ tests/stdlib/test_threading_local.py

 tests/stdlib/test_timeout.py

 tests/stdlib/test_urllib.py

 tests/stdlib/test_urllib2.py

-tests/stdlib/test_urllib2_localnet.py

\ No newline at end of file

+tests/stdlib/test_urllib2_localnet.py

Index: eventlet-0.33.0/tests/greenio_test.py

===================================================================

--- eventlet-0.33.0.orig/tests/greenio_test.py

+++ eventlet-0.33.0/tests/greenio_test.py

@@ -9,8 +9,6 @@ import socket as _orig_sock

 import sys

 import tempfile

-from nose.tools import eq_

-

 import eventlet

 from eventlet import event, greenio, debug

 from eventlet.hubs import get_hub

@@ -39,7 +37,7 @@ def expect_socket_timeout(function, *arg

         raise AssertionError("socket.timeout not raised")

     except socket.timeout as e:

         assert hasattr(e, 'args')

-        eq_(e.args[0], 'timed out')

+        assert e.args[0] == 'timed out'

 def min_buf_size():

@@ -674,8 +672,8 @@ class TestGreenSocket(tests.LimitedTestC

         sender.sendto(b'second', 0, address)

         sender_address = ('127.0.0.1', sender.getsockname()[1])

-        eq_(receiver.recvfrom(1024), (b'first', sender_address))

-        eq_(receiver.recvfrom(1024), (b'second', sender_address))

+        assert receiver.recvfrom(1024) == (b'first', sender_address)

+        assert receiver.recvfrom(1024) == (b'second', sender_address)

 def test_get_fileno_of_a_socket_works():

Index: eventlet-0.33.0/tests/nosewrapper.py

===================================================================

--- eventlet-0.33.0.orig/tests/nosewrapper.py

+++ eventlet-0.33.0/tests/nosewrapper.py

@@ -1,20 +1,13 @@

 """ This script simply gets the paths correct for testing eventlet with the

 hub extension for Nose."""

-import nose

 from os.path import dirname, realpath, abspath

 import sys

+import unittest

 parent_dir = dirname(dirname(realpath(abspath(__file__))))

 if parent_dir not in sys.path:

     sys.path.insert(0, parent_dir)

-# hudson does a better job printing the test results if the exit value is 0

-zero_status = '--force-zero-status'

-if zero_status in sys.argv:

-    sys.argv.remove(zero_status)

-    launch = nose.run

-else:

-    launch = nose.main

-

-launch(argv=sys.argv)

+if __name__ == '__main__':

+    unittest.main()

Index: eventlet-0.33.0/tests/__init__.py

===================================================================

--- eventlet-0.33.0.orig/tests/__init__.py

+++ eventlet-0.33.0/tests/__init__.py

@@ -20,7 +20,7 @@ import sys

 import unittest

 import warnings

-from nose.plugins.skip import SkipTest

+from unittest import SkipTest

 import eventlet

 from eventlet import tpool

@@ -223,7 +223,6 @@ class LimitedTestCase(unittest.TestCase)

 def check_idle_cpu_usage(duration, allowed_part):

     if resource is None:

         # TODO: use https://code.google.com/p/psutil/

-        from nose.plugins.skip import SkipTest

         raise SkipTest('CPU usage testing not supported (`import resource` failed)')

     r1 = resource.getrusage(resource.RUSAGE_SELF)

Index: eventlet-0.33.0/tests/dagpool_test.py

===================================================================

--- eventlet-0.33.0.orig/tests/dagpool_test.py

+++ eventlet-0.33.0/tests/dagpool_test.py

@@ -5,7 +5,6 @@

 @brief  Test DAGPool class

 """

-from nose.tools import *

 import eventlet

 from eventlet.dagpool import DAGPool, Collision, PropagateError

 import six

@@ -13,8 +12,8 @@ from contextlib import contextmanager

 import itertools

-# Not all versions of nose.tools.assert_raises() support the usage in this

-# module, but it's straightforward enough to code that explicitly.

+# Not all versions of assert_raises() support the usage in this module,

+# but it's straightforward enough to code that explicitly.

 @contextmanager

 def assert_raises(exc):

     """exc is an exception class"""

@@ -163,7 +162,7 @@ class Capture(object):

                     # a set. Make a set containing its elements.

                     setlist.append(set(subseq))

         # Now that we've massaged 'sequence' into 'setlist', compare.

-        assert_equal(self.sequence, setlist)

+        assert self.sequence == setlist

 # ****************************************************************************

@@ -191,14 +190,14 @@ def test_init():

         with check_no_suspend():

             results = pool.waitall()

         # with no spawn() or post(), waitall() returns preload data

-        assert_equals(results, dict(a=1, b=2, c=3))

+        assert results == dict(a=1, b=2, c=3)

         # preload sequence of pairs

         pool = DAGPool([("d", 4), ("e", 5), ("f", 6)])

         # this must not hang

         with check_no_suspend():

             results = pool.waitall()

-        assert_equals(results, dict(d=4, e=5, f=6))

+        assert results == dict(d=4, e=5, f=6)

 def test_wait_each_empty():

@@ -216,10 +215,10 @@ def test_wait_each_preload():

         with check_no_suspend():

             # wait_each() may deliver in arbitrary order; collect into a dict

             # for comparison

-            assert_equals(dict(pool.wait_each("abc")), dict(a=1, b=2, c=3))

+            assert dict(pool.wait_each("abc")) == dict(a=1, b=2, c=3)

             # while we're at it, test wait() for preloaded keys

-            assert_equals(pool.wait("bc"), dict(b=2, c=3))

+            assert pool.wait("bc") == dict(b=2, c=3)

 def post_each(pool, capture):

@@ -257,7 +256,7 @@ def test_wait_posted():

     eventlet.spawn(post_each, pool, capture)

     gotten = pool.wait("bcdefg")

     capture.add("got all")

-    assert_equals(gotten,

+    assert (gotten ==

                   dict(b=2, c=3,

                        d="dval", e="eval",

                        f="fval", g="gval"))

@@ -285,7 +284,7 @@ def test_spawn_collision_spawn():

     pool = DAGPool()

     pool.spawn("a", (), lambda key, results: "aval")

     # hasn't yet even started

-    assert_equals(pool.get("a"), None)

+    assert pool.get("a") == None

     with assert_raises(Collision):

         # Attempting to spawn again with same key should collide even if the

         # first spawned greenthread hasn't yet had a chance to run.

@@ -293,7 +292,7 @@ def test_spawn_collision_spawn():

     # now let the spawned eventlet run

     eventlet.sleep(0)

     # should have finished

-    assert_equals(pool.get("a"), "aval")

+    assert pool.get("a") == "aval"

     with assert_raises(Collision):

         # Attempting to spawn with same key collides even when the greenthread

         # has completed.

@@ -324,60 +323,60 @@ def test_spawn_multiple():

     capture.step()

     # but none of them has yet produced a result

     for k in "defgh":

-        assert_equals(pool.get(k), None)

-    assert_equals(set(pool.keys()), set("abc"))

-    assert_equals(dict(pool.items()), dict(a=1, b=2, c=3))

-    assert_equals(pool.running(), 5)

-    assert_equals(set(pool.running_keys()), set("defgh"))

-    assert_equals(pool.waiting(), 1)

-    assert_equals(pool.waiting_for(), dict(h=set("defg")))

-    assert_equals(pool.waiting_for("d"), set())

-    assert_equals(pool.waiting_for("c"), set())

+        assert pool.get(k) == None

+    assert set(pool.keys()) == set("abc")

+    assert dict(pool.items()) == dict(a=1, b=2, c=3)

+    assert pool.running() == 5

+    assert set(pool.running_keys()) == set("defgh")

+    assert pool.waiting() == 1

+    assert pool.waiting_for() == dict(h=set("defg"))

+    assert pool.waiting_for("d") == set()

+    assert pool.waiting_for("c") == set()

     with assert_raises(KeyError):

         pool.waiting_for("j")

-    assert_equals(pool.waiting_for("h"), set("defg"))

+    assert pool.waiting_for("h") == set("defg")

     # let one of the upstream greenthreads complete

     events["f"].send("fval")

     spin()

     capture.step()

-    assert_equals(pool.get("f"), "fval")

-    assert_equals(set(pool.keys()), set("abcf"))

-    assert_equals(dict(pool.items()), dict(a=1, b=2, c=3, f="fval"))

-    assert_equals(pool.running(), 4)

-    assert_equals(set(pool.running_keys()), set("degh"))

-    assert_equals(pool.waiting(), 1)

-    assert_equals(pool.waiting_for("h"), set("deg"))

+    assert pool.get("f") == "fval"

+    assert set(pool.keys()) == set("abcf")

+    assert dict(pool.items()) == dict(a=1, b=2, c=3, f="fval")

+    assert pool.running() == 4

+    assert set(pool.running_keys()) == set("degh")

+    assert pool.waiting() == 1

+    assert pool.waiting_for("h") == set("deg")

     # now two others

     events["e"].send("eval")

     events["g"].send("gval")

     spin()

     capture.step()

-    assert_equals(pool.get("e"), "eval")

-    assert_equals(pool.get("g"), "gval")

-    assert_equals(set(pool.keys()), set("abcefg"))

-    assert_equals(dict(pool.items()),

+    assert pool.get("e") == "eval"

+    assert pool.get("g") == "gval"

+    assert set(pool.keys()) == set("abcefg")

+    assert (dict(pool.items()) ==

                   dict(a=1, b=2, c=3, e="eval", f="fval", g="gval"))

-    assert_equals(pool.running(), 2)

-    assert_equals(set(pool.running_keys()), set("dh"))

-    assert_equals(pool.waiting(), 1)

-    assert_equals(pool.waiting_for("h"), set("d"))

+    assert pool.running() == 2

+    assert set(pool.running_keys()) == set("dh")

+    assert pool.waiting() == 1

+    assert pool.waiting_for("h") == set("d")

     # last one

     events["d"].send("dval")

     # make sure both pool greenthreads get a chance to run

     spin()

     capture.step()

-    assert_equals(pool.get("d"), "dval")

-    assert_equals(set(pool.keys()), set("abcdefgh"))

-    assert_equals(dict(pool.items()),

+    assert pool.get("d") == "dval"

+    assert set(pool.keys()) == set("abcdefgh")

+    assert (dict(pool.items()) ==

                   dict(a=1, b=2, c=3,

                        d="dval", e="eval", f="fval", g="gval", h="hval"))

-    assert_equals(pool.running(), 0)

-    assert_false(pool.running_keys())

-    assert_equals(pool.waiting(), 0)

-    assert_equals(pool.waiting_for("h"), set())

+    assert pool.running() == 0

+    assert not pool.running_keys()

+    assert pool.waiting() == 0

+    assert pool.waiting_for("h") == set()

     capture.validate([

         ["h got b", "h got c"],

@@ -432,13 +431,13 @@ def test_spawn_many():

     spin()

     # verify that e completed (also that post(key) within greenthread

     # overrides implicit post of return value, which would be None)

-    assert_equals(pool.get("e"), "e")

+    assert pool.get("e") == "e"

     # With the dependency graph shown above, it is not guaranteed whether b or

     # c will complete first. Handle either case.

     sequence = capture.sequence[:]

     sequence[1:3] = [set([sequence[1].pop(), sequence[2].pop()])]

-    assert_equals(sequence,

+    assert (sequence ==

                   [set(["a done"]),

                    set(["b done", "c done"]),

                    set(["d done"]),

@@ -466,7 +465,7 @@ def test_wait_each_all():

     for pos in range(len(keys)):

         # next value from wait_each()

         k, v = next(each)

-        assert_equals(k, keys[pos])

+        assert k == keys[pos]

         # advance every pool greenlet as far as it can go

         spin()

         # everything from keys[:pos+1] should have a value by now

@@ -494,7 +493,7 @@ def test_kill():

     pool.kill("a")

     # didn't run

     spin()

-    assert_equals(pool.get("a"), None)

+    assert pool.get("a") == None

     # killing it forgets about it

     with assert_raises(KeyError):

         pool.kill("a")

@@ -505,7 +504,7 @@ def test_kill():

     with assert_raises(KeyError):

         pool.kill("a")

     # verify it ran to completion

-    assert_equals(pool.get("a"), 2)

+    assert pool.get("a") == 2

 def test_post_collision_preload():

@@ -533,7 +532,7 @@ def test_post_collision_spawn():

     pool.kill("a")

     # now we can post

     pool.post("a", 3)

-    assert_equals(pool.get("a"), 3)

+    assert pool.get("a") == 3

     pool = DAGPool()

     pool.spawn("a", (), lambda key, result: 4)

@@ -553,10 +552,10 @@ def test_post_replace():

     pool = DAGPool()

     pool.post("a", 1)

     pool.post("a", 2, replace=True)

-    assert_equals(pool.get("a"), 2)

-    assert_equals(dict(pool.wait_each("a")), dict(a=2))

-    assert_equals(pool.wait("a"), dict(a=2))

-    assert_equals(pool["a"], 2)

+    assert pool.get("a") == 2

+    assert dict(pool.wait_each("a")) == dict(a=2)

+    assert pool.wait("a") == dict(a=2)

+    assert pool["a"] == 2

 def waitfor(capture, pool, key):

@@ -598,14 +597,14 @@ def test_waitall_exc():

     try:

         pool.waitall()

     except PropagateError as err:

-        assert_equals(err.key, "a")

+        assert err.key == "a"

         assert isinstance(err.exc, BogusError), \

             "exc attribute is {0}, not BogusError".format(err.exc)

-        assert_equals(str(err.exc), "bogus")

+        assert str(err.exc) == "bogus"

         msg = str(err)

-        assert_in("PropagateError(a)", msg)

-        assert_in("BogusError", msg)

-        assert_in("bogus", msg)

+        assert "PropagateError(a)" in msg

+        assert "BogusError" in msg

+        assert "bogus" in msg

 def test_propagate_exc():

@@ -616,20 +615,20 @@ def test_propagate_exc():

     try:

         pool["c"]

     except PropagateError as errc:

-        assert_equals(errc.key, "c")

+        assert errc.key == "c"

         errb = errc.exc

-        assert_equals(errb.key, "b")

+        assert errb.key == "b"

         erra = errb.exc

-        assert_equals(erra.key, "a")

+        assert erra.key == "a"

         assert isinstance(erra.exc, BogusError), \

             "exc attribute is {0}, not BogusError".format(erra.exc)

-        assert_equals(str(erra.exc), "bogus")

+        assert str(erra.exc) == "bogus"

         msg = str(errc)

-        assert_in("PropagateError(a)", msg)

-        assert_in("PropagateError(b)", msg)

-        assert_in("PropagateError(c)", msg)

-        assert_in("BogusError", msg)

-        assert_in("bogus", msg)

+        assert "PropagateError(a)" in msg

+        assert "PropagateError(b)" in msg

+        assert "PropagateError(c)" in msg

+        assert "BogusError" in msg

+        assert "bogus" in msg

 def test_wait_each_exc():

@@ -681,13 +680,13 @@ def test_post_get_exc():

             pass

     # wait_each_success() filters

-    assert_equals(dict(pool.wait_each_success()), dict(a=bogua))

-    assert_equals(dict(pool.wait_each_success("ab")), dict(a=bogua))

-    assert_equals(dict(pool.wait_each_success("a")), dict(a=bogua))

-    assert_equals(dict(pool.wait_each_success("b")), {})

+    assert dict(pool.wait_each_success()) == dict(a=bogua)

+    assert dict(pool.wait_each_success("ab")) == dict(a=bogua)

+    assert dict(pool.wait_each_success("a")) == dict(a=bogua)

+    assert dict(pool.wait_each_success("b")) == {}

     # wait_each_exception() filters the other way

-    assert_equals(dict(pool.wait_each_exception()), dict(b=bogub))

-    assert_equals(dict(pool.wait_each_exception("ab")), dict(b=bogub))

-    assert_equals(dict(pool.wait_each_exception("a")), {})

-    assert_equals(dict(pool.wait_each_exception("b")), dict(b=bogub))

+    assert dict(pool.wait_each_exception()) == dict(b=bogub)

+    assert dict(pool.wait_each_exception("ab")) == dict(b=bogub)

+    assert dict(pool.wait_each_exception("a")) == {}

+    assert dict(pool.wait_each_exception("b")) == dict(b=bogub)