Try testing PyPy on Windows again. I'm getting clean-ish runs in my local test...

Try testing PyPy on Windows again. I'm getting clean-ish runs in my local test VM (with a small number of networking and subprocess tests disabled).

Try testing PyPy on Windows again. I'm getting clean-ish runs in my local test...
Try testing PyPy on Windows again. I'm getting clean-ish runs in my local test VM (with a small number of networking and subprocess tests disabled).
602724fc · Jason Madden · c40a5796 · 602724fc · 602724fc · 602724fc
Commit 602724fc authored Jan 24, 2018 by Jason Madden
21 changed files
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -55,6 +55,9 @@ Platform Support
  been tested. This merely removes the supporting Trove classifier and
  remaining test code. See :issue:`997`.
+- PyPy is now known to run on Windows using the libuv backend, with
+  caveats. See the section on libuv for more information.
 - Due to security concerns, official support for Python 2.7.8 and
  earlier (without a modern SSL implementation) has been dropped.
  These versions are no longer tested with gevent, but gevent can
@@ -206,6 +209,14 @@ libuv
    duplicate crashes. If you can duplicate a crash, **please** submit
    an issue.
+  - This is the only backend that PyPy can use on Windows. As of this
+    alpha, there are many known issues with non-blocking sockets
+    (e.g., as used by :mod:`asyncore`; see ``test_ftplib.py``) and
+    sometimes sockets not getting closed in a timely fashion
+    (apparently; see ``test_httpservers.py``) and communicating with
+    subprocesses (it always hangs). Help tracking those down would be
+    appreciated. Only PyPy2 is tested.
  Feedback and pull requests are welcome, especially to address the
  issues mentioned above.

--- a/appveyor.yml
+++ b/appveyor.yml
@@ -10,15 +10,12 @@ environment:
    # Pre-installed Python versions, which Appveyor may upgrade to
    # a later point release.
-    # We're not quite ready for PyPy+libuv.
-    # It works correctly on POSIX (linux and darwin),
+    - PYTHON: "C:\\pypy2-v5.10.0-win32"
-    # but has some strange errors and many timeouts on Windows.
+      PYTHON_ID: "pypy"
-    # Most recent build: https://ci.appveyor.com/project/denik/gevent/build/1.0.1174/job/cv63181yj3ebb9cs
+      PYTHON_EXE: pypy
-    # - PYTHON: "C:\\pypy2-v5.9.0-win32"
+      PYTHON_VERSION: "2.7.x"
-    #   PYTHON_ID: "pypy"
+      PYTHON_ARCH: "32"
-    #   PYTHON_EXE: pypy
-    #   PYTHON_VERSION: "2.7.x"
-    #   PYTHON_ARCH: "32"
    - PYTHON: "C:\\Python36-x64"
      PYTHON_VERSION: "3.6.x" # currently 3.6.0
@@ -104,10 +101,10 @@ install:
        New-Item -ItemType directory -Path "$env:PYTMP" | Out-Null;
      }
      if ("${env:PYTHON_ID}" -eq "pypy") {
-        if (!(Test-Path "${env:PYTMP}\pypy2-v5.9.0-win32.zip")) {
+        if (!(Test-Path "${env:PYTMP}\pypy2-v5.10.0-win32.zip")) {
-          (New-Object Net.WebClient).DownloadFile('https://bitbucket.org/pypy/pypy/downloads/pypy2-v5.9.0-win32.zip', "${env:PYTMP}\pypy2-v5.9.0-win32.zip");
+          (New-Object Net.WebClient).DownloadFile('https://bitbucket.org/pypy/pypy/downloads/pypy2-v5.10.0-win32.zip', "${env:PYTMP}\pypy2-v5.10.0-win32.zip");
        }
-        7z x -y "${env:PYTMP}\pypy2-v5.9.0-win32.zip" -oC:\ | Out-Null;
+        7z x -y "${env:PYTMP}\pypy2-v5.10.0-win32.zip" -oC:\ | Out-Null;
        & "${env:PYTHON}\pypy.exe" "-mensurepip";
      }

--- a/examples/echoserver.py
+++ b/examples/echoserver.py
@@ -2,7 +2,7 @@
 """Simple server that listens on port 16000 and echos back every input to the client.
 Connect to it with:
-  telnet localhost 16000
+  telnet 127.0.0.1 16000
 Terminate the connection by terminating telnet (typically Ctrl-] and then 'quit').
 """
@@ -30,7 +30,7 @@ def echo(socket, address):
 if __name__ == '__main__':
    # to make the server use SSL, pass certfile and keyfile arguments to the constructor
-    server = StreamServer(('0.0.0.0', 16000), echo)
+    server = StreamServer(('127.0.0.1', 16000), echo)
    # to start the server asynchronously, use its start() method;
    # we use blocking serve_forever() here because we have no other jobs
    print('Starting echo server on port 16000')

--- a/examples/webproxy.py
+++ b/examples/webproxy.py
@@ -27,7 +27,7 @@ except ImportError:
    from urllib.parse import urlparse
    from urllib.parse import unquote
-LISTEN = ":8088"
+LISTEN = ('127.0.0.1', 8088)
 def _as_bytes(s):
@@ -147,5 +147,5 @@ FORM = b"""<html><head>
 if __name__ == '__main__':
    from gevent.pywsgi import WSGIServer
-    print('Serving on %s...' % LISTEN)
+    print('Serving on %s...' % (LISTEN,))
    WSGIServer(LISTEN, application).serve_forever()
--- a/examples/wsgiserver.py
+++ b/examples/wsgiserver.py
@@ -15,4 +15,4 @@ def application(env, start_response):
 if __name__ == '__main__':
    print('Serving on 8088...')
-    WSGIServer(('', 8088), application).serve_forever()
+    WSGIServer(('127.0.0.1', 8088), application).serve_forever()
--- a/examples/wsgiserver_ssl.py
+++ b/examples/wsgiserver_ssl.py
@@ -14,7 +14,7 @@ def hello_world(env, start_response):
    return [b'<h1>Not Found</h1>']
 print('Serving on https://:8443')
-server = pywsgi.WSGIServer(('', 8443), hello_world, keyfile='server.key', certfile='server.crt')
+server = pywsgi.WSGIServer(('127.0.0.1', 8443), hello_world, keyfile='server.key', certfile='server.crt')
 # to start the server asynchronously, call server.start()
 # we use blocking serve_forever() here because we have no other jobs
 server.serve_forever()
--- a/src/greentest/2.7pypy/test_httpservers.py
+++ b/src/greentest/2.7pypy/test_httpservers.py
@@ -664,6 +664,18 @@ class SimpleHTTPRequestHandlerTestCase(unittest.TestCase):
 def test_main(verbose=None):
+    # XXX: gevent: On windows with pypy2, some of these
+    # tests are incredibly slow or hang in shutdown for unknown
+    # reasons
+    import greentest
+    if greentest.PYPY and greentest.WIN:
+        class SimpleHTTPRequestHandlerTestCase(unittest.TestCase):
+            def setUp(self):
+                raise unittest.SkipTest("gevent: Hangs")
+            def test_empty(self):
+                return
+        SimpleHTTPServerTestCase = SimpleHTTPRequestHandlerTestCase
+        CGIHTTPServerTestCase = SimpleHTTPRequestHandlerTestCase
    try:
        cwd = os.getcwd()
        test_support.run_unittest(BaseHTTPRequestHandlerTestCase,

--- a/src/greentest/greentest/__init__.py
+++ b/src/greentest/greentest/__init__.py
@@ -64,7 +64,7 @@ from greentest.skipping import skipIf
 from greentest.skipping import skipOnLibuv
 from greentest.skipping import skipOnLibuvOnCI
 from greentest.skipping import skipOnLibuvOnCIOnPyPy
+from greentest.skipping import skipOnLibuvOnPyPyOnWin
 from greentest.exception import ExpectedException

--- a/src/greentest/greentest/flaky.py
+++ b/src/greentest/greentest/flaky.py
@@ -27,6 +27,9 @@ from gevent.util import dump_stacks
 from greentest import sysinfo
 from greentest import six
+class FlakyAssertionError(AssertionError):
+    "Re-raised so that we know it's a known-flaky test."
 # The next exceptions allow us to raise them in a highly
 # greppable way so that we can debug them later.
@@ -54,22 +57,37 @@ class FlakyTestCrashes(FlakyTest):
    """
 def reraiseFlakyTestRaceCondition():
-    six.reraise(*sys.exc_info())
+    six.reraise(FlakyAssertionError,
+                FlakyAssertionError(sys.exc_info()[1]),
+                sys.exc_info()[2])
 reraiseFlakyTestTimeout = reraiseFlakyTestRaceCondition
 reraiseFlakyTestRaceConditionLibuv = reraiseFlakyTestRaceCondition
 reraiseFlakyTestTimeoutLibuv = reraiseFlakyTestRaceCondition
-if sysinfo.RUNNING_ON_CI:
+if sysinfo.RUNNING_ON_CI or (sysinfo.PYPY and sysinfo.WIN):
    # pylint: disable=function-redefined
    def reraiseFlakyTestRaceCondition():
+        if sysinfo.PYPY and sysinfo.WIN:
+            # Getting stack traces is incredibly expensive
+            # in pypy on win, at least in test virtual machines.
+            # It can take minutes. The traceback consistently looks like
+            # the following when interrupted:
+            # dump_stacks -> traceback.format_stack
+            #    -> traceback.extract_stack -> linecache.checkcache
+            #    -> os.stat -> _structseq.structseq_new
+            msg = str(sys.exc_info()[1])
+        else:
+            msg = '\n'.join(dump_stacks())
        six.reraise(FlakyTestRaceCondition,
-                    FlakyTestRaceCondition('\n'.join(dump_stacks())),
+                    FlakyTestRaceCondition(msg),
                    sys.exc_info()[2])
    def reraiseFlakyTestTimeout():
+        msg = str(sys.exc_info()[1])
        six.reraise(FlakyTestTimeout,
-                    FlakyTestTimeout(),
+                    FlakyTestTimeout(msg),
                    sys.exc_info()[2])
    if sysinfo.LIBUV:

--- a/src/greentest/greentest/patched_tests_setup.py
+++ b/src/greentest/greentest/patched_tests_setup.py
@@ -301,7 +301,7 @@ if LIBUV:
            # That returns None when the underlying socket raises
            # EWOULDBLOCK, which it will do because it's set to non-blocking
            # both by gevent and by libuv (at the level below python's knowledge)
-            # I can *sometimes* reproduce these locally; it seems to be some sort
+            # I can *usually* reproduce these locally; it seems to be some sort
            # of race condition.
            'test_ftplib.TestFTPClass.test_acct',
            'test_ftplib.TestFTPClass.test_all_errors',
@@ -332,8 +332,14 @@ if LIBUV:
            'test_ftplib.TestFTPClass.test_storlines',
            'test_ftplib.TestFTPClass.test_storlines_too_long',
            'test_ftplib.TestFTPClass.test_voidcmd',
+            'test_ftplib.TestTLS_FTPClass.test_data_connection',
-            # This one times out
+            'test_ftplib.TestTLS_FTPClass.test_control_connection',
+            'test_ftplib.TestTLS_FTPClass.test_context',
+            'test_ftplib.TestTLS_FTPClass.test_check_hostname',
+            'test_ftplib.TestTLS_FTPClass.test_auth_ssl',
+            'test_ftplib.TestTLS_FTPClass.test_auth_issued_twice',
+            # This one times out, but it's still a non-blocking socket
            'test_ftplib.TestFTPClass.test_makeport',
            # More unexpected timeouts
@@ -345,13 +351,60 @@ if LIBUV:
            # A timeout, possibly because of the way we handle interrupts?
            'test_socketserver.SocketServerTest.test_InterruptedServerSelectCall',
+            'test_socketserver.SocketServerTest.test_InterruptServerSelectCall',
+            # times out with something about threading?
+            # The apparent hang is just after the print of "waiting for server"
+            'test_socketserver.SocketServerTest.test_ThreadingTCPServer',
+            'test_socketserver.SocketServerTest.test_ThreadingUDPServer',
+            'test_socketserver.SocketServerTest.test_TCPServer',
+            'test_socketserver.SocketServerTest.test_UDPServer',
            # This one might be like  'test_urllib2_localnet.TestUrlopen.test_https_with_cafile'?
+            # XXX: Look at newer pypy and verify our usage of drop/reuse matches
+            # theirs.
            'test_httpservers.BaseHTTPServerTestCase.test_command',
+            'test_httpservers.BaseHTTPServerTestCase.test_handler',
+            'test_httpservers.BaseHTTPServerTestCase.test_head_keep_alive',
+            'test_httpservers.BaseHTTPServerTestCase.test_head_via_send_error',
+            'test_httpservers.BaseHTTPServerTestCase.test_header_close',
+            'test_httpservers.BaseHTTPServerTestCase.test_internal_key_error',
+            'test_httpservers.BaseHTTPServerTestCase.test_request_line_trimming',
+            'test_httpservers.BaseHTTPServerTestCase.test_return_custom_status',
+            'test_httpservers.BaseHTTPServerTestCase.test_send_blank',
+            'test_httpservers.BaseHTTPServerTestCase.test_send_error',
+            'test_httpservers.BaseHTTPServerTestCase.test_version_bogus',
+            'test_httpservers.BaseHTTPServerTestCase.test_version_digits',
+            'test_httpservers.BaseHTTPServerTestCase.test_version_invalid',
+            'test_httpservers.BaseHTTPServerTestCase.test_version_none',
            # But on Windows, our gc fix for that doesn't work anyway
            # so we have to disable it.
            'test_urllib2_localnet.TestUrlopen.test_https_with_cafile',
+            # These tests hang. see above.
+            'test_threading.ThreadJoinOnShutdown.test_1_join_on_shutdown',
+            'test_threading.ThreadingExceptionTests.test_print_exception',
+            # Our copy of these in test__subprocess.py also hangs.
+            # Anything that uses Popen.communicate or directly uses
+            # Popen.stdXXX.read hangs. It's not clear why.
+            'test_subprocess.ProcessTestCase.test_communicate',
+            'test_subprocess.ProcessTestCase.test_cwd',
+            'test_subprocess.ProcessTestCase.test_env',
+            'test_subprocess.ProcessTestCase.test_stderr_pipe',
+            'test_subprocess.ProcessTestCase.test_stdout_pipe',
+            'test_subprocess.ProcessTestCase.test_stdout_stderr_pipe',
+            'test_subprocess.ProcessTestCase.test_stderr_redirect_with_no_stdout_redirect',
+            'test_subprocess.ProcessTestCase.test_stdout_filedes_of_stdout',
+            'test_subprocess.ProcessTestcase.test_stdout_none',
+            'test_subprocess.ProcessTestcase.test_universal_newlines',
+            'test_subprocess.ProcessTestcase.test_writes_before_communicate',
+            'test_subprocess.Win32ProcessTestCase._kill_process',
+            'test_subprocess.Win32ProcessTestCase._kill_dead_process',
+            'test_subprocess.Win32ProcessTestCase.test_shell_sequence',
+            'test_subprocess.Win32ProcessTestCase.test_shell_string',
+            'test_subprocess.CommandsWithSpaces.with_spaces',
        ]
    if WIN:
@@ -726,6 +779,7 @@ if PYPY:
        'test_urllib2_localnet.TestUrlopen.test_https_with_cafile': _gc_at_end,
    })
 if PY34 and sys.version_info[:3] < (3, 4, 4):
    # Older versions have some issues with the SSL tests. Seen on Appveyor
    disabled_tests += [

--- a/src/greentest/greentest/skipping.py
+++ b/src/greentest/greentest/skipping.py
@@ -72,6 +72,7 @@ skipIf = unittest.skipIf
 skipOnLibuv = _do_not_skip
 skipOnLibuvOnCI = _do_not_skip
 skipOnLibuvOnCIOnPyPy = _do_not_skip
+skipOnLibuvOnPyPyOnWin = _do_not_skip
 if sysinfo.LIBUV:
    skipOnLibuv = unittest.skip
@@ -80,3 +81,6 @@ if sysinfo.LIBUV:
        skipOnLibuvOnCI = unittest.skip
        if sysinfo.PYPY:
            skipOnLibuvOnCIOnPyPy = unittest.skip
+    if sysinfo.PYPY and sysinfo.WIN:
+        skipOnLibuvOnPyPyOnWin = unittest.skip
--- a/src/greentest/greentest/testcase.py
+++ b/src/greentest/greentest/testcase.py
@@ -225,18 +225,18 @@ class TestCase(TestCaseMetaClass("NewBase", (BaseTestCase,), {})):
            self.assertIsInstance(econtext, where_type)
        return error
+    def assertTimeoutAlmostEqual(self, first, second, places=None, msg=None, delta=None):
+        try:
+            self.assertAlmostEqual(first, second, places=places, msg=msg, delta=delta)
+        except AssertionError:
+            flaky.reraiseFlakyTestTimeout()
    if sysinfo.EXPECT_POOR_TIMER_RESOLUTION:
        # pylint:disable=unused-argument
-        # appveyor timeouts are unreliable; seems to be very slow wakeups
-        def assertTimeoutAlmostEqual(self, *args, **kwargs):
-            return
        def assertTimeWithinRange(self, delay, min_time, max_time):
            return
    else:
-        def assertTimeoutAlmostEqual(self, *args, **kwargs):
-            self.assertAlmostEqual(*args, **kwargs)
        def assertTimeWithinRange(self, time_taken, min_time, max_time):
            self.assertLessEqual(time_taken, max_time)
            self.assertGreaterEqual(time_taken, min_time)

--- a/src/greentest/test___example_servers.py
+++ b/src/greentest/test___example_servers.py
@@ -12,10 +12,11 @@ import ssl
 from greentest import DEFAULT_XPC_SOCKET_TIMEOUT
 from greentest import main
 from greentest import util
+from greentest import params
 class Test_wsgiserver(util.TestServer):
    server = 'wsgiserver.py'
-    URL = 'http://localhost:8088'
+    URL = 'http://%s:8088' % (params.DEFAULT_LOCAL_HOST_ADDR,)
    PORT = 8088
    not_found_message = b'<h1>Not Found</h1>'
    ssl_ctx = None
@@ -90,7 +91,7 @@ class Test_wsgiserver(util.TestServer):
 class Test_wsgiserver_ssl(Test_wsgiserver):
    server = 'wsgiserver_ssl.py'
-    URL = 'https://localhost:8443'
+    URL = 'https://%s:8443' % (params.DEFAULT_LOCAL_HOST_ADDR,)
    PORT = 8443
    _use_ssl = True

--- a/src/greentest/test__core_stat.py
+++ b/src/greentest/test__core_stat.py
@@ -8,6 +8,7 @@ import gevent
 import gevent.core
 import greentest
+import greentest.flaky
 #pylint: disable=protected-access
@@ -82,7 +83,7 @@ class TestCoreStat(greentest.TestCase):
        if reaction <= 0.0:
            # Sigh. This is especially true on PyPy on Windows
-            raise greentest.FlakyTestRaceCondition(
+            raise greentest.flaky.FlakyTestRaceCondition(
                "Bad timer resolution (on Windows?), test is useless. Start %s, now %s" % (start, now))
        self.assertGreaterEqual(

--- a/src/greentest/test__doctests.py
+++ b/src/greentest/test__doctests.py
@@ -10,6 +10,7 @@ import unittest
 import gevent
 from gevent import socket
 from greentest import walk_modules
+from greentest import sysinfo
 # Ignore tracebacks: ZeroDivisionError
@@ -36,6 +37,12 @@ class RENormalizingOutputChecker(doctest.OutputChecker):
        return doctest.OutputChecker.check_output(self, want, got, optionflags)
+FORBIDDEN_MODULES = set()
+if sysinfo.WIN:
+    FORBIDDEN_MODULES |= {
+        # Uses commands only found on posix
+        'gevent.subprocess',
+    }
 if __name__ == '__main__':
    cwd = os.getcwd()
@@ -53,6 +60,8 @@ if __name__ == '__main__':
        def add_module(name, path):
            if allowed_modules and name not in allowed_modules:
                return
+            if name in FORBIDDEN_MODULES:
+                return
            modules.add((name, path))
        for path, module in walk_modules():

--- a/src/greentest/test__example_echoserver.py
+++ b/src/greentest/test__example_echoserver.py
@@ -3,6 +3,7 @@ import greentest
 import gevent
 from greentest import util
+from greentest import params
 class Test(util.TestServer):
    server = 'echoserver.py'
@@ -14,7 +15,7 @@ class Test(util.TestServer):
            else:
                kwargs = {'bufsize': 1}
            kwargs['mode'] = 'rb'
-            conn = create_connection(('127.0.0.1', 16000))
+            conn = create_connection((params.DEFAULT_LOCAL_HOST_ADDR, 16000))
            conn.settimeout(greentest.DEFAULT_XPC_SOCKET_TIMEOUT)
            rfile = conn.makefile(**kwargs)

--- a/src/greentest/test__issue600.py
+++ b/src/greentest/test__issue600.py
 # Make sure that libev child watchers, implicitly installed through the use
 # of subprocess, do not cause waitpid() to fail to poll for processes.
 # NOTE: This was only reproducible under python 2.
+from __future__ import print_function
 import gevent
 from gevent import monkey
 monkey.patch_all()
 import sys
 from multiprocessing import Process
-from gevent.subprocess import Popen, PIPE
+from subprocess import Popen, PIPE
+import greentest
-def test_invoke():
+def f(sleep_sec):
-    # Run a subprocess through Popen to make sure
+    gevent.sleep(sleep_sec)
-    # libev is handling SIGCHLD. This could *probably* be simplified to use
-    # just hub.loop.install_sigchld
-    p = Popen([sys.executable, '-V'], stdout=PIPE, stderr=PIPE)
-    gevent.sleep(0)
-    p.communicate()
-    gevent.sleep(0)
-def f(sleep_sec):
+class TestIssue600(greentest.TestCase):
-    gevent.sleep(sleep_sec)
+    __timeout__ = greentest.LARGE_TIMEOUT
-def test_process():
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
-    # Launch
+    def test_invoke(self):
-    p = Process(target=f, args=(1.0,))
+        # Run a subprocess through Popen to make sure
-    p.start()
+        # libev is handling SIGCHLD. This could *probably* be simplified to use
+        # just hub.loop.install_sigchld
-    with gevent.Timeout(3):
+        p = Popen([sys.executable, '-V'], stdout=PIPE, stderr=PIPE)
-        # Poll for up to 10 seconds. If the bug exists,
+        gevent.sleep(0)
-        # this will timeout because our subprocess should
+        p.communicate()
-        # be long gone by now
+        gevent.sleep(0)
-        p.join(10)
+    def test_process(self):
+        # Launch
+        p = Process(target=f, args=(0.5,))
+        p.start()
+        with gevent.Timeout(3):
+            # Poll for up to 10 seconds. If the bug exists,
+            # this will timeout because our subprocess should
+            # be long gone by now
+            p.join(10)
-if __name__ == '__main__':
-    # do a subprocess open
-    test_invoke()
-    test_process()
+if __name__ == '__main__':
+    greentest.main()
--- a/src/greentest/test__refcount.py
+++ b/src/greentest/test__refcount.py
@@ -110,7 +110,7 @@ def run_interaction(run_client):
    #s.close()
    w = weakref.ref(s._sock)
    s.close()
-    if greentest.RUNNING_ON_APPVEYOR:
+    if greentest.WIN:
        # The background thread may not have even had a chance to run
        # yet, sleep again to be sure it does. Otherwise there could be
        # strong refs to the socket still around.
@@ -137,7 +137,7 @@ def run_and_check(run_client):
        raise AssertionError('server should be dead by now')
-@greentest.skipOnAppVeyor("Often fail with timeouts; not sure why.")
+@greentest.skipOnAppVeyor("Often fail with timeouts or force closed connections; not sure why.")
 @greentest.skipOnPyPy3OnCI("Often fails with timeouts; not sure why.")
 class Test(greentest.TestCase):

--- a/src/greentest/test__subprocess.py
+++ b/src/greentest/test__subprocess.py
@@ -69,7 +69,7 @@ class Test(greentest.TestCase):
        num_after = greentest.get_number_open_files()
        self.assertEqual(num_before, num_after)
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_communicate(self):
        p = subprocess.Popen([sys.executable, "-W", "ignore",
                              "-c",
@@ -113,6 +113,7 @@ class Test(greentest.TestCase):
        self.assertEqual(stderr,
                         'pineapple\n\xff\xff\xf2\xf9\n')
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_universal1(self):
        p = subprocess.Popen([sys.executable, "-c",
                              'import sys,os;' + SETBINARY +
@@ -148,6 +149,7 @@ class Test(greentest.TestCase):
        finally:
            p.stdout.close()
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_universal2(self):
        p = subprocess.Popen([sys.executable, "-c",
                              'import sys,os;' + SETBINARY +
@@ -213,6 +215,7 @@ class Test(greentest.TestCase):
            else:
                raise AssertionError('must fail with ENOENT')
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_check_output_keyword_error(self):
        try:
            subprocess.check_output([sys.executable, '-c', 'import sys; sys.exit(44)'])
@@ -261,6 +264,7 @@ class Test(greentest.TestCase):
        test_subprocess_in_native_thread.ignore_leakcheck = True
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def __test_no_output(self, kwargs, kind):
        proc = subprocess.Popen([sys.executable, '-c', 'pass'],
                                stdout=subprocess.PIPE,
@@ -327,16 +331,19 @@ class RunFuncTestCase(greentest.TestCase):
        with self.assertRaises(subprocess.TimeoutExpired):
            self.run_python("while True: pass", timeout=0.0001)
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_capture_stdout(self):
        # capture stdout with zero return code
        cp = self.run_python("print('BDFL')", stdout=subprocess.PIPE)
        self.assertIn(b'BDFL', cp.stdout)
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_capture_stderr(self):
        cp = self.run_python("import sys; sys.stderr.write('BDFL')",
                             stderr=subprocess.PIPE)
        self.assertIn(b'BDFL', cp.stderr)
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_check_output_stdin_arg(self):
        # run() can be called with stdin set to a file
        with tempfile.TemporaryFile() as tf:
@@ -347,6 +354,7 @@ class RunFuncTestCase(greentest.TestCase):
                stdin=tf, stdout=subprocess.PIPE)
            self.assertIn(b'PEAR', cp.stdout)
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_check_output_input_arg(self):
        # check_output() can be called with input set to a string
        cp = self.run_python(
@@ -354,6 +362,7 @@ class RunFuncTestCase(greentest.TestCase):
            input=b'pear', stdout=subprocess.PIPE)
        self.assertIn(b'PEAR', cp.stdout)
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_check_output_stdin_with_input_arg(self):
        # run() refuses to accept 'stdin' with 'input'
        with tempfile.TemporaryFile() as tf:
@@ -366,6 +375,7 @@ class RunFuncTestCase(greentest.TestCase):
            self.assertIn('stdin', c.exception.args[0])
            self.assertIn('input', c.exception.args[0])
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_check_output_timeout(self):
        with self.assertRaises(subprocess.TimeoutExpired) as c:
            self.run_python(

--- a/src/greentest/test__threadpool.py
+++ b/src/greentest/test__threadpool.py
+from __future__ import print_function
 import sys
 from time import time, sleep
 import contextlib
@@ -60,7 +61,7 @@ class PoolBasicTests(TestCase):
        pool.apply_async(r.append, (4, ))
        self.assertEqual(r, [1])
        gevent.sleep(0.01)
-        self.assertEqual(sorted(r), [1, 2, 3, 4])
+        self.assertEqualFlakyRaceCondition(sorted(r), [1, 2, 3, 4])
    def test_apply(self):
        self.pool = pool = ThreadPool(1)
@@ -143,6 +144,14 @@ class _AbstractPoolTest(TestCase):
        del self.pool
        del pmap
+SMALL_RANGE = 10
+LARGE_RANGE = 1000
+if greentest.PYPY and greentest.WIN:
+    # PyPy 5.9 is *really* slow at spawning or switching between threads on Windows
+    # Tests that happen instantaneously on other platforms
+    # time out due to the overhead
+    LARGE_RANGE = 50
 class TestPool(_AbstractPoolTest):
@@ -155,68 +164,70 @@ class TestPool(_AbstractPoolTest):
        res = self.pool.apply_async(sqr, (7, TIMEOUT1,))
        get = TimingWrapper(res.get)
        self.assertEqual(get(), 49)
-        self.assertAlmostEqual(get.elapsed, TIMEOUT1, 1)
+        self.assertTimeoutAlmostEqual(get.elapsed, TIMEOUT1, 1)
    def test_async_callback(self):
        result = []
        res = self.pool.apply_async(sqr, (7, TIMEOUT1,), callback=lambda x: result.append(x))
        get = TimingWrapper(res.get)
        self.assertEqual(get(), 49)
-        self.assertAlmostEqual(get.elapsed, TIMEOUT1, 1)
+        self.assertTimeoutAlmostEqual(get.elapsed, TIMEOUT1, 1)
-        gevent.sleep(0)  # let's the callback run
+        gevent.sleep(0)  # lets the callback run
        assert result == [49], result
    def test_async_timeout(self):
        res = self.pool.apply_async(sqr, (6, TIMEOUT2 + 0.2))
        get = TimingWrapper(res.get)
        self.assertRaises(gevent.Timeout, get, timeout=TIMEOUT2)
-        self.assertAlmostEqual(get.elapsed, TIMEOUT2, 1)
+        self.assertTimeoutAlmostEqual(get.elapsed, TIMEOUT2, 1)
        self.pool.join()
-    def test_imap(self):
+    def test_imap_list_small(self):
-        it = self.pool.imap(sqr, range(10))
+        it = self.pool.imap(sqr, range(SMALL_RANGE))
-        self.assertEqual(list(it), list(map(sqr, range(10))))
+        self.assertEqual(list(it), list(map(sqr, range(SMALL_RANGE))))
-        it = self.pool.imap(sqr, range(10))
+    def test_imap_it_small(self):
-        for i in range(10):
+        it = self.pool.imap(sqr, range(SMALL_RANGE))
+        for i in range(SMALL_RANGE):
            self.assertEqual(six.advance_iterator(it), i * i)
        self.assertRaises(StopIteration, lambda: six.advance_iterator(it))
-        it = self.pool.imap(sqr, range(1000))
+    def test_imap_it_large(self):
-        for i in range(1000):
+        it = self.pool.imap(sqr, range(LARGE_RANGE))
+        for i in range(LARGE_RANGE):
            self.assertEqual(six.advance_iterator(it), i * i)
        self.assertRaises(StopIteration, lambda: six.advance_iterator(it))
    def test_imap_gc(self):
-        it = self.pool.imap(sqr, range(10))
+        it = self.pool.imap(sqr, range(SMALL_RANGE))
-        for i in range(10):
+        for i in range(SMALL_RANGE):
            self.assertEqual(six.advance_iterator(it), i * i)
            gc.collect()
        self.assertRaises(StopIteration, lambda: six.advance_iterator(it))
    def test_imap_unordered_gc(self):
-        it = self.pool.imap_unordered(sqr, range(10))
+        it = self.pool.imap_unordered(sqr, range(SMALL_RANGE))
        result = []
-        for i in range(10):
+        for i in range(SMALL_RANGE):
            result.append(six.advance_iterator(it))
            gc.collect()
        self.assertRaises(StopIteration, lambda: six.advance_iterator(it))
-        self.assertEqual(sorted(result), [x * x for x in range(10)])
+        self.assertEqual(sorted(result), [x * x for x in range(SMALL_RANGE)])
    def test_imap_random(self):
-        it = self.pool.imap(sqr_random_sleep, range(10))
+        it = self.pool.imap(sqr_random_sleep, range(SMALL_RANGE))
-        self.assertEqual(list(it), list(map(sqr, range(10))))
+        self.assertEqual(list(it), list(map(sqr, range(SMALL_RANGE))))
    def test_imap_unordered(self):
-        it = self.pool.imap_unordered(sqr, range(1000))
+        it = self.pool.imap_unordered(sqr, range(LARGE_RANGE))
-        self.assertEqual(sorted(it), list(map(sqr, range(1000))))
+        self.assertEqual(sorted(it), list(map(sqr, range(LARGE_RANGE))))
-        it = self.pool.imap_unordered(sqr, range(1000))
+        it = self.pool.imap_unordered(sqr, range(LARGE_RANGE))
-        self.assertEqual(sorted(it), list(map(sqr, range(1000))))
+        self.assertEqual(sorted(it), list(map(sqr, range(LARGE_RANGE))))
    def test_imap_unordered_random(self):
-        it = self.pool.imap_unordered(sqr_random_sleep, range(10))
+        it = self.pool.imap_unordered(sqr_random_sleep, range(SMALL_RANGE))
-        self.assertEqual(sorted(it), list(map(sqr, range(10))))
+        self.assertEqual(sorted(it), list(map(sqr, range(SMALL_RANGE))))
    def test_terminate(self):
        size = self.size or 10
@@ -374,7 +385,7 @@ class TestMaxsize(TestCase):
        self.assertEqual(pool.size, 3)
        pool.maxsize = 0
        gevent.sleep(0.2)
-        self.assertEqual(pool.size, 0)
+        self.assertEqualFlakyRaceCondition(pool.size, 0)
 class TestSize(TestCase):

--- a/src/greentest/test_threading_2.py
+++ b/src/greentest/test_threading_2.py
@@ -339,6 +339,7 @@ class ThreadTests(unittest.TestCase):
            """ % setup_3])
        self.assertEqual(rc, 42)
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_join_nondaemon_on_shutdown(self):
        # Issue 1722344
        # Raising SystemExit skipped threading._shutdown
@@ -439,6 +440,7 @@ class ThreadJoinOnShutdown(unittest.TestCase):
        self.assertNotEqual(rc, 2, b"interpreter was blocked")
        self.assertEqual(rc, 0, b"Unexpected error")
+    @greentest.skipOnLibuvOnPyPyOnWin("hangs")
    def test_1_join_on_shutdown(self):
        # The usual case: on exit, wait for a non-daemon thread
        script = """if 1:
@@ -594,7 +596,6 @@ def main():
    )
 if __name__ == "__main__":
-    import greentest
    if greentest.PYPY3 and greentest.RUNNING_ON_CI:
        print("SKIPPED: Timeout on PyPy3 on Travis")
    else: