コード例 #1
0
ファイル: test__socket_close.py プロジェクト: gevent/gevent
        receiver = gevent.spawn(sock.recv, 25)
        try:
            gevent.sleep(0.001)
            sock.close()
            receiver.join(timeout=0.1)
            self.assertTrue(receiver.ready(), receiver)
            self.assertEqual(receiver.value, None)
            self.assertIsInstance(receiver.exception, socket.error)
            self.assertEqual(receiver.exception.errno, socket.EBADF)
        finally:
            receiver.kill()

    # XXX: This is possibly due to the bad behaviour of small sleeps?
    # The timeout is the global test timeout, 10s
    @greentest.skipOnLibuvOnCI("Sometimes randomly times out")
    def test_recv_twice(self):
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect((greentest.DEFAULT_CONNECT_HOST, self.server.server_port))
        receiver = gevent.spawn(sock.recv, 25)
        try:
            gevent.sleep(0.001)
            self.assertRaises(AssertionError, sock.recv, 25)
            self.assertRaises(AssertionError, sock.recv, 25)
        finally:
            receiver.kill()
            sock.close()


if __name__ == '__main__':
    greentest.main()
コード例 #2
0
import unittest
import subprocess
import os

from gevent import testing as greentest


@unittest.skipUnless(greentest.resolver_dnspython_available(),
                     "dnspython not available")
class TestDnsPython(unittest.TestCase):
    def _run_one(self, mod_name):
        cmd = [sys.executable, '-m', 'gevent.tests.monkey_package.' + mod_name]

        env = dict(os.environ)
        env['GEVENT_RESOLVER'] = 'dnspython'

        output = subprocess.check_output(cmd, env=env)
        self.assertIn(b'_g_patched_module_dns', output)
        self.assertNotIn(b'_g_patched_module_dns.rdtypes', output)
        return output

    def test_import_dns_no_monkey_patch(self):
        self._run_one('issue1526_no_monkey')

    def test_import_dns_with_monkey_patch(self):
        self._run_one('issue1526_with_monkey')


if __name__ == '__main__':
    greentest.main()
コード例 #3
0
ファイル: test__execmodules.py プロジェクト: handwriter/ufo

class TestExec(unittest.TestCase):
    pass


def make_exec_test(path, module):
    def test(_):
        with open(path, 'rb') as f:
            src = f.read()
        with warnings.catch_warnings():
            warnings.simplefilter('ignore', DeprecationWarning)
            six.exec_(src, {'__file__': path})

    name = "test_" + module.replace(".", "_")
    test.__name__ = name
    setattr(TestExec, name, test)


def make_all_tests():
    for path, module in walk_modules(recursive=True):
        if module.endswith(NON_APPLICABLE_SUFFIXES):
            continue
        make_exec_test(path, module)


make_all_tests()

if __name__ == '__main__':
    main()
コード例 #4
0
ファイル: test__execmodules.py プロジェクト: gevent/gevent
            src = f.read()
        with warnings.catch_warnings():
            warnings.simplefilter('ignore', DeprecationWarning)
            try:
                six.exec_(src, {'__file__': path})
            except ImportError:
                if module in modules.OPTIONAL_MODULES:
                    raise unittest.SkipTest("Unable to import optional module %s" % module)
                raise

    name = "test_" + module.replace(".", "_")
    test.__name__ = name
    return test

def make_all_tests(cls):
    for path, module in modules.walk_modules(recursive=True, check_optional=False):
        if module.endswith(NON_APPLICABLE_SUFFIXES):
            continue
        test = make_exec_test(path, module)
        setattr(cls, test.__name__, test)
    return cls


@make_all_tests
class Test(unittest.TestCase):
    pass


if __name__ == '__main__':
    main()
コード例 #5
0
from gevent.testing import util
from gevent.testing import main


class Test_udp_client(util.TestServer):

    start_kwargs = {'timeout': 10}
    example = 'udp_client.py'
    example_args = ['Test_udp_client']

    def test(self):
        log = []

        def handle(message, address):
            log.append(message)
            server.sendto(b'reply-from-server', address)

        server = DatagramServer('127.0.0.1:9001', handle)
        server.start()
        try:
            self.run_example()
        finally:
            server.close()
        self.assertEqual(log, [b'Test_udp_client'])


if __name__ == '__main__':
    # Running this following test__example_portforwarder on Appveyor
    # doesn't work in the same process for some reason.
    main()  # pragma: testrunner-no-combine
コード例 #6
0
                        msg="locals() unusable: %s..." % response)

    def test_switch_exc(self):
        from gevent.queue import Queue, Empty

        def bad():
            q = Queue()
            print('switching out, then throwing in')
            try:
                q.get(block=True, timeout=0.1)
            except Empty:
                print("Got Empty")
            print('switching out')
            gevent.sleep(0.1)
            print('switched in')

        with self._make_and_start_server(locals={'bad': bad}) as server:
            with self._create_connection(server) as conn:
                conn.sendall(b'bad()\r\n')
                response = self._wait_for_prompt(conn)
                self._close(conn)

        response = response.replace('\r\n', '\n')
        self.assertEqual(
            'switching out, then throwing in\nGot Empty\nswitching out\nswitched in\n>>> ',
            response)


if __name__ == '__main__':
    greentest.main()  # pragma: testrunner-no-combine
コード例 #7
0
# -*- coding: utf-8 -*-
"""
Tests for ``gevent.threading`` that DO NOT monkey patch. This
allows easy comparison with the standard module.

"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import threading

from gevent import threading as gthreading
from gevent import testing


class TestDummyThread(testing.TestCase):
    def test_name(self):
        # Matches the stdlib.
        # https://github.com/gevent/gevent/issues/1659
        std_dummy = threading._DummyThread()
        gvt_dummy = gthreading._DummyThread()
        self.assertIsNot(type(std_dummy), type(gvt_dummy))

        self.assertStartsWith(std_dummy.name, 'Dummy-')
        self.assertStartsWith(gvt_dummy.name, 'Dummy-')


if __name__ == '__main__':
    testing.main()