Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-31 13:41:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merged default into 3.4 branch. 3.4 branch is now effectively 3.4.1rc1.

Browse source
This commit is contained in:
Larry Hastings 2014-03-16 22:54:05 -07:00
commit 3c5c56f3c0
136 changed files with 1891 additions and 1273 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.hgeol
View file

@ -38,6 +38,8 @@ Lib/test/xmltestdata/* = BIN
Lib/venv/scripts/nt/* = BIN Lib/venv/scripts/nt/* = BIN
Lib/test/coding20731.py = BIN
# All other files (which presumably are human-editable) are "native". # All other files (which presumably are human-editable) are "native".
# This must be the last rule! # This must be the last rule!

5
.hgignore
View file

@ -24,11 +24,6 @@ python-config.py$
reflog.txt$ reflog.txt$
tags$ tags$
Lib/plat-mac/errors.rsrc.df.rsrc Lib/plat-mac/errors.rsrc.df.rsrc
Doc/tools/sphinx/
Doc/tools/docutils/
Doc/tools/jinja/
Doc/tools/jinja2/
Doc/tools/pygments/
Misc/python.pc Misc/python.pc
Misc/python-config.sh$ Misc/python-config.sh$
Modules/Setup$ Modules/Setup$

3
.hgtags
View file

@ -120,6 +120,9 @@ d32442c0e60dfbd71234e807d3d1dedd227495a9 v3.3.3rc2
c3896275c0f61b2510a6c7e6c458a750359a91b8 v3.3.3 c3896275c0f61b2510a6c7e6c458a750359a91b8 v3.3.3
fa92f5f940c6c0d839d7f0611e4b717606504a3c v3.3.4rc1 fa92f5f940c6c0d839d7f0611e4b717606504a3c v3.3.4rc1
7ff62415e4263c432c8acf6e424224209211eadb v3.3.4 7ff62415e4263c432c8acf6e424224209211eadb v3.3.4
9ec811df548ed154a9bf9815383a916d6df31b98 v3.3.5rc1
ca5635efe090f78806188ac2758f9948596aa8b2 v3.3.5rc2
62cf4e77f78564714e7ea3d4bf1479ca1fbd0758 v3.3.5
46535f65e7f3bcdcf176f36d34bc1fed719ffd2b v3.4.0a1 46535f65e7f3bcdcf176f36d34bc1fed719ffd2b v3.4.0a1
9265a2168e2cb2a84785d8717792acc661e6b692 v3.4.0a2 9265a2168e2cb2a84785d8717792acc661e6b692 v3.4.0a2
dd9cdf90a5073510877e9dd5112f8e6cf20d5e89 v3.4.0a3 dd9cdf90a5073510877e9dd5112f8e6cf20d5e89 v3.4.0a3

36
Doc/Makefile
View file

@ -5,7 +5,7 @@
# You can set these variables from the command line. # You can set these variables from the command line.
PYTHON = python PYTHON = python
SVNROOT = http://svn.python.org/projects SPHINXBUILD = sphinx-build
SPHINXOPTS = SPHINXOPTS =
PAPER = PAPER =
SOURCES = SOURCES =
@ -14,14 +14,13 @@ DISTVERSION = $(shell $(PYTHON) tools/sphinxext/patchlevel.py)
ALLSPHINXOPTS = -b $(BUILDER) -d build/doctrees -D latex_paper_size=$(PAPER) \ ALLSPHINXOPTS = -b $(BUILDER) -d build/doctrees -D latex_paper_size=$(PAPER) \
$(SPHINXOPTS) . build/$(BUILDER) $(SOURCES) $(SPHINXOPTS) . build/$(BUILDER) $(SOURCES)
.PHONY: help checkout update build html htmlhelp latex text changes linkcheck \ .PHONY: help build html htmlhelp latex text changes linkcheck \
suspicious coverage doctest pydoc-topics htmlview clean dist check serve \ suspicious coverage doctest pydoc-topics htmlview clean dist check serve \
autobuild-dev autobuild-stable autobuild-dev autobuild-stable
help: help:
@echo "Please use \`make <target>' where <target> is one of" @echo "Please use \`make <target>' where <target> is one of"
@echo " clean to remove build files" @echo " clean to remove build files"
@echo " update to update build tools"
@echo " html to make standalone HTML files" @echo " html to make standalone HTML files"
@echo " htmlhelp to make HTML files and a HTML help project" @echo " htmlhelp to make HTML files and a HTML help project"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@ -37,30 +36,8 @@ help:
@echo " check to run a check for frequent markup errors" @echo " check to run a check for frequent markup errors"
@echo " serve to serve the documentation on the localhost (8000)" @echo " serve to serve the documentation on the localhost (8000)"
# Note: if you update versions here, do the same in make.bat and README.txt build:
checkout: $(SPHINXBUILD) $(ALLSPHINXOPTS)
@if [ ! -d tools/sphinx ]; then \
echo "Checking out Sphinx..."; \
svn checkout $(SVNROOT)/external/Sphinx-1.2/sphinx tools/sphinx; \
fi
@if [ ! -d tools/docutils ]; then \
echo "Checking out Docutils..."; \
svn checkout $(SVNROOT)/external/docutils-0.11/docutils tools/docutils; \
fi
@if [ ! -d tools/jinja2 ]; then \
echo "Checking out Jinja..."; \
svn checkout $(SVNROOT)/external/Jinja-2.3.1/jinja2 tools/jinja2; \
fi
@if [ ! -d tools/pygments ]; then \
echo "Checking out Pygments..."; \
svn checkout $(SVNROOT)/external/Pygments-1.6/pygments tools/pygments; \
fi
update: clean checkout
build: checkout
mkdir -p build/$(BUILDER) build/doctrees
$(PYTHON) tools/sphinx-build.py $(ALLSPHINXOPTS)
@echo @echo
html: BUILDER = html html: BUILDER = html
@ -120,10 +97,6 @@ htmlview: html
clean: clean:
-rm -rf build/* -rm -rf build/*
-rm -rf tools/sphinx
-rm -rf tools/pygments
-rm -rf tools/jinja2
-rm -rf tools/docutils
dist: dist:
rm -rf dist rm -rf dist
@ -184,7 +157,6 @@ serve:
# for development releases: always build # for development releases: always build
autobuild-dev: autobuild-dev:
make update
make dist SPHINXOPTS='-A daily=1 -A versionswitcher=1' make dist SPHINXOPTS='-A daily=1 -A versionswitcher=1'
-make suspicious -make suspicious

62
Doc/README.txt
View file

@ -3,36 +3,34 @@ Python Documentation README
This directory contains the reStructuredText (reST) sources to the Python This directory contains the reStructuredText (reST) sources to the Python
documentation. You don't need to build them yourself, prebuilt versions are documentation. You don't need to build them yourself, prebuilt versions are
available at http://docs.python.org/download/. available at <http://docs.python.org/download/>.
Documentation on the authoring Python documentation, including information about Documentation on the authoring Python documentation, including information about
both style and markup, is available in the "Documenting Python" chapter of the both style and markup, is available in the "Documenting Python" chapter of the
developers guide (http://docs.python.org/devguide/documenting.html). developers guide <http://docs.python.org/devguide/documenting.html>.
There's also a chapter intended to point out differences to
those familiar with the previous docs written in LaTeX.
Building the docs Building the docs
================= =================
You need to have Python 2.4 or higher installed; the toolset used to build the You need to have Sphinx <http://sphinx-doc.org/> installed; it is the toolset
docs is written in Python. It is called *Sphinx*, it is not included in this used to build the docs. It is not included in this tree, but maintained
tree, but maintained separately. Also needed are the docutils, supplying the separately and available from PyPI <http://pypi.python.org/pypi/Sphinx>.
base markup that Sphinx uses, Jinja, a templating engine, and optionally
Pygments, a code highlighter.
Using make Using make
---------- ----------
Luckily, a Makefile has been prepared so that on Unix, provided you have A Makefile has been prepared so that on Unix, provided you have installed
installed Python and Subversion, you can just run :: Sphinx, you can just run ::
make html make html
to check out the necessary toolset in the `tools/` subdirectory and build the to build the HTML output files. To view the generated HTML, point your favorite
HTML output files. To view the generated HTML, point your favorite browser at browser at the top-level index `build/html/index.html` after running "make".
the top-level index `build/html/index.html` after running "make".
On Windows, we try to emulate the Makefile as closely as possible with a
``make.bat`` file.
To use a Python interpreter that's not called ``python``, use the standard To use a Python interpreter that's not called ``python``, use the standard
way to set Makefile variables, using e.g. :: way to set Makefile variables, using e.g. ::
@ -74,43 +72,21 @@ Available make targets are:
`tools/sphinxext/pyspecific.py` -- pydoc needs these to show topic and `tools/sphinxext/pyspecific.py` -- pydoc needs these to show topic and
keyword help. keyword help.
A "make update" updates the Subversion checkouts in `tools/`. * "suspicious", which checks the parsed markup for text that looks like
malformed and thus unconverted reST.
Without make Without make
------------ ------------
You'll need to install the Sphinx package, either by checking it out via :: Install the Sphinx package and its dependencies from PyPI.
svn co http://svn.python.org/projects/external/Sphinx-1.0.7/sphinx tools/sphinx Then, from the ``Docs`` directory, run ::
or by installing it from PyPI. sphinx-build -b<builder> . build/<builder>
Then, you need to install Docutils, either by checking it out via :: where ``<builder>`` is one of html, text, latex, or htmlhelp (for explanations
see the make targets above).
svn co http://svn.python.org/projects/external/docutils-0.6/docutils tools/docutils
or by installing it from http://docutils.sf.net/.
You also need Jinja2, either by checking it out via ::
svn co http://svn.python.org/projects/external/Jinja-2.3.1/jinja2 tools/jinja2
or by installing it from PyPI.
You can optionally also install Pygments, either as a checkout via ::
svn co http://svn.python.org/projects/external/Pygments-1.3.1/pygments tools/pygments
or from PyPI at http://pypi.python.org/pypi/Pygments.
Then, make an output directory, e.g. under `build/`, and run ::
python tools/sphinx-build.py -b<builder> . build/<outputdirectory>
where `<builder>` is one of html, text, latex, or htmlhelp (for explanations see
the make targets above).
Contributing Contributing

6
Doc/library/asyncio-subprocess.rst
View file

@ -107,6 +107,8 @@ Process
The data read is buffered in memory, so do not use this method if the The data read is buffered in memory, so do not use this method if the
data size is large or unlimited. data size is large or unlimited.
This method is a :ref:`coroutine <coroutine>`.
.. method:: kill() .. method:: kill()
Kills the child. On Posix OSs the function sends :py:data:`SIGKILL` to Kills the child. On Posix OSs the function sends :py:data:`SIGKILL` to
@ -129,11 +131,13 @@ Process
to the child. On Windows the Win32 API function to the child. On Windows the Win32 API function
:c:func:`TerminateProcess` is called to stop the child. :c:func:`TerminateProcess` is called to stop the child.
.. method:: wait(self): .. method:: wait():
Wait for child process to terminate. Set and return :attr:`returncode` Wait for child process to terminate. Set and return :attr:`returncode`
attribute. attribute.
This method is a :ref:`coroutine <coroutine>`.
Example Example
------- -------

22
Doc/library/http.client.rst
View file

@ -451,11 +451,25 @@ HTTPConnection Objects
.. method:: HTTPConnection.set_tunnel(host, port=None, headers=None) .. method:: HTTPConnection.set_tunnel(host, port=None, headers=None)
Set the host and the port for HTTP Connect Tunnelling. Normally used when it Set the host and the port for HTTP Connect Tunnelling. This allows running
is required to a HTTPS Connection through a proxy server. the connection through a proxy server.
The headers argument should be a mapping of extra HTTP headers to send The host and port arguments specify the endpoint of the tunneled connection
with the CONNECT request. (i.e. the address included in the CONNECT request, *not* the address of the
proxy server).
The headers argument should be a mapping of extra HTTP headers to send with
the CONNECT request.
For example, to tunnel through a HTTPS proxy server running locally on port
8080, we would pass the address of the proxy to the :class:`HTTPSConnection`
constructor, and the address of the host that we eventually want to reach to
the :meth:`~HTTPConnection.set_tunnel` method::
>>> import http.client
>>> conn = http.client.HTTPSConnection("localhost", 8080)
>>> conn.set_tunnel("www.python.org")
>>> conn.request("HEAD","/index.html")
.. versionadded:: 3.2 .. versionadded:: 3.2

19
Doc/make.bat
View file

@ -1,7 +1,6 @@
@@echo off @@echo off
setlocal setlocal
set SVNROOT=http://svn.python.org/projects
if "%PYTHON%" EQU "" set PYTHON=py -2 if "%PYTHON%" EQU "" set PYTHON=py -2
if "%HTMLHELP%" EQU "" set HTMLHELP=%ProgramFiles%\HTML Help Workshop\hhc.exe if "%HTMLHELP%" EQU "" set HTMLHELP=%ProgramFiles%\HTML Help Workshop\hhc.exe
if "%DISTVERSION%" EQU "" for /f "usebackq" %%v in (`%PYTHON% tools/sphinxext/patchlevel.py`) do set DISTVERSION=%%v if "%DISTVERSION%" EQU "" for /f "usebackq" %%v in (`%PYTHON% tools/sphinxext/patchlevel.py`) do set DISTVERSION=%%v
@ -14,15 +13,11 @@ if "%1" EQU "text" goto build
if "%1" EQU "suspicious" goto build if "%1" EQU "suspicious" goto build
if "%1" EQU "linkcheck" goto build if "%1" EQU "linkcheck" goto build
if "%1" EQU "changes" goto build if "%1" EQU "changes" goto build
if "%1" EQU "checkout" goto checkout
if "%1" EQU "update" goto update
:help :help
set this=%~n0 set this=%~n0
echo HELP echo HELP
echo. echo.
echo %this% checkout
echo %this% update
echo %this% html echo %this% html
echo %this% htmlhelp echo %this% htmlhelp
echo %this% latex echo %this% latex
@ -33,20 +28,6 @@ echo %this% changes
echo. echo.
goto end goto end
:checkout
svn co %SVNROOT%/external/Sphinx-1.2/sphinx tools/sphinx
svn co %SVNROOT%/external/docutils-0.11/docutils tools/docutils
svn co %SVNROOT%/external/Jinja-2.3.1/jinja2 tools/jinja2
svn co %SVNROOT%/external/Pygments-1.6/pygments tools/pygments
goto end
:update
svn update tools/sphinx
svn update tools/docutils
svn update tools/jinja2
svn update tools/pygments
goto end
:build :build
if not exist build mkdir build if not exist build mkdir build
if not exist build\%1 mkdir build\%1 if not exist build\%1 mkdir build\%1

28
Doc/tools/sphinx-build.py
View file

@ -1,28 +0,0 @@
# -*- coding: utf-8 -*-
"""
Sphinx - Python documentation toolchain
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: 2007-2010 by Georg Brandl.
:license: Python license.
"""
import sys
import warnings
# Get rid of UserWarnings reported by pkg_resources.
warnings.filterwarnings('ignore', category=UserWarning, module='jinja2')
if __name__ == '__main__':
if sys.version_info[:3] < (2, 4, 0) or sys.version_info[:3] > (3, 0, 0):
sys.stderr.write("""\
Error: Sphinx needs to be executed with Python 2.4 or newer (not 3.0 though).
(If you run this from the Makefile, you can set the PYTHON variable
to the path of an alternative interpreter executable, e.g.,
``make html PYTHON=python2.5``).
""")
sys.exit(1)
from sphinx import main
sys.exit(main(sys.argv))

22
Doc/tools/sphinxext/pyspecific.py
View file

@ -16,6 +16,7 @@
import sphinx import sphinx
from sphinx.util.nodes import split_explicit_title from sphinx.util.nodes import split_explicit_title
from sphinx.util.compat import Directive
from sphinx.writers.html import HTMLTranslator from sphinx.writers.html import HTMLTranslator
from sphinx.writers.latex import LaTeXTranslator from sphinx.writers.latex import LaTeXTranslator
from sphinx.locale import versionlabels from sphinx.locale import versionlabels
@ -27,7 +28,9 @@
Body.enum.converters['lowerroman'] = \ Body.enum.converters['lowerroman'] = \
Body.enum.converters['upperroman'] = lambda x: None Body.enum.converters['upperroman'] = lambda x: None
if sphinx.__version__[:3] < '1.2': SPHINX11 = sphinx.__version__[:3] < '1.2'
if SPHINX11:
# monkey-patch HTML translator to give versionmodified paragraphs a class # monkey-patch HTML translator to give versionmodified paragraphs a class
def new_visit_versionmodified(self, node): def new_visit_versionmodified(self, node):
self.body.append(self.starttag(node, 'p', CLASS=node['type'])) self.body.append(self.starttag(node, 'p', CLASS=node['type']))
@ -88,8 +91,6 @@ def source_role(typ, rawtext, text, lineno, inliner, options={}, content=[]):
# Support for marking up implementation details # Support for marking up implementation details
from sphinx.util.compat import Directive
class ImplementationDetail(Directive): class ImplementationDetail(Directive):
has_content = True has_content = True
@ -142,10 +143,6 @@ def run(self):
# Support for documenting version of removal in deprecations # Support for documenting version of removal in deprecations
from sphinx.locale import versionlabels
from sphinx.util.compat import Directive
class DeprecatedRemoved(Directive): class DeprecatedRemoved(Directive):
has_content = True has_content = True
required_arguments = 2 required_arguments = 2
@ -171,16 +168,16 @@ def run(self):
messages = [] messages = []
if self.content: if self.content:
self.state.nested_parse(self.content, self.content_offset, node) self.state.nested_parse(self.content, self.content_offset, node)
if len(node):
if isinstance(node[0], nodes.paragraph) and node[0].rawsource: if isinstance(node[0], nodes.paragraph) and node[0].rawsource:
content = nodes.inline(node[0].rawsource, translatable=True) content = nodes.inline(node[0].rawsource, translatable=True)
content.source = node[0].source content.source = node[0].source
content.line = node[0].line content.line = node[0].line
content += node[0].children content += node[0].children
node[0].replace_self(nodes.paragraph('', '', content)) node[0].replace_self(nodes.paragraph('', '', content))
node[0].insert(0, nodes.inline('', '%s: ' % text, if not SPHINX11:
classes=['versionmodified'])) node[0].insert(0, nodes.inline('', '%s: ' % text,
else: classes=['versionmodified']))
elif not SPHINX11:
para = nodes.paragraph('', '', para = nodes.paragraph('', '',
nodes.inline('', '%s.' % text, classes=['versionmodified'])) nodes.inline('', '%s.' % text, classes=['versionmodified']))
node.append(para) node.append(para)
@ -188,6 +185,9 @@ def run(self):
env.note_versionchange('deprecated', version[0], node, self.lineno) env.note_versionchange('deprecated', version[0], node, self.lineno)
return [node] + messages return [node] + messages
# for Sphinx < 1.2
versionlabels['deprecated-removed'] = DeprecatedRemoved._label
# Support for including Misc/NEWS # Support for including Misc/NEWS

2
Include/objimpl.h
View file

@ -265,7 +265,7 @@ extern PyGC_Head *_PyGC_generation0;
#define _PyGCHead_REFS(g) ((g)->gc.gc_refs >> _PyGC_REFS_SHIFT) #define _PyGCHead_REFS(g) ((g)->gc.gc_refs >> _PyGC_REFS_SHIFT)
#define _PyGCHead_SET_REFS(g, v) do { \ #define _PyGCHead_SET_REFS(g, v) do { \
(g)->gc.gc_refs = ((g)->gc.gc_refs & ~_PyGC_REFS_MASK) \ (g)->gc.gc_refs = ((g)->gc.gc_refs & ~_PyGC_REFS_MASK) \
| (v << _PyGC_REFS_SHIFT); \ | (((size_t)(v)) << _PyGC_REFS_SHIFT); \
} while (0) } while (0)
#define _PyGCHead_DECREF(g) ((g)->gc.gc_refs -= 1 << _PyGC_REFS_SHIFT) #define _PyGCHead_DECREF(g) ((g)->gc.gc_refs -= 1 << _PyGC_REFS_SHIFT)

17
Include/pytime.h
View file

@ -53,10 +53,19 @@ do { \
(tv_end.tv_usec - tv_start.tv_usec) * 0.000001) (tv_end.tv_usec - tv_start.tv_usec) * 0.000001)
#ifndef Py_LIMITED_API #ifndef Py_LIMITED_API
typedef enum {
/* Round towards zero. */
_PyTime_ROUND_DOWN=0,
/* Round away from zero. */
_PyTime_ROUND_UP
} _PyTime_round_t;
/* Convert a number of seconds, int or float, to time_t. */ /* Convert a number of seconds, int or float, to time_t. */
PyAPI_FUNC(int) _PyTime_ObjectToTime_t( PyAPI_FUNC(int) _PyTime_ObjectToTime_t(
PyObject *obj, PyObject *obj,
time_t *sec); time_t *sec,
_PyTime_round_t);
/* Convert a time_t to a PyLong. */ /* Convert a time_t to a PyLong. */
PyAPI_FUNC(PyObject *) _PyLong_FromTime_t( PyAPI_FUNC(PyObject *) _PyLong_FromTime_t(
@ -72,7 +81,8 @@ PyAPI_FUNC(time_t) _PyLong_AsTime_t(
PyAPI_FUNC(int) _PyTime_ObjectToTimeval( PyAPI_FUNC(int) _PyTime_ObjectToTimeval(
PyObject *obj, PyObject *obj,
time_t *sec, time_t *sec,
long *usec); long *usec,
_PyTime_round_t);
/* Convert a number of seconds, int or float, to a timespec structure. /* Convert a number of seconds, int or float, to a timespec structure.
nsec is in the range [0; 999999999] and rounded towards zero. nsec is in the range [0; 999999999] and rounded towards zero.
@ -80,7 +90,8 @@ PyAPI_FUNC(int) _PyTime_ObjectToTimeval(
PyAPI_FUNC(int) _PyTime_ObjectToTimespec( PyAPI_FUNC(int) _PyTime_ObjectToTimespec(
PyObject *obj, PyObject *obj,
time_t *sec, time_t *sec,
long *nsec); long *nsec,
_PyTime_round_t);
#endif #endif
/* Dummy to force linking. */ /* Dummy to force linking. */

11
Lib/asyncio/selector_events.py
View file

@ -136,6 +136,8 @@ def _accept_connection(self, protocol_factory, sock,
def add_reader(self, fd, callback, *args): def add_reader(self, fd, callback, *args):
"""Add a reader callback.""" """Add a reader callback."""
if self._selector is None:
raise RuntimeError('Event loop is closed')
handle = events.Handle(callback, args, self) handle = events.Handle(callback, args, self)
try: try:
key = self._selector.get_key(fd) key = self._selector.get_key(fd)
@ -151,6 +153,8 @@ def add_reader(self, fd, callback, *args):
def remove_reader(self, fd): def remove_reader(self, fd):
"""Remove a reader callback.""" """Remove a reader callback."""
if self._selector is None:
return False
try: try:
key = self._selector.get_key(fd) key = self._selector.get_key(fd)
except KeyError: except KeyError:
@ -171,6 +175,8 @@ def remove_reader(self, fd):
def add_writer(self, fd, callback, *args): def add_writer(self, fd, callback, *args):
"""Add a writer callback..""" """Add a writer callback.."""
if self._selector is None:
raise RuntimeError('Event loop is closed')
handle = events.Handle(callback, args, self) handle = events.Handle(callback, args, self)
try: try:
key = self._selector.get_key(fd) key = self._selector.get_key(fd)
@ -186,6 +192,8 @@ def add_writer(self, fd, callback, *args):
def remove_writer(self, fd): def remove_writer(self, fd):
"""Remove a writer callback.""" """Remove a writer callback."""
if self._selector is None:
return False
try: try:
key = self._selector.get_key(fd) key = self._selector.get_key(fd)
except KeyError: except KeyError:
@ -702,8 +710,7 @@ def _write_ready(self):
if self._buffer: if self._buffer:
try: try:
n = self._sock.send(self._buffer) n = self._sock.send(self._buffer)
except (BlockingIOError, InterruptedError, except (BlockingIOError, InterruptedError, ssl.SSLWantWriteError):
ssl.SSLWantWriteError):
n = 0 n = 0
except ssl.SSLWantReadError: except ssl.SSLWantReadError:
n = 0 n = 0

2
Lib/asyncio/tasks.py
View file

@ -325,7 +325,7 @@ def _step(self, value=None, exc=None):
'Task got bad yield: {!r}'.format(result))) 'Task got bad yield: {!r}'.format(result)))
finally: finally:
self.__class__._current_tasks.pop(self._loop) self.__class__._current_tasks.pop(self._loop)
self = None self = None # Needed to break cycles when an exception occurs.
def _wakeup(self, future): def _wakeup(self, future):
try: try:

20
Lib/asyncio/test_utils.py
View file

@ -11,8 +11,7 @@
import tempfile import tempfile
import threading import threading
import time import time
import unittest from unittest import mock
import unittest.mock
from http.server import HTTPServer from http.server import HTTPServer
from wsgiref.simple_server import WSGIRequestHandler, WSGIServer from wsgiref.simple_server import WSGIRequestHandler, WSGIServer
@ -22,10 +21,11 @@
except ImportError: # pragma: no cover except ImportError: # pragma: no cover
ssl = None ssl = None
from . import tasks
from . import base_events from . import base_events
from . import events from . import events
from . import futures
from . import selectors from . import selectors
from . import tasks
if sys.platform == 'win32': # pragma: no cover if sys.platform == 'win32': # pragma: no cover
@ -53,18 +53,14 @@ def once():
gen.close() gen.close()
def run_until(loop, pred, timeout=None): def run_until(loop, pred, timeout=30):
if timeout is not None: deadline = time.time() + timeout
deadline = time.time() + timeout
while not pred(): while not pred():
if timeout is not None: if timeout is not None:
timeout = deadline - time.time() timeout = deadline - time.time()
if timeout <= 0: if timeout <= 0:
return False raise futures.TimeoutError()
loop.run_until_complete(tasks.sleep(timeout, loop=loop)) loop.run_until_complete(tasks.sleep(0.001, loop=loop))
else:
run_briefly(loop)
return True
def run_once(loop): def run_once(loop):
@ -362,7 +358,7 @@ def _write_to_self(self):
def MockCallback(**kwargs): def MockCallback(**kwargs):
return unittest.mock.Mock(spec=['__call__'], **kwargs) return mock.Mock(spec=['__call__'], **kwargs)
class MockPattern(str): class MockPattern(str):

20
Lib/asyncio/windows_events.py
View file

@ -213,7 +213,7 @@ def recv(self, conn, nbytes, flags=0):
else: else:
ov.ReadFile(conn.fileno(), nbytes) ov.ReadFile(conn.fileno(), nbytes)
def finish(trans, key, ov): def finish_recv(trans, key, ov):
try: try:
return ov.getresult() return ov.getresult()
except OSError as exc: except OSError as exc:
@ -222,7 +222,7 @@ def finish(trans, key, ov):
else: else:
raise raise
return self._register(ov, conn, finish) return self._register(ov, conn, finish_recv)
def send(self, conn, buf, flags=0): def send(self, conn, buf, flags=0):
self._register_with_iocp(conn) self._register_with_iocp(conn)
@ -232,7 +232,7 @@ def send(self, conn, buf, flags=0):
else: else:
ov.WriteFile(conn.fileno(), buf) ov.WriteFile(conn.fileno(), buf)
def finish(trans, key, ov): def finish_send(trans, key, ov):
try: try:
return ov.getresult() return ov.getresult()
except OSError as exc: except OSError as exc:
@ -241,7 +241,7 @@ def finish(trans, key, ov):
else: else:
raise raise
return self._register(ov, conn, finish) return self._register(ov, conn, finish_send)
def accept(self, listener): def accept(self, listener):
self._register_with_iocp(listener) self._register_with_iocp(listener)
@ -300,17 +300,17 @@ def accept_pipe(self, pipe):
ov = _overlapped.Overlapped(NULL) ov = _overlapped.Overlapped(NULL)
ov.ConnectNamedPipe(pipe.fileno()) ov.ConnectNamedPipe(pipe.fileno())
def finish(trans, key, ov): def finish_accept_pipe(trans, key, ov):
ov.getresult() ov.getresult()
return pipe return pipe
return self._register(ov, pipe, finish) return self._register(ov, pipe, finish_accept_pipe)
def connect_pipe(self, address): def connect_pipe(self, address):
ov = _overlapped.Overlapped(NULL) ov = _overlapped.Overlapped(NULL)
ov.WaitNamedPipeAndConnect(address, self._iocp, ov.address) ov.WaitNamedPipeAndConnect(address, self._iocp, ov.address)
def finish(err, handle, ov): def finish_connect_pipe(err, handle, ov):
# err, handle were arguments passed to PostQueuedCompletionStatus() # err, handle were arguments passed to PostQueuedCompletionStatus()
# in a function run in a thread pool. # in a function run in a thread pool.
if err == _overlapped.ERROR_SEM_TIMEOUT: if err == _overlapped.ERROR_SEM_TIMEOUT:
@ -323,7 +323,7 @@ def finish(err, handle, ov):
else: else:
return windows_utils.PipeHandle(handle) return windows_utils.PipeHandle(handle)
return self._register(ov, None, finish, wait_for_post=True) return self._register(ov, None, finish_connect_pipe, wait_for_post=True)
def wait_for_handle(self, handle, timeout=None): def wait_for_handle(self, handle, timeout=None):
if timeout is None: if timeout is None:
@ -339,7 +339,7 @@ def wait_for_handle(self, handle, timeout=None):
handle, self._iocp, ov.address, ms) handle, self._iocp, ov.address, ms)
f = _WaitHandleFuture(wh, loop=self._loop) f = _WaitHandleFuture(wh, loop=self._loop)
def finish(trans, key, ov): def finish_wait_for_handle(trans, key, ov):
if not f.cancelled(): if not f.cancelled():
try: try:
_overlapped.UnregisterWait(wh) _overlapped.UnregisterWait(wh)
@ -355,7 +355,7 @@ def finish(trans, key, ov):
return (_winapi.WaitForSingleObject(handle, 0) == return (_winapi.WaitForSingleObject(handle, 0) ==
_winapi.WAIT_OBJECT_0) _winapi.WAIT_OBJECT_0)
self._cache[ov.address] = (f, ov, None, finish) self._cache[ov.address] = (f, ov, None, finish_wait_for_handle)
return f return f
def _register_with_iocp(self, obj): def _register_with_iocp(self, obj):

17
Lib/asyncio/windows_utils.py
View file

@ -36,12 +36,25 @@ def socketpair(family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0):
Origin: https://gist.github.com/4325783, by Geert Jansen. Public domain. Origin: https://gist.github.com/4325783, by Geert Jansen. Public domain.
""" """
if family == socket.AF_INET:
host = '127.0.0.1'
elif family == socket.AF_INET6:
host = '::1'
else:
raise ValueError("Ony AF_INET and AF_INET6 socket address families "
"are supported")
if type != socket.SOCK_STREAM:
raise ValueError("Only SOCK_STREAM socket type is supported")
if proto != 0:
raise ValueError("Only protocol zero is supported")
# We create a connected TCP socket. Note the trick with setblocking(0) # We create a connected TCP socket. Note the trick with setblocking(0)
# that prevents us from having to create a thread. # that prevents us from having to create a thread.
lsock = socket.socket(family, type, proto) lsock = socket.socket(family, type, proto)
lsock.bind(('localhost', 0)) lsock.bind((host, 0))
lsock.listen(1) lsock.listen(1)
addr, port = lsock.getsockname() # On IPv6, ignore flow_info and scope_id
addr, port = lsock.getsockname()[:2]
csock = socket.socket(family, type, proto) csock = socket.socket(family, type, proto)
csock.setblocking(False) csock.setblocking(False)
try: try:

1
Lib/base64.py
View file

@ -9,7 +9,6 @@
import re import re
import struct import struct
import binascii import binascii
import itertools
__all__ = [ __all__ = [

2
Lib/copy.py
View file

@ -110,7 +110,7 @@ def copy(x):
def _copy_immutable(x): def _copy_immutable(x):
return x return x
for t in (type(None), int, float, bool, str, tuple, for t in (type(None), int, float, bool, str, tuple,
frozenset, type, range, bytes, frozenset, type, range,
types.BuiltinFunctionType, type(Ellipsis), types.BuiltinFunctionType, type(Ellipsis),
types.FunctionType, weakref.ref): types.FunctionType, weakref.ref):
d[t] = _copy_immutable d[t] = _copy_immutable

2
Lib/ctypes/test/test_bitfields.py
View file

@ -207,7 +207,7 @@ def test_mixed_2(self):
class X(Structure): class X(Structure):
_fields_ = [("a", c_byte, 4), _fields_ = [("a", c_byte, 4),
("b", c_int, 32)] ("b", c_int, 32)]
self.assertEqual(sizeof(X), sizeof(c_int)*2) self.assertEqual(sizeof(X), alignment(c_int)+sizeof(c_int))
def test_mixed_3(self): def test_mixed_3(self):
class X(Structure): class X(Structure):

18
Lib/ctypes/test/test_structures.py
View file

@ -83,7 +83,7 @@ class X(Structure):
class Y(Structure): class Y(Structure):
_fields_ = [("x", c_char * 3), _fields_ = [("x", c_char * 3),
("y", c_int)] ("y", c_int)]
self.assertEqual(alignment(Y), calcsize("i")) self.assertEqual(alignment(Y), alignment(c_int))
self.assertEqual(sizeof(Y), calcsize("3si")) self.assertEqual(sizeof(Y), calcsize("3si"))
class SI(Structure): class SI(Structure):
@ -175,23 +175,23 @@ class X(Structure):
self.assertEqual(sizeof(X), 10) self.assertEqual(sizeof(X), 10)
self.assertEqual(X.b.offset, 2) self.assertEqual(X.b.offset, 2)
class X(Structure):
_fields_ = [("a", c_byte),
("b", c_longlong)]
_pack_ = 4
self.assertEqual(sizeof(X), 12)
self.assertEqual(X.b.offset, 4)
import struct import struct
longlong_size = struct.calcsize("q") longlong_size = struct.calcsize("q")
longlong_align = struct.calcsize("bq") - longlong_size longlong_align = struct.calcsize("bq") - longlong_size
class X(Structure):
_fields_ = [("a", c_byte),
("b", c_longlong)]
_pack_ = 4
self.assertEqual(sizeof(X), min(4, longlong_align) + longlong_size)
self.assertEqual(X.b.offset, min(4, longlong_align))
class X(Structure): class X(Structure):
_fields_ = [("a", c_byte), _fields_ = [("a", c_byte),
("b", c_longlong)] ("b", c_longlong)]
_pack_ = 8 _pack_ = 8
self.assertEqual(sizeof(X), longlong_align + longlong_size) self.assertEqual(sizeof(X), min(8, longlong_align) + longlong_size)
self.assertEqual(X.b.offset, min(8, longlong_align)) self.assertEqual(X.b.offset, min(8, longlong_align))

7
Lib/distutils/core.py
View file

@ -11,7 +11,6 @@
from distutils.debug import DEBUG from distutils.debug import DEBUG
from distutils.errors import * from distutils.errors import *
from distutils.util import grok_environment_error
# Mainly import these so setup scripts can "from distutils.core import" them. # Mainly import these so setup scripts can "from distutils.core import" them.
from distutils.dist import Distribution from distutils.dist import Distribution
@ -150,13 +149,11 @@ class found in 'cmdclass' is used in place of the default, which is
except KeyboardInterrupt: except KeyboardInterrupt:
raise SystemExit("interrupted") raise SystemExit("interrupted")
except OSError as exc: except OSError as exc:
error = grok_environment_error(exc)
if DEBUG: if DEBUG:
sys.stderr.write(error + "\n") sys.stderr.write("error: %s\n" % (exc,))
raise raise
else: else:
raise SystemExit(error) raise SystemExit("error: %s" % (exc,))
except (DistutilsError, except (DistutilsError,
CCompilerError) as msg: CCompilerError) as msg:

6
Lib/distutils/dir_util.py
View file

@ -2,7 +2,7 @@
Utility functions for manipulating directories and directory trees.""" Utility functions for manipulating directories and directory trees."""
import os, sys import os
import errno import errno
from distutils.errors import DistutilsFileError, DistutilsInternalError from distutils.errors import DistutilsFileError, DistutilsInternalError
from distutils import log from distutils import log
@ -182,7 +182,6 @@ def remove_tree(directory, verbose=1, dry_run=0):
Any errors are ignored (apart from being reported to stdout if 'verbose' Any errors are ignored (apart from being reported to stdout if 'verbose'
is true). is true).
""" """
from distutils.util import grok_environment_error
global _path_created global _path_created
if verbose >= 1: if verbose >= 1:
@ -199,8 +198,7 @@ def remove_tree(directory, verbose=1, dry_run=0):
if abspath in _path_created: if abspath in _path_created:
del _path_created[abspath] del _path_created[abspath]
except OSError as exc: except OSError as exc:
log.warn(grok_environment_error( log.warn("error removing %s: %s", directory, exc)
exc, "error removing %s: " % directory))
def ensure_relative(path): def ensure_relative(path):
"""Take the full path 'path', and make it a relative path. """Take the full path 'path', and make it a relative path.

55
Lib/distutils/spawn.py
View file

@ -10,6 +10,7 @@
import os import os
from distutils.errors import DistutilsPlatformError, DistutilsExecError from distutils.errors import DistutilsPlatformError, DistutilsExecError
from distutils.debug import DEBUG
from distutils import log from distutils import log
def spawn(cmd, search_path=1, verbose=0, dry_run=0): def spawn(cmd, search_path=1, verbose=0, dry_run=0):
@ -28,10 +29,15 @@ def spawn(cmd, search_path=1, verbose=0, dry_run=0):
Raise DistutilsExecError if running the program fails in any way; just Raise DistutilsExecError if running the program fails in any way; just
return on success. return on success.
""" """
# cmd is documented as a list, but just in case some code passes a tuple
# in, protect our %-formatting code against horrible death
cmd = list(cmd)
if os.name == 'posix': if os.name == 'posix':
_spawn_posix(cmd, search_path, dry_run=dry_run) _spawn_posix(cmd, search_path, dry_run=dry_run)
elif os.name == 'nt': elif os.name == 'nt':
_spawn_nt(cmd, search_path, dry_run=dry_run) _spawn_nt(cmd, search_path, dry_run=dry_run)
elif os.name == 'os2':
_spawn_os2(cmd, search_path, dry_run=dry_run)
else: else:
raise DistutilsPlatformError( raise DistutilsPlatformError(
"don't know how to spawn programs on platform '%s'" % os.name) "don't know how to spawn programs on platform '%s'" % os.name)
@ -65,12 +71,16 @@ def _spawn_nt(cmd, search_path=1, verbose=0, dry_run=0):
rc = os.spawnv(os.P_WAIT, executable, cmd) rc = os.spawnv(os.P_WAIT, executable, cmd)
except OSError as exc: except OSError as exc:
# this seems to happen when the command isn't found # this seems to happen when the command isn't found
if not DEBUG:
cmd = executable
raise DistutilsExecError( raise DistutilsExecError(
"command '%s' failed: %s" % (cmd[0], exc.args[-1])) "command %r failed: %s" % (cmd, exc.args[-1]))
if rc != 0: if rc != 0:
# and this reflects the command running but failing # and this reflects the command running but failing
if not DEBUG:
cmd = executable
raise DistutilsExecError( raise DistutilsExecError(
"command '%s' failed with exit status %d" % (cmd[0], rc)) "command %r failed with exit status %d" % (cmd, rc))
if sys.platform == 'darwin': if sys.platform == 'darwin':
from distutils import sysconfig from distutils import sysconfig
@ -81,8 +91,9 @@ def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
log.info(' '.join(cmd)) log.info(' '.join(cmd))
if dry_run: if dry_run:
return return
executable = cmd[0]
exec_fn = search_path and os.execvp or os.execv exec_fn = search_path and os.execvp or os.execv
exec_args = [cmd[0], cmd] env = None
if sys.platform == 'darwin': if sys.platform == 'darwin':
global _cfg_target, _cfg_target_split global _cfg_target, _cfg_target_split
if _cfg_target is None: if _cfg_target is None:
@ -103,17 +114,23 @@ def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
env = dict(os.environ, env = dict(os.environ,
MACOSX_DEPLOYMENT_TARGET=cur_target) MACOSX_DEPLOYMENT_TARGET=cur_target)
exec_fn = search_path and os.execvpe or os.execve exec_fn = search_path and os.execvpe or os.execve
exec_args.append(env)
pid = os.fork() pid = os.fork()
if pid == 0: # in the child if pid == 0: # in the child
try: try:
exec_fn(*exec_args) if env is None:
exec_fn(executable, cmd)
else:
exec_fn(executable, cmd, env)
except OSError as e: except OSError as e:
sys.stderr.write("unable to execute %s: %s\n" if not DEBUG:
% (cmd[0], e.strerror)) cmd = executable
sys.stderr.write("unable to execute %r: %s\n"
% (cmd, e.strerror))
os._exit(1) os._exit(1)
sys.stderr.write("unable to execute %s for unknown reasons" % cmd[0]) if not DEBUG:
cmd = executable
sys.stderr.write("unable to execute %r for unknown reasons" % cmd)
os._exit(1) os._exit(1)
else: # in the parent else: # in the parent
# Loop until the child either exits or is terminated by a signal # Loop until the child either exits or is terminated by a signal
@ -125,26 +142,34 @@ def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
import errno import errno
if exc.errno == errno.EINTR: if exc.errno == errno.EINTR:
continue continue
if not DEBUG:
cmd = executable
raise DistutilsExecError( raise DistutilsExecError(
"command '%s' failed: %s" % (cmd[0], exc.args[-1])) "command %r failed: %s" % (cmd, exc.args[-1]))
if os.WIFSIGNALED(status): if os.WIFSIGNALED(status):
if not DEBUG:
cmd = executable
raise DistutilsExecError( raise DistutilsExecError(
"command '%s' terminated by signal %d" "command %r terminated by signal %d"
% (cmd[0], os.WTERMSIG(status))) % (cmd, os.WTERMSIG(status)))
elif os.WIFEXITED(status): elif os.WIFEXITED(status):
exit_status = os.WEXITSTATUS(status) exit_status = os.WEXITSTATUS(status)
if exit_status == 0: if exit_status == 0:
return # hey, it succeeded! return # hey, it succeeded!
else: else:
if not DEBUG:
cmd = executable
raise DistutilsExecError( raise DistutilsExecError(
"command '%s' failed with exit status %d" "command %r failed with exit status %d"
% (cmd[0], exit_status)) % (cmd, exit_status))
elif os.WIFSTOPPED(status): elif os.WIFSTOPPED(status):
continue continue
else: else:
if not DEBUG:
cmd = executable
raise DistutilsExecError( raise DistutilsExecError(
"unknown error executing '%s': termination status %d" "unknown error executing %r: termination status %d"
% (cmd[0], status)) % (cmd, status))
def find_executable(executable, path=None): def find_executable(executable, path=None):
"""Tries to find 'executable' in the directories listed in 'path'. """Tries to find 'executable' in the directories listed in 'path'.

10
Lib/distutils/tests/test_util.py
View file

@ -8,7 +8,8 @@
from distutils.errors import DistutilsPlatformError, DistutilsByteCompileError from distutils.errors import DistutilsPlatformError, DistutilsByteCompileError
from distutils.util import (get_platform, convert_path, change_root, from distutils.util import (get_platform, convert_path, change_root,
check_environ, split_quoted, strtobool, check_environ, split_quoted, strtobool,
rfc822_escape, byte_compile) rfc822_escape, byte_compile,
grok_environment_error)
from distutils import util # used to patch _environ_checked from distutils import util # used to patch _environ_checked
from distutils.sysconfig import get_config_vars from distutils.sysconfig import get_config_vars
from distutils import sysconfig from distutils import sysconfig
@ -285,6 +286,13 @@ def test_dont_write_bytecode(self):
finally: finally:
sys.dont_write_bytecode = old_dont_write_bytecode sys.dont_write_bytecode = old_dont_write_bytecode
def test_grok_environment_error(self):
# test obsolete function to ensure backward compat (#4931)
exc = IOError("Unable to find batch file")
msg = grok_environment_error(exc)
self.assertEqual(msg, "error: Unable to find batch file")
def test_suite(): def test_suite():
return unittest.makeSuite(UtilTestCase) return unittest.makeSuite(UtilTestCase)

23
Lib/distutils/util.py
View file

@ -207,25 +207,10 @@ def _subst (match, local_vars=local_vars):
def grok_environment_error (exc, prefix="error: "): def grok_environment_error (exc, prefix="error: "):
"""Generate a useful error message from an OSError # Function kept for backward compatibility.
exception object. Handles Python 1.5.1 and 1.5.2 styles, and # Used to try clever things with EnvironmentErrors,
does what it can to deal with exception objects that don't have a # but nowadays str(exception) produces good messages.
filename (which happens when the error is due to a two-file operation, return prefix + str(exc)
such as 'rename()' or 'link()'. Returns the error message as a string
prefixed with 'prefix'.
"""
# check for Python 1.5.2-style {IO,OS}Error exception objects
if hasattr(exc, 'filename') and hasattr(exc, 'strerror'):
if exc.filename:
error = prefix + "%s: %s" % (exc.filename, exc.strerror)
else:
# two-argument functions in posix module don't
# include the filename in the exception object!
error = prefix + "%s" % exc.strerror
else:
error = prefix + str(exc.args[-1])
return error
# Needed by 'split_quoted()' # Needed by 'split_quoted()'

6
Lib/email/message.py
View file

@ -203,7 +203,11 @@ def attach(self, payload):
if self._payload is None: if self._payload is None:
self._payload = [payload] self._payload = [payload]
else: else:
self._payload.append(payload) try:
self._payload.append(payload)
except AttributeError:
raise TypeError("Attach is not valid on a message with a"
" non-multipart payload")
def get_payload(self, i=None, decode=False): def get_payload(self, i=None, decode=False):
"""Return a reference to the payload. """Return a reference to the payload.

3
Lib/encodings/base64_codec.py
View file

@ -1,7 +1,6 @@
"""Python 'base64_codec' Codec - base64 content transfer encoding. """Python 'base64_codec' Codec - base64 content transfer encoding.
This codec de/encodes from bytes to bytes and is therefore usable with This codec de/encodes from bytes to bytes.
bytes.transform() and bytes.untransform().
Written by Marc-Andre Lemburg (mal@lemburg.com). Written by Marc-Andre Lemburg (mal@lemburg.com).
""" """

3
Lib/encodings/hex_codec.py
View file

@ -1,7 +1,6 @@
"""Python 'hex_codec' Codec - 2-digit hex content transfer encoding. """Python 'hex_codec' Codec - 2-digit hex content transfer encoding.
This codec de/encodes from bytes to bytes and is therefore usable with This codec de/encodes from bytes to bytes.
bytes.transform() and bytes.untransform().
Written by Marc-Andre Lemburg (mal@lemburg.com). Written by Marc-Andre Lemburg (mal@lemburg.com).
""" """

3
Lib/encodings/quopri_codec.py
View file

@ -1,7 +1,6 @@
"""Codec for quoted-printable encoding. """Codec for quoted-printable encoding.
This codec de/encodes from bytes to bytes and is therefore usable with This codec de/encodes from bytes to bytes.
bytes.transform() and bytes.untransform().
""" """
import codecs import codecs

3
Lib/encodings/rot_13.py
View file

@ -1,8 +1,7 @@
#!/usr/bin/env python #!/usr/bin/env python
""" Python Character Mapping Codec for ROT13. """ Python Character Mapping Codec for ROT13.
This codec de/encodes from str to str and is therefore usable with This codec de/encodes from str to str.
str.transform() and str.untransform().
Written by Marc-Andre Lemburg (mal@lemburg.com). Written by Marc-Andre Lemburg (mal@lemburg.com).
""" """

3
Lib/encodings/uu_codec.py
View file

@ -1,7 +1,6 @@
"""Python 'uu_codec' Codec - UU content transfer encoding. """Python 'uu_codec' Codec - UU content transfer encoding.
This codec de/encodes from bytes to bytes and is therefore usable with This codec de/encodes from bytes to bytes.
bytes.transform() and bytes.untransform().
Written by Marc-Andre Lemburg (mal@lemburg.com). Some details were Written by Marc-Andre Lemburg (mal@lemburg.com). Some details were
adapted from uu.py which was written by Lance Ellinghouse and adapted from uu.py which was written by Lance Ellinghouse and

3
Lib/encodings/zlib_codec.py
View file

@ -1,7 +1,6 @@
"""Python 'zlib_codec' Codec - zlib compression encoding. """Python 'zlib_codec' Codec - zlib compression encoding.
This codec de/encodes from bytes to bytes and is therefore usable with This codec de/encodes from bytes to bytes.
bytes.transform() and bytes.untransform().
Written by Marc-Andre Lemburg (mal@lemburg.com). Written by Marc-Andre Lemburg (mal@lemburg.com).
""" """

2
Lib/gzip.py
View file

@ -96,7 +96,7 @@ def prepend(self, prepend=b'', readprevious=False):
self._read -= len(prepend) self._read -= len(prepend)
return return
else: else:
self._buffer = self._buffer[read:] + prepend self._buffer = self._buffer[self._read:] + prepend
self._length = len(self._buffer) self._length = len(self._buffer)
self._read = 0 self._read = 0

2
Lib/idlelib/GrepDialog.py
View file

@ -98,7 +98,7 @@ def grep_it(self, prog, path):
def findfiles(self, dir, base, rec): def findfiles(self, dir, base, rec):
try: try:
names = os.listdir(dir or os.curdir) names = os.listdir(dir or os.curdir)
except OSerror as msg: except OSError as msg:
print(msg) print(msg)
return [] return []
list = [] list = []

6
Lib/idlelib/MultiCall.py
View file

@ -111,6 +111,8 @@ def __del__(self):
except tkinter.TclError as e: except tkinter.TclError as e:
if e.args[0] == APPLICATION_GONE: if e.args[0] == APPLICATION_GONE:
pass pass
else:
raise
# An int in range(1 << len(_modifiers)) represents a combination of modifiers # An int in range(1 << len(_modifiers)) represents a combination of modifiers
# (if the least significent bit is on, _modifiers[0] is on, and so on). # (if the least significent bit is on, _modifiers[0] is on, and so on).
@ -244,6 +246,8 @@ def __del__(self):
except tkinter.TclError as e: except tkinter.TclError as e:
if e.args[0] == APPLICATION_GONE: if e.args[0] == APPLICATION_GONE:
break break
else:
raise
# define the list of event types to be handled by MultiEvent. the order is # define the list of event types to be handled by MultiEvent. the order is
# compatible with the definition of event type constants. # compatible with the definition of event type constants.
@ -411,6 +415,8 @@ def __del__(self):
except tkinter.TclError as e: except tkinter.TclError as e:
if e.args[0] == APPLICATION_GONE: if e.args[0] == APPLICATION_GONE:
break break
else:
raise
_multicall_dict[widget] = MultiCall _multicall_dict[widget] = MultiCall
return MultiCall return MultiCall

10
Lib/idlelib/idle_test/README.txt
View file

@ -41,9 +41,10 @@ idle class. For the benefit of buildbot machines that do not have a graphics
screen, gui tests must be 'guarded' by "requires('gui')" in a setUp screen, gui tests must be 'guarded' by "requires('gui')" in a setUp
function or method. This will typically be setUpClass. function or method. This will typically be setUpClass.
All gui objects must be destroyed by the end of the test, perhaps in a tearDown To avoid interfering with other gui tests, all gui objects must be destroyed
function. Creating the Tk root directly in a setUp allows a reference to be saved and deleted by the end of the test. If a widget, such as a Tk root, is created
so it can be properly destroyed in the corresponding tearDown. in a setUpX function, destroy it in the corresponding tearDownX. For module
and class attributes, also delete the widget.
--- ---
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
@ -53,6 +54,7 @@ so it can be properly destroyed in the corresponding tearDown.
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
cls.root.destroy() cls.root.destroy()
del cls.root
--- ---
Support.requires('gui') returns true if it is either called in a main module Support.requires('gui') returns true if it is either called in a main module
@ -105,4 +107,4 @@ makes other tests fail (issue 18081).
To run an individual Testcase or test method, extend the dotted name given to To run an individual Testcase or test method, extend the dotted name given to
unittest on the command line. (But gui tests will not this way.) unittest on the command line. (But gui tests will not this way.)
python -m unittest -v idlelib.idle_test.text_xyz.Test_case.test_meth python -m unittest -v idlelib.idle_test.test_xyz.Test_case.test_meth

3
Lib/idlelib/idle_test/test_formatparagraph.py
View file

@ -277,6 +277,9 @@ def setUpClass(cls):
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
cls.root.destroy() cls.root.destroy()
del cls.root
del cls.text
del cls.formatter
def test_short_line(self): def test_short_line(self):
self.text.insert('1.0', "Short line\n") self.text.insert('1.0', "Short line\n")

1
Lib/idlelib/idle_test/test_idlehistory.py
View file

@ -80,6 +80,7 @@ def setUp(self):
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
cls.root.destroy() cls.root.destroy()
del cls.root
def fetch_test(self, reverse, line, prefix, index, *, bell=False): def fetch_test(self, reverse, line, prefix, index, *, bell=False):
# Perform one fetch as invoked by Alt-N or Alt-P # Perform one fetch as invoked by Alt-N or Alt-P

3
Lib/idlelib/idle_test/test_searchengine.py
View file

@ -64,6 +64,7 @@ class GetSelectionTest(unittest.TestCase):
## @classmethod ## @classmethod
## def tearDownClass(cls): ## def tearDownClass(cls):
## cls.root.destroy() ## cls.root.destroy()
## del cls.root
def test_get_selection(self): def test_get_selection(self):
# text = Text(master=self.root) # text = Text(master=self.root)
@ -219,6 +220,7 @@ def setUpClass(cls):
## @classmethod ## @classmethod
## def tearDownClass(cls): ## def tearDownClass(cls):
## cls.root.destroy() ## cls.root.destroy()
## del cls.root
def test_search(self): def test_search(self):
Equal = self.assertEqual Equal = self.assertEqual
@ -261,6 +263,7 @@ class ForwardBackwardTest(unittest.TestCase):
## @classmethod ## @classmethod
## def tearDownClass(cls): ## def tearDownClass(cls):
## cls.root.destroy() ## cls.root.destroy()
## del cls.root
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):

1
Lib/idlelib/idle_test/test_text.py
View file

@ -221,6 +221,7 @@ def setUpClass(cls):
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
cls.root.destroy() cls.root.destroy()
del cls.root
if __name__ == '__main__': if __name__ == '__main__':

12
Lib/ipaddress.py
View file

@ -2155,6 +2155,18 @@ def __init__(self, address, strict=True):
if self._prefixlen == (self._max_prefixlen - 1): if self._prefixlen == (self._max_prefixlen - 1):
self.hosts = self.__iter__ self.hosts = self.__iter__
def hosts(self):
"""Generate Iterator over usable hosts in a network.
This is like __iter__ except it doesn't return the
Subnet-Router anycast address.
"""
network = int(self.network_address)
broadcast = int(self.broadcast_address)
for x in range(network + 1, broadcast + 1):
yield self._address_class(x)
@property @property
def is_site_local(self): def is_site_local(self):
"""Test if the address is reserved for site-local. """Test if the address is reserved for site-local.

16
Lib/logging/__init__.py
View file

@ -1,4 +1,4 @@
# Copyright 2001-2013 by Vinay Sajip. All Rights Reserved. # Copyright 2001-2014 by Vinay Sajip. All Rights Reserved.
# #
# Permission to use, copy, modify, and distribute this software and its # Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose and without fee is hereby granted, # documentation for any purpose and without fee is hereby granted,
@ -18,7 +18,7 @@
Logging package for Python. Based on PEP 282 and comments thereto in Logging package for Python. Based on PEP 282 and comments thereto in
comp.lang.python. comp.lang.python.
Copyright (C) 2001-2013 Vinay Sajip. All Rights Reserved. Copyright (C) 2001-2014 Vinay Sajip. All Rights Reserved.
To use, simply 'import logging' and log away! To use, simply 'import logging' and log away!
""" """
@ -42,6 +42,7 @@
__author__ = "Vinay Sajip <vinay_sajip@red-dove.com>" __author__ = "Vinay Sajip <vinay_sajip@red-dove.com>"
__status__ = "production" __status__ = "production"
# The following module attributes are no longer updated.
__version__ = "0.5.1.2" __version__ = "0.5.1.2"
__date__ = "07 February 2010" __date__ = "07 February 2010"
@ -902,8 +903,15 @@ def handleError(self, record):
sys.stderr.write('Logged from file %s, line %s\n' % ( sys.stderr.write('Logged from file %s, line %s\n' % (
record.filename, record.lineno)) record.filename, record.lineno))
# Issue 18671: output logging message and arguments # Issue 18671: output logging message and arguments
sys.stderr.write('Message: %r\n' try:
'Arguments: %s\n' % (record.msg, record.args)) sys.stderr.write('Message: %r\n'
'Arguments: %s\n' % (record.msg,
record.args))
except Exception:
sys.stderr.write('Unable to print the message and arguments'
' - possible formatting error.\nUse the'
' traceback above to help find the error.\n'
)
except OSError: #pragma: no cover except OSError: #pragma: no cover
pass # see issue 5971 pass # see issue 5971
finally: finally:

12
Lib/modulefinder.py
View file

@ -1,6 +1,7 @@
"""Find modules used by a script, using introspection.""" """Find modules used by a script, using introspection."""
import dis import dis
import importlib._bootstrap
import importlib.machinery import importlib.machinery
import marshal import marshal
import os import os
@ -287,11 +288,12 @@ def load_module(self, fqname, fp, pathname, file_info):
if type == imp.PY_SOURCE: if type == imp.PY_SOURCE:
co = compile(fp.read()+'\n', pathname, 'exec') co = compile(fp.read()+'\n', pathname, 'exec')
elif type == imp.PY_COMPILED: elif type == imp.PY_COMPILED:
if fp.read(4) != imp.get_magic(): try:
self.msgout(2, "raise ImportError: Bad magic number", pathname) marshal_data = importlib._bootstrap._validate_bytecode_header(fp.read())
raise ImportError("Bad magic number in %s" % pathname) except ImportError as exc:
fp.read(4) self.msgout(2, "raise ImportError: " + str(exc), pathname)
co = marshal.load(fp) raise
co = marshal.loads(marshal_data)
else: else:
co = None co = None
m = self.add_module(fqname) m = self.add_module(fqname)

60
Lib/ntpath.py
View file

@ -377,6 +377,7 @@ def expandvars(path):
percent = b'%' percent = b'%'
brace = b'{' brace = b'{'
dollar = b'$' dollar = b'$'
environ = getattr(os, 'environb', None)
else: else:
if '$' not in path and '%' not in path: if '$' not in path and '%' not in path:
return path return path
@ -386,6 +387,7 @@ def expandvars(path):
percent = '%' percent = '%'
brace = '{' brace = '{'
dollar = '$' dollar = '$'
environ = os.environ
res = path[:0] res = path[:0]
index = 0 index = 0
pathlen = len(path) pathlen = len(path)
@ -414,14 +416,13 @@ def expandvars(path):
index = pathlen - 1 index = pathlen - 1
else: else:
var = path[:index] var = path[:index]
if isinstance(path, bytes): try:
var = var.decode('ascii') if environ is None:
if var in os.environ: value = os.fsencode(os.environ[os.fsdecode(var)])
value = os.environ[var] else:
else: value = environ[var]
value = '%' + var + '%' except KeyError:
if isinstance(path, bytes): value = percent + var + percent
value = value.encode('ascii')
res += value res += value
elif c == dollar: # variable or '$$' elif c == dollar: # variable or '$$'
if path[index + 1:index + 2] == dollar: if path[index + 1:index + 2] == dollar:
@ -435,39 +436,40 @@ def expandvars(path):
index = path.index(b'}') index = path.index(b'}')
else: else:
index = path.index('}') index = path.index('}')
var = path[:index]
if isinstance(path, bytes):
var = var.decode('ascii')
if var in os.environ:
value = os.environ[var]
else:
value = '${' + var + '}'
if isinstance(path, bytes):
value = value.encode('ascii')
res += value
except ValueError: except ValueError:
if isinstance(path, bytes): if isinstance(path, bytes):
res += b'${' + path res += b'${' + path
else: else:
res += '${' + path res += '${' + path
index = pathlen - 1 index = pathlen - 1
else:
var = path[:index]
try:
if environ is None:
value = os.fsencode(os.environ[os.fsdecode(var)])
else:
value = environ[var]
except KeyError:
if isinstance(path, bytes):
value = b'${' + var + b'}'
else:
value = '${' + var + '}'
res += value
else: else:
var = '' var = path[:0]
index += 1 index += 1
c = path[index:index + 1] c = path[index:index + 1]
while c and c in varchars: while c and c in varchars:
if isinstance(path, bytes): var += c
var += c.decode('ascii')
else:
var += c
index += 1 index += 1
c = path[index:index + 1] c = path[index:index + 1]
if var in os.environ: try:
value = os.environ[var] if environ is None:
else: value = os.fsencode(os.environ[os.fsdecode(var)])
value = '$' + var else:
if isinstance(path, bytes): value = environ[var]
value = value.encode('ascii') except KeyError:
value = dollar + var
res += value res += value
if c: if c:
index -= 1 index -= 1

18
Lib/posixpath.py
View file

@ -279,6 +279,7 @@ def expandvars(path):
search = _varprogb.search search = _varprogb.search
start = b'{' start = b'{'
end = b'}' end = b'}'
environ = getattr(os, 'environb', None)
else: else:
if '$' not in path: if '$' not in path:
return path return path
@ -288,6 +289,7 @@ def expandvars(path):
search = _varprog.search search = _varprog.search
start = '{' start = '{'
end = '}' end = '}'
environ = os.environ
i = 0 i = 0
while True: while True:
m = search(path, i) m = search(path, i)
@ -297,18 +299,18 @@ def expandvars(path):
name = m.group(1) name = m.group(1)
if name.startswith(start) and name.endswith(end): if name.startswith(start) and name.endswith(end):
name = name[1:-1] name = name[1:-1]
if isinstance(name, bytes): try:
name = str(name, 'ASCII') if environ is None:
if name in os.environ: value = os.fsencode(os.environ[os.fsdecode(name)])
else:
value = environ[name]
except KeyError:
i = j
else:
tail = path[j:] tail = path[j:]
value = os.environ[name]
if isinstance(path, bytes):
value = value.encode('ASCII')
path = path[:i] + value path = path[:i] + value
i = len(path) i = len(path)
path += tail path += tail
else:
i = j
return path return path

9
Lib/pydoc.py
View file

@ -1256,9 +1256,12 @@ def spilldata(msg, attrs, predicate):
doc = getdoc(value) doc = getdoc(value)
else: else:
doc = None doc = None
push(self.docother( try:
getattr(object, name, None) or homecls.__dict__[name], obj = getattr(object, name)
name, mod, maxlen=70, doc=doc) + '\n') except AttributeError:
obj = homecls.__dict__[name]
push(self.docother(obj, name, mod, maxlen=70, doc=doc) +
'\n')
return attrs return attrs
attrs = [(name, kind, cls, value) attrs = [(name, kind, cls, value)

3
Lib/shutil.py
View file

@ -483,7 +483,8 @@ def onerror(*args):
def _basename(path): def _basename(path):
# A basename() variant which first strips the trailing slash, if present. # A basename() variant which first strips the trailing slash, if present.
# Thus we always get the last component of the path, even for directories. # Thus we always get the last component of the path, even for directories.
return os.path.basename(path.rstrip(os.path.sep)) sep = os.path.sep + (os.path.altsep or '')
return os.path.basename(path.rstrip(sep))
def move(src, dst): def move(src, dst):
"""Recursively move a file or directory to another location. This is """Recursively move a file or directory to another location. This is

1
Lib/sqlite3/test/factory.py
View file

@ -112,6 +112,7 @@ def CheckSqliteRowAsTuple(self):
self.con.row_factory = sqlite.Row self.con.row_factory = sqlite.Row
row = self.con.execute("select 1 as a, 2 as b").fetchone() row = self.con.execute("select 1 as a, 2 as b").fetchone()
t = tuple(row) t = tuple(row)
self.assertEqual(t, (row['a'], row['b']))
def CheckSqliteRowAsDict(self): def CheckSqliteRowAsDict(self):
"""Checks if the row object can be correctly converted to a dictionary""" """Checks if the row object can be correctly converted to a dictionary"""

2
Lib/sqlite3/test/hooks.py
View file

@ -162,7 +162,7 @@ def progress():
create table bar (a, b) create table bar (a, b)
""") """)
second_count = len(progress_calls) second_count = len(progress_calls)
self.assertGreater(first_count, second_count) self.assertGreaterEqual(first_count, second_count)
def CheckCancelOperation(self): def CheckCancelOperation(self):
""" """

23
Lib/subprocess.py
View file

@ -738,6 +738,9 @@ def getoutput(cmd):
class Popen(object): class Popen(object):
_child_created = False # Set here since __del__ checks it
def __init__(self, args, bufsize=-1, executable=None, def __init__(self, args, bufsize=-1, executable=None,
stdin=None, stdout=None, stderr=None, stdin=None, stdout=None, stderr=None,
preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS, preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS,
@ -748,7 +751,6 @@ def __init__(self, args, bufsize=-1, executable=None,
"""Create new Popen instance.""" """Create new Popen instance."""
_cleanup() _cleanup()
self._child_created = False
self._input = None self._input = None
self._communication_started = False self._communication_started = False
if bufsize is None: if bufsize is None:
@ -890,11 +892,8 @@ def __exit__(self, type, value, traceback):
# Wait for the process to terminate, to avoid zombies. # Wait for the process to terminate, to avoid zombies.
self.wait() self.wait()
def __del__(self, _maxsize=sys.maxsize, _active=_active): def __del__(self, _maxsize=sys.maxsize):
# If __init__ hasn't had a chance to execute (e.g. if it if not self._child_created:
# was passed an undeclared keyword argument), we don't
# have a _child_created attribute at all.
if not getattr(self, '_child_created', False):
# We didn't get to successfully create a child process. # We didn't get to successfully create a child process.
return return
# In case the child hasn't been waited on, check if it's done. # In case the child hasn't been waited on, check if it's done.
@ -1187,7 +1186,15 @@ def _communicate(self, input, endtime, orig_timeout):
try: try:
self.stdin.write(input) self.stdin.write(input)
except OSError as e: except OSError as e:
if e.errno != errno.EPIPE: if e.errno == errno.EPIPE:
# communicate() should ignore pipe full error
pass
elif (e.errno == errno.EINVAL
and self.poll() is not None):
# Issue #19612: stdin.write() fails with EINVAL
# if the process already exited before the write
pass
else:
raise raise
self.stdin.close() self.stdin.close()
@ -1446,7 +1453,7 @@ def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED,
_WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED, _WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED,
_WEXITSTATUS=os.WEXITSTATUS): _WEXITSTATUS=os.WEXITSTATUS):
# This method is called (indirectly) by __del__, so it cannot # This method is called (indirectly) by __del__, so it cannot
# refer to anything outside of its local scope.""" # refer to anything outside of its local scope.
if _WIFSIGNALED(sts): if _WIFSIGNALED(sts):
self.returncode = -_WTERMSIG(sts) self.returncode = -_WTERMSIG(sts)
elif _WIFEXITED(sts): elif _WIFEXITED(sts):

2
Lib/test/_test_multiprocessing.py
View file

@ -3651,7 +3651,7 @@ def test_semaphore_tracker(self):
_multiprocessing.sem_unlink(name1) _multiprocessing.sem_unlink(name1)
p.terminate() p.terminate()
p.wait() p.wait()
time.sleep(1.0) time.sleep(2.0)
with self.assertRaises(OSError) as ctx: with self.assertRaises(OSError) as ctx:
_multiprocessing.sem_unlink(name2) _multiprocessing.sem_unlink(name2)
# docs say it should be ENOENT, but OSX seems to give EINVAL # docs say it should be ENOENT, but OSX seems to give EINVAL

4
Lib/test/coding20731.py Normal file
View file

@ -0,0 +1,4 @@
#coding:latin1

9
Lib/test/regrtest.py
View file

@ -1373,10 +1373,9 @@ def dash_R(the_module, test, indirect_test, huntrleaks):
try: try:
import zipimport import zipimport
except ImportError: except ImportError:
zsc = zdc = None # Run unmodified on platforms without zipimport support zdc = None # Run unmodified on platforms without zipimport support
else: else:
zdc = zipimport._zip_directory_cache.copy() zdc = zipimport._zip_directory_cache.copy()
zsc = zipimport._zip_stat_cache.copy()
abcs = {} abcs = {}
for abc in [getattr(collections.abc, a) for a in collections.abc.__all__]: for abc in [getattr(collections.abc, a) for a in collections.abc.__all__]:
if not isabstract(abc): if not isabstract(abc):
@ -1395,7 +1394,7 @@ def dash_R(the_module, test, indirect_test, huntrleaks):
sys.stderr.flush() sys.stderr.flush()
for i in range(repcount): for i in range(repcount):
indirect_test() indirect_test()
alloc_after, rc_after = dash_R_cleanup(fs, ps, pic, zdc, zsc, abcs) alloc_after, rc_after = dash_R_cleanup(fs, ps, pic, zdc, abcs)
sys.stderr.write('.') sys.stderr.write('.')
sys.stderr.flush() sys.stderr.flush()
if i >= nwarmup: if i >= nwarmup:
@ -1429,7 +1428,7 @@ def check_alloc_deltas(deltas):
failed = True failed = True
return failed return failed
def dash_R_cleanup(fs, ps, pic, zdc, zsc, abcs): def dash_R_cleanup(fs, ps, pic, zdc, abcs):
import gc, copyreg import gc, copyreg
import _strptime, linecache import _strptime, linecache
import urllib.parse, urllib.request, mimetypes, doctest import urllib.parse, urllib.request, mimetypes, doctest
@ -1455,8 +1454,6 @@ def dash_R_cleanup(fs, ps, pic, zdc, zsc, abcs):
else: else:
zipimport._zip_directory_cache.clear() zipimport._zip_directory_cache.clear()
zipimport._zip_directory_cache.update(zdc) zipimport._zip_directory_cache.update(zdc)
zipimport._zip_stat_cache.clear()
zipimport._zip_stat_cache.update(zsc)
# clear type cache # clear type cache
sys._clear_type_cache() sys._clear_type_cache()

110
Lib/test/test_asyncio/test_base_events.py
View file

@ -6,8 +6,8 @@
import sys import sys
import time import time
import unittest import unittest
import unittest.mock from unittest import mock
from test.support import find_unused_port, IPV6_ENABLED from test.support import IPV6_ENABLED
import asyncio import asyncio
from asyncio import base_events from asyncio import base_events
@ -15,7 +15,7 @@
from asyncio import test_utils from asyncio import test_utils
MOCK_ANY = unittest.mock.ANY MOCK_ANY = mock.ANY
PY34 = sys.version_info >= (3, 4) PY34 = sys.version_info >= (3, 4)
@ -23,11 +23,11 @@ class BaseEventLoopTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = base_events.BaseEventLoop() self.loop = base_events.BaseEventLoop()
self.loop._selector = unittest.mock.Mock() self.loop._selector = mock.Mock()
asyncio.set_event_loop(None) asyncio.set_event_loop(None)
def test_not_implemented(self): def test_not_implemented(self):
m = unittest.mock.Mock() m = mock.Mock()
self.assertRaises( self.assertRaises(
NotImplementedError, NotImplementedError,
self.loop._make_socket_transport, m, m) self.loop._make_socket_transport, m, m)
@ -75,13 +75,13 @@ def test__add_callback_cancelled_handle(self):
self.assertFalse(self.loop._ready) self.assertFalse(self.loop._ready)
def test_set_default_executor(self): def test_set_default_executor(self):
executor = unittest.mock.Mock() executor = mock.Mock()
self.loop.set_default_executor(executor) self.loop.set_default_executor(executor)
self.assertIs(executor, self.loop._default_executor) self.assertIs(executor, self.loop._default_executor)
def test_getnameinfo(self): def test_getnameinfo(self):
sockaddr = unittest.mock.Mock() sockaddr = mock.Mock()
self.loop.run_in_executor = unittest.mock.Mock() self.loop.run_in_executor = mock.Mock()
self.loop.getnameinfo(sockaddr) self.loop.getnameinfo(sockaddr)
self.assertEqual( self.assertEqual(
(None, socket.getnameinfo, sockaddr, 0), (None, socket.getnameinfo, sockaddr, 0),
@ -111,7 +111,7 @@ def test_call_later_negative_delays(self):
def cb(arg): def cb(arg):
calls.append(arg) calls.append(arg)
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
self.loop.call_later(-1, cb, 'a') self.loop.call_later(-1, cb, 'a')
self.loop.call_later(-2, cb, 'b') self.loop.call_later(-2, cb, 'b')
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
@ -121,7 +121,7 @@ def test_time_and_call_at(self):
def cb(): def cb():
self.loop.stop() self.loop.stop()
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
delay = 0.1 delay = 0.1
when = self.loop.time() + delay when = self.loop.time() + delay
@ -163,7 +163,7 @@ def cb():
pass pass
h = asyncio.Handle(cb, (), self.loop) h = asyncio.Handle(cb, (), self.loop)
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
executor = unittest.mock.Mock() executor = mock.Mock()
executor.submit.return_value = f executor.submit.return_value = f
self.loop.set_default_executor(executor) self.loop.set_default_executor(executor)
@ -171,7 +171,7 @@ def cb():
res = self.loop.run_in_executor(None, h) res = self.loop.run_in_executor(None, h)
self.assertIs(f, res) self.assertIs(f, res)
executor = unittest.mock.Mock() executor = mock.Mock()
executor.submit.return_value = f executor.submit.return_value = f
res = self.loop.run_in_executor(executor, h) res = self.loop.run_in_executor(executor, h)
self.assertIs(f, res) self.assertIs(f, res)
@ -187,7 +187,7 @@ def test__run_once(self):
h1.cancel() h1.cancel()
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
self.loop._scheduled.append(h1) self.loop._scheduled.append(h1)
self.loop._scheduled.append(h2) self.loop._scheduled.append(h2)
self.loop._run_once() self.loop._run_once()
@ -203,8 +203,8 @@ def test_set_debug(self):
self.loop.set_debug(False) self.loop.set_debug(False)
self.assertFalse(self.loop.get_debug()) self.assertFalse(self.loop.get_debug())
@unittest.mock.patch('asyncio.base_events.time') @mock.patch('asyncio.base_events.time')
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test__run_once_logging(self, m_logger, m_time): def test__run_once_logging(self, m_logger, m_time):
# Log to INFO level if timeout > 1.0 sec. # Log to INFO level if timeout > 1.0 sec.
idx = -1 idx = -1
@ -219,7 +219,7 @@ def monotonic():
self.loop._scheduled.append( self.loop._scheduled.append(
asyncio.TimerHandle(11.0, lambda: True, (), self.loop)) asyncio.TimerHandle(11.0, lambda: True, (), self.loop))
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
self.loop._run_once() self.loop._run_once()
self.assertEqual(logging.INFO, m_logger.log.call_args[0][0]) self.assertEqual(logging.INFO, m_logger.log.call_args[0][0])
@ -242,7 +242,7 @@ def cb(loop):
h = asyncio.TimerHandle(time.monotonic() - 1, cb, (self.loop,), h = asyncio.TimerHandle(time.monotonic() - 1, cb, (self.loop,),
self.loop) self.loop)
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
self.loop._scheduled.append(h) self.loop._scheduled.append(h)
self.loop._run_once() self.loop._run_once()
@ -303,14 +303,14 @@ def test_subprocess_shell_invalid_args(self):
asyncio.SubprocessProtocol, 'exit 0', bufsize=4096) asyncio.SubprocessProtocol, 'exit 0', bufsize=4096)
def test_default_exc_handler_callback(self): def test_default_exc_handler_callback(self):
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
def zero_error(fut): def zero_error(fut):
fut.set_result(True) fut.set_result(True)
1/0 1/0
# Test call_soon (events.Handle) # Test call_soon (events.Handle)
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
self.loop.call_soon(zero_error, fut) self.loop.call_soon(zero_error, fut)
fut.add_done_callback(lambda fut: self.loop.stop()) fut.add_done_callback(lambda fut: self.loop.stop())
@ -320,7 +320,7 @@ def zero_error(fut):
exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY)) exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY))
# Test call_later (events.TimerHandle) # Test call_later (events.TimerHandle)
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
self.loop.call_later(0.01, zero_error, fut) self.loop.call_later(0.01, zero_error, fut)
fut.add_done_callback(lambda fut: self.loop.stop()) fut.add_done_callback(lambda fut: self.loop.stop())
@ -330,7 +330,7 @@ def zero_error(fut):
exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY)) exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY))
def test_default_exc_handler_coro(self): def test_default_exc_handler_coro(self):
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
@asyncio.coroutine @asyncio.coroutine
def zero_error_coro(): def zero_error_coro():
@ -338,7 +338,7 @@ def zero_error_coro():
1/0 1/0
# Test Future.__del__ # Test Future.__del__
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
fut = asyncio.async(zero_error_coro(), loop=self.loop) fut = asyncio.async(zero_error_coro(), loop=self.loop)
fut.add_done_callback(lambda *args: self.loop.stop()) fut.add_done_callback(lambda *args: self.loop.stop())
self.loop.run_forever() self.loop.run_forever()
@ -368,9 +368,9 @@ def run_loop():
self.loop.call_soon(zero_error) self.loop.call_soon(zero_error)
self.loop._run_once() self.loop._run_once()
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
mock_handler = unittest.mock.Mock() mock_handler = mock.Mock()
self.loop.set_exception_handler(mock_handler) self.loop.set_exception_handler(mock_handler)
run_loop() run_loop()
mock_handler.assert_called_with(self.loop, { mock_handler.assert_called_with(self.loop, {
@ -382,7 +382,7 @@ def run_loop():
mock_handler.reset_mock() mock_handler.reset_mock()
self.loop.set_exception_handler(None) self.loop.set_exception_handler(None)
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
run_loop() run_loop()
log.error.assert_called_with( log.error.assert_called_with(
test_utils.MockPattern( test_utils.MockPattern(
@ -401,11 +401,11 @@ def zero_error():
def handler(loop, context): def handler(loop, context):
raise AttributeError('spam') raise AttributeError('spam')
self.loop._process_events = unittest.mock.Mock() self.loop._process_events = mock.Mock()
self.loop.set_exception_handler(handler) self.loop.set_exception_handler(handler)
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
run_loop() run_loop()
log.error.assert_called_with( log.error.assert_called_with(
test_utils.MockPattern( test_utils.MockPattern(
@ -417,8 +417,8 @@ def test_default_exc_handler_broken(self):
class Loop(base_events.BaseEventLoop): class Loop(base_events.BaseEventLoop):
_selector = unittest.mock.Mock() _selector = mock.Mock()
_process_events = unittest.mock.Mock() _process_events = mock.Mock()
def default_exception_handler(self, context): def default_exception_handler(self, context):
nonlocal _context nonlocal _context
@ -435,7 +435,7 @@ def zero_error():
loop.call_soon(zero_error) loop.call_soon(zero_error)
loop._run_once() loop._run_once()
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
run_loop() run_loop()
log.error.assert_called_with( log.error.assert_called_with(
'Exception in default exception handler', 'Exception in default exception handler',
@ -446,7 +446,7 @@ def custom_handler(loop, context):
_context = None _context = None
loop.set_exception_handler(custom_handler) loop.set_exception_handler(custom_handler)
with unittest.mock.patch('asyncio.base_events.logger') as log: with mock.patch('asyncio.base_events.logger') as log:
run_loop() run_loop()
log.error.assert_called_with( log.error.assert_called_with(
test_utils.MockPattern('Exception in default exception.*' test_utils.MockPattern('Exception in default exception.*'
@ -527,7 +527,7 @@ def setUp(self):
def tearDown(self): def tearDown(self):
self.loop.close() self.loop.close()
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_connection_multiple_errors(self, m_socket): def test_create_connection_multiple_errors(self, m_socket):
class MyProto(asyncio.Protocol): class MyProto(asyncio.Protocol):
@ -592,7 +592,7 @@ def getaddrinfo_task(*args, **kwds):
return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop) return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop)
self.loop.getaddrinfo = getaddrinfo_task self.loop.getaddrinfo = getaddrinfo_task
self.loop.sock_connect = unittest.mock.Mock() self.loop.sock_connect = mock.Mock()
self.loop.sock_connect.side_effect = OSError self.loop.sock_connect.side_effect = OSError
coro = self.loop.create_connection(MyProto, 'example.com', 80) coro = self.loop.create_connection(MyProto, 'example.com', 80)
@ -609,7 +609,7 @@ def getaddrinfo_task(*args, **kwds):
return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop) return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop)
self.loop.getaddrinfo = getaddrinfo_task self.loop.getaddrinfo = getaddrinfo_task
self.loop.sock_connect = unittest.mock.Mock() self.loop.sock_connect = mock.Mock()
self.loop.sock_connect.side_effect = OSError self.loop.sock_connect.side_effect = OSError
coro = self.loop.create_connection( coro = self.loop.create_connection(
@ -617,7 +617,7 @@ def getaddrinfo_task(*args, **kwds):
with self.assertRaises(OSError): with self.assertRaises(OSError):
self.loop.run_until_complete(coro) self.loop.run_until_complete(coro)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_connection_multiple_errors_local_addr(self, m_socket): def test_create_connection_multiple_errors_local_addr(self, m_socket):
def bind(addr): def bind(addr):
@ -637,7 +637,7 @@ def getaddrinfo_task(*args, **kwds):
return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop) return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop)
self.loop.getaddrinfo = getaddrinfo_task self.loop.getaddrinfo = getaddrinfo_task
self.loop.sock_connect = unittest.mock.Mock() self.loop.sock_connect = mock.Mock()
self.loop.sock_connect.side_effect = OSError('Err2') self.loop.sock_connect.side_effect = OSError('Err2')
coro = self.loop.create_connection( coro = self.loop.create_connection(
@ -669,7 +669,7 @@ def getaddrinfo_task(*args, **kwds):
OSError, self.loop.run_until_complete, coro) OSError, self.loop.run_until_complete, coro)
def test_create_connection_ssl_server_hostname_default(self): def test_create_connection_ssl_server_hostname_default(self):
self.loop.getaddrinfo = unittest.mock.Mock() self.loop.getaddrinfo = mock.Mock()
def mock_getaddrinfo(*args, **kwds): def mock_getaddrinfo(*args, **kwds):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
@ -678,9 +678,9 @@ def mock_getaddrinfo(*args, **kwds):
return f return f
self.loop.getaddrinfo.side_effect = mock_getaddrinfo self.loop.getaddrinfo.side_effect = mock_getaddrinfo
self.loop.sock_connect = unittest.mock.Mock() self.loop.sock_connect = mock.Mock()
self.loop.sock_connect.return_value = () self.loop.sock_connect.return_value = ()
self.loop._make_ssl_transport = unittest.mock.Mock() self.loop._make_ssl_transport = mock.Mock()
class _SelectorTransportMock: class _SelectorTransportMock:
_sock = None _sock = None
@ -696,7 +696,7 @@ def mock_make_ssl_transport(sock, protocol, sslcontext, waiter,
return transport return transport
self.loop._make_ssl_transport.side_effect = mock_make_ssl_transport self.loop._make_ssl_transport.side_effect = mock_make_ssl_transport
ANY = unittest.mock.ANY ANY = mock.ANY
# First try the default server_hostname. # First try the default server_hostname.
self.loop._make_ssl_transport.reset_mock() self.loop._make_ssl_transport.reset_mock()
coro = self.loop.create_connection(MyProto, 'python.org', 80, ssl=True) coro = self.loop.create_connection(MyProto, 'python.org', 80, ssl=True)
@ -775,13 +775,13 @@ def test_create_server_no_host_port_sock(self):
self.assertRaises(ValueError, self.loop.run_until_complete, fut) self.assertRaises(ValueError, self.loop.run_until_complete, fut)
def test_create_server_no_getaddrinfo(self): def test_create_server_no_getaddrinfo(self):
getaddrinfo = self.loop.getaddrinfo = unittest.mock.Mock() getaddrinfo = self.loop.getaddrinfo = mock.Mock()
getaddrinfo.return_value = [] getaddrinfo.return_value = []
f = self.loop.create_server(MyProto, '0.0.0.0', 0) f = self.loop.create_server(MyProto, '0.0.0.0', 0)
self.assertRaises(OSError, self.loop.run_until_complete, f) self.assertRaises(OSError, self.loop.run_until_complete, f)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_server_cant_bind(self, m_socket): def test_create_server_cant_bind(self, m_socket):
class Err(OSError): class Err(OSError):
@ -790,14 +790,14 @@ class Err(OSError):
m_socket.getaddrinfo.return_value = [ m_socket.getaddrinfo.return_value = [
(2, 1, 6, '', ('127.0.0.1', 10100))] (2, 1, 6, '', ('127.0.0.1', 10100))]
m_socket.getaddrinfo._is_coroutine = False m_socket.getaddrinfo._is_coroutine = False
m_sock = m_socket.socket.return_value = unittest.mock.Mock() m_sock = m_socket.socket.return_value = mock.Mock()
m_sock.bind.side_effect = Err m_sock.bind.side_effect = Err
fut = self.loop.create_server(MyProto, '0.0.0.0', 0) fut = self.loop.create_server(MyProto, '0.0.0.0', 0)
self.assertRaises(OSError, self.loop.run_until_complete, fut) self.assertRaises(OSError, self.loop.run_until_complete, fut)
self.assertTrue(m_sock.close.called) self.assertTrue(m_sock.close.called)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_datagram_endpoint_no_addrinfo(self, m_socket): def test_create_datagram_endpoint_no_addrinfo(self, m_socket):
m_socket.getaddrinfo.return_value = [] m_socket.getaddrinfo.return_value = []
m_socket.getaddrinfo._is_coroutine = False m_socket.getaddrinfo._is_coroutine = False
@ -818,7 +818,7 @@ def test_create_datagram_endpoint_addr_error(self):
AssertionError, self.loop.run_until_complete, coro) AssertionError, self.loop.run_until_complete, coro)
def test_create_datagram_endpoint_connect_err(self): def test_create_datagram_endpoint_connect_err(self):
self.loop.sock_connect = unittest.mock.Mock() self.loop.sock_connect = mock.Mock()
self.loop.sock_connect.side_effect = OSError self.loop.sock_connect.side_effect = OSError
coro = self.loop.create_datagram_endpoint( coro = self.loop.create_datagram_endpoint(
@ -826,7 +826,7 @@ def test_create_datagram_endpoint_connect_err(self):
self.assertRaises( self.assertRaises(
OSError, self.loop.run_until_complete, coro) OSError, self.loop.run_until_complete, coro)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_datagram_endpoint_socket_err(self, m_socket): def test_create_datagram_endpoint_socket_err(self, m_socket):
m_socket.getaddrinfo = socket.getaddrinfo m_socket.getaddrinfo = socket.getaddrinfo
m_socket.socket.side_effect = OSError m_socket.socket.side_effect = OSError
@ -849,7 +849,7 @@ def test_create_datagram_endpoint_no_matching_family(self):
self.assertRaises( self.assertRaises(
ValueError, self.loop.run_until_complete, coro) ValueError, self.loop.run_until_complete, coro)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_datagram_endpoint_setblk_err(self, m_socket): def test_create_datagram_endpoint_setblk_err(self, m_socket):
m_socket.socket.return_value.setblocking.side_effect = OSError m_socket.socket.return_value.setblocking.side_effect = OSError
@ -865,14 +865,14 @@ def test_create_datagram_endpoint_noaddr_nofamily(self):
asyncio.DatagramProtocol) asyncio.DatagramProtocol)
self.assertRaises(ValueError, self.loop.run_until_complete, coro) self.assertRaises(ValueError, self.loop.run_until_complete, coro)
@unittest.mock.patch('asyncio.base_events.socket') @mock.patch('asyncio.base_events.socket')
def test_create_datagram_endpoint_cant_bind(self, m_socket): def test_create_datagram_endpoint_cant_bind(self, m_socket):
class Err(OSError): class Err(OSError):
pass pass
m_socket.AF_INET6 = socket.AF_INET6 m_socket.AF_INET6 = socket.AF_INET6
m_socket.getaddrinfo = socket.getaddrinfo m_socket.getaddrinfo = socket.getaddrinfo
m_sock = m_socket.socket.return_value = unittest.mock.Mock() m_sock = m_socket.socket.return_value = mock.Mock()
m_sock.bind.side_effect = Err m_sock.bind.side_effect = Err
fut = self.loop.create_datagram_endpoint( fut = self.loop.create_datagram_endpoint(
@ -882,19 +882,19 @@ class Err(OSError):
self.assertTrue(m_sock.close.called) self.assertTrue(m_sock.close.called)
def test_accept_connection_retry(self): def test_accept_connection_retry(self):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.accept.side_effect = BlockingIOError() sock.accept.side_effect = BlockingIOError()
self.loop._accept_connection(MyProto, sock) self.loop._accept_connection(MyProto, sock)
self.assertFalse(sock.close.called) self.assertFalse(sock.close.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_accept_connection_exception(self, m_log): def test_accept_connection_exception(self, m_log):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.accept.side_effect = OSError(errno.EMFILE, 'Too many open files') sock.accept.side_effect = OSError(errno.EMFILE, 'Too many open files')
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop.call_later = unittest.mock.Mock() self.loop.call_later = mock.Mock()
self.loop._accept_connection(MyProto, sock) self.loop._accept_connection(MyProto, sock)
self.assertTrue(m_log.error.called) self.assertTrue(m_log.error.called)
@ -902,7 +902,7 @@ def test_accept_connection_exception(self, m_log):
self.loop.remove_reader.assert_called_with(10) self.loop.remove_reader.assert_called_with(10)
self.loop.call_later.assert_called_with(constants.ACCEPT_RETRY_DELAY, self.loop.call_later.assert_called_with(constants.ACCEPT_RETRY_DELAY,
# self.loop._start_serving # self.loop._start_serving
unittest.mock.ANY, mock.ANY,
MyProto, sock, None, None) MyProto, sock, None, None)
def test_call_coroutine(self): def test_call_coroutine(self):

455
Lib/test/test_asyncio/test_events.py
View file

@ -20,12 +20,11 @@
import time import time
import errno import errno
import unittest import unittest
import unittest.mock from unittest import mock
from test import support # find_unused_port, IPV6_ENABLED, TEST_HOME_DIR from test import support # find_unused_port, IPV6_ENABLED, TEST_HOME_DIR
import asyncio import asyncio
from asyncio import events
from asyncio import selector_events from asyncio import selector_events
from asyncio import test_utils from asyncio import test_utils
@ -57,6 +56,7 @@ def osx_tiger():
class MyBaseProto(asyncio.Protocol): class MyBaseProto(asyncio.Protocol):
connected = None
done = None done = None
def __init__(self, loop=None): def __init__(self, loop=None):
@ -64,12 +64,15 @@ def __init__(self, loop=None):
self.state = 'INITIAL' self.state = 'INITIAL'
self.nbytes = 0 self.nbytes = 0
if loop is not None: if loop is not None:
self.connected = asyncio.Future(loop=loop)
self.done = asyncio.Future(loop=loop) self.done = asyncio.Future(loop=loop)
def connection_made(self, transport): def connection_made(self, transport):
self.transport = transport self.transport = transport
assert self.state == 'INITIAL', self.state assert self.state == 'INITIAL', self.state
self.state = 'CONNECTED' self.state = 'CONNECTED'
if self.connected:
self.connected.set_result(None)
def data_received(self, data): def data_received(self, data):
assert self.state == 'CONNECTED', self.state assert self.state == 'CONNECTED', self.state
@ -331,7 +334,8 @@ def run(arg):
def test_reader_callback(self): def test_reader_callback(self):
r, w = test_utils.socketpair() r, w = test_utils.socketpair()
bytes_read = [] r.setblocking(False)
bytes_read = bytearray()
def reader(): def reader():
try: try:
@ -341,37 +345,40 @@ def reader():
# at least on Linux -- see man select. # at least on Linux -- see man select.
return return
if data: if data:
bytes_read.append(data) bytes_read.extend(data)
else: else:
self.assertTrue(self.loop.remove_reader(r.fileno())) self.assertTrue(self.loop.remove_reader(r.fileno()))
r.close() r.close()
self.loop.add_reader(r.fileno(), reader) self.loop.add_reader(r.fileno(), reader)
self.loop.call_soon(w.send, b'abc') self.loop.call_soon(w.send, b'abc')
test_utils.run_briefly(self.loop) test_utils.run_until(self.loop, lambda: len(bytes_read) >= 3)
self.loop.call_soon(w.send, b'def') self.loop.call_soon(w.send, b'def')
test_utils.run_briefly(self.loop) test_utils.run_until(self.loop, lambda: len(bytes_read) >= 6)
self.loop.call_soon(w.close) self.loop.call_soon(w.close)
self.loop.call_soon(self.loop.stop) self.loop.call_soon(self.loop.stop)
self.loop.run_forever() self.loop.run_forever()
self.assertEqual(b''.join(bytes_read), b'abcdef') self.assertEqual(bytes_read, b'abcdef')
def test_writer_callback(self): def test_writer_callback(self):
r, w = test_utils.socketpair() r, w = test_utils.socketpair()
w.setblocking(False) w.setblocking(False)
self.loop.add_writer(w.fileno(), w.send, b'x'*(256*1024))
test_utils.run_briefly(self.loop)
def remove_writer(): def writer(data):
self.assertTrue(self.loop.remove_writer(w.fileno())) w.send(data)
self.loop.stop()
self.loop.call_soon(remove_writer) data = b'x' * 1024
self.loop.call_soon(self.loop.stop) self.loop.add_writer(w.fileno(), writer, data)
self.loop.run_forever() self.loop.run_forever()
self.assertTrue(self.loop.remove_writer(w.fileno()))
self.assertFalse(self.loop.remove_writer(w.fileno()))
w.close() w.close()
data = r.recv(256*1024) read = r.recv(len(data) * 2)
r.close() r.close()
self.assertGreaterEqual(len(data), 200) self.assertEqual(read, data)
def _basetest_sock_client_ops(self, httpd, sock): def _basetest_sock_client_ops(self, httpd, sock):
sock.setblocking(False) sock.setblocking(False)
@ -465,10 +472,10 @@ def my_handler():
self.assertFalse(self.loop.remove_signal_handler(signal.SIGKILL)) self.assertFalse(self.loop.remove_signal_handler(signal.SIGKILL))
# Now set a handler and handle it. # Now set a handler and handle it.
self.loop.add_signal_handler(signal.SIGINT, my_handler) self.loop.add_signal_handler(signal.SIGINT, my_handler)
test_utils.run_briefly(self.loop)
os.kill(os.getpid(), signal.SIGINT) os.kill(os.getpid(), signal.SIGINT)
test_utils.run_briefly(self.loop) test_utils.run_until(self.loop, lambda: caught)
self.assertEqual(caught, 1)
# Removing it should restore the default handler. # Removing it should restore the default handler.
self.assertTrue(self.loop.remove_signal_handler(signal.SIGINT)) self.assertTrue(self.loop.remove_signal_handler(signal.SIGINT))
self.assertEqual(signal.getsignal(signal.SIGINT), self.assertEqual(signal.getsignal(signal.SIGINT),
@ -624,7 +631,7 @@ def test_create_connection_local_addr_in_use(self):
self.assertIn(str(httpd.address), cm.exception.strerror) self.assertIn(str(httpd.address), cm.exception.strerror)
def test_create_server(self): def test_create_server(self):
proto = MyProto() proto = MyProto(self.loop)
f = self.loop.create_server(lambda: proto, '0.0.0.0', 0) f = self.loop.create_server(lambda: proto, '0.0.0.0', 0)
server = self.loop.run_until_complete(f) server = self.loop.run_until_complete(f)
self.assertEqual(len(server.sockets), 1) self.assertEqual(len(server.sockets), 1)
@ -634,14 +641,11 @@ def test_create_server(self):
client = socket.socket() client = socket.socket()
client.connect(('127.0.0.1', port)) client.connect(('127.0.0.1', port))
client.sendall(b'xxx') client.sendall(b'xxx')
test_utils.run_briefly(self.loop)
test_utils.run_until(self.loop, lambda: proto is not None, 10) self.loop.run_until_complete(proto.connected)
self.assertIsInstance(proto, MyProto)
self.assertEqual('INITIAL', proto.state)
test_utils.run_briefly(self.loop)
self.assertEqual('CONNECTED', proto.state) self.assertEqual('CONNECTED', proto.state)
test_utils.run_until(self.loop, lambda: proto.nbytes > 0,
timeout=10) test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
self.assertEqual(3, proto.nbytes) self.assertEqual(3, proto.nbytes)
# extra info is available # extra info is available
@ -651,7 +655,7 @@ def test_create_server(self):
# close connection # close connection
proto.transport.close() proto.transport.close()
test_utils.run_briefly(self.loop) # windows iocp self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state) self.assertEqual('CLOSED', proto.state)
@ -673,27 +677,22 @@ def _make_unix_server(self, factory, **kwargs):
@unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'No UNIX Sockets') @unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'No UNIX Sockets')
def test_create_unix_server(self): def test_create_unix_server(self):
proto = MyProto() proto = MyProto(loop=self.loop)
server, path = self._make_unix_server(lambda: proto) server, path = self._make_unix_server(lambda: proto)
self.assertEqual(len(server.sockets), 1) self.assertEqual(len(server.sockets), 1)
client = socket.socket(socket.AF_UNIX) client = socket.socket(socket.AF_UNIX)
client.connect(path) client.connect(path)
client.sendall(b'xxx') client.sendall(b'xxx')
test_utils.run_briefly(self.loop)
test_utils.run_until(self.loop, lambda: proto is not None, 10)
self.assertIsInstance(proto, MyProto) self.loop.run_until_complete(proto.connected)
self.assertEqual('INITIAL', proto.state)
test_utils.run_briefly(self.loop)
self.assertEqual('CONNECTED', proto.state) self.assertEqual('CONNECTED', proto.state)
test_utils.run_until(self.loop, lambda: proto.nbytes > 0, test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
timeout=10)
self.assertEqual(3, proto.nbytes) self.assertEqual(3, proto.nbytes)
# close connection # close connection
proto.transport.close() proto.transport.close()
test_utils.run_briefly(self.loop) # windows iocp self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state) self.assertEqual('CLOSED', proto.state)
@ -736,12 +735,10 @@ def test_create_server_ssl(self):
client, pr = self.loop.run_until_complete(f_c) client, pr = self.loop.run_until_complete(f_c)
client.write(b'xxx') client.write(b'xxx')
test_utils.run_briefly(self.loop) self.loop.run_until_complete(proto.connected)
self.assertIsInstance(proto, MyProto)
test_utils.run_briefly(self.loop)
self.assertEqual('CONNECTED', proto.state) self.assertEqual('CONNECTED', proto.state)
test_utils.run_until(self.loop, lambda: proto.nbytes > 0,
timeout=10) test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
self.assertEqual(3, proto.nbytes) self.assertEqual(3, proto.nbytes)
# extra info is available # extra info is available
@ -775,12 +772,9 @@ def test_create_unix_server_ssl(self):
client, pr = self.loop.run_until_complete(f_c) client, pr = self.loop.run_until_complete(f_c)
client.write(b'xxx') client.write(b'xxx')
test_utils.run_briefly(self.loop) self.loop.run_until_complete(proto.connected)
self.assertIsInstance(proto, MyProto)
test_utils.run_briefly(self.loop)
self.assertEqual('CONNECTED', proto.state) self.assertEqual('CONNECTED', proto.state)
test_utils.run_until(self.loop, lambda: proto.nbytes > 0, test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
timeout=10)
self.assertEqual(3, proto.nbytes) self.assertEqual(3, proto.nbytes)
# close connection # close connection
@ -1045,15 +1039,9 @@ def datagram_received(self, data, addr):
self.assertEqual('INITIALIZED', client.state) self.assertEqual('INITIALIZED', client.state)
transport.sendto(b'xxx') transport.sendto(b'xxx')
for _ in range(1000): test_utils.run_until(self.loop, lambda: server.nbytes)
if server.nbytes:
break
test_utils.run_briefly(self.loop)
self.assertEqual(3, server.nbytes) self.assertEqual(3, server.nbytes)
for _ in range(1000): test_utils.run_until(self.loop, lambda: client.nbytes)
if client.nbytes:
break
test_utils.run_briefly(self.loop)
# received # received
self.assertEqual(8, client.nbytes) self.assertEqual(8, client.nbytes)
@ -1098,11 +1086,11 @@ def connect():
self.loop.run_until_complete(connect()) self.loop.run_until_complete(connect())
os.write(wpipe, b'1') os.write(wpipe, b'1')
test_utils.run_briefly(self.loop) test_utils.run_until(self.loop, lambda: proto.nbytes >= 1)
self.assertEqual(1, proto.nbytes) self.assertEqual(1, proto.nbytes)
os.write(wpipe, b'2345') os.write(wpipe, b'2345')
test_utils.run_briefly(self.loop) test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state) self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes) self.assertEqual(5, proto.nbytes)
@ -1156,33 +1144,30 @@ def connect():
@unittest.skipUnless(sys.platform != 'win32', @unittest.skipUnless(sys.platform != 'win32',
"Don't support pipes for Windows") "Don't support pipes for Windows")
def test_write_pipe(self): def test_write_pipe(self):
proto = MyWritePipeProto(loop=self.loop)
transport = None
rpipe, wpipe = os.pipe() rpipe, wpipe = os.pipe()
pipeobj = io.open(wpipe, 'wb', 1024) pipeobj = io.open(wpipe, 'wb', 1024)
@asyncio.coroutine proto = MyWritePipeProto(loop=self.loop)
def connect(): connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
nonlocal transport transport, p = self.loop.run_until_complete(connect)
t, p = yield from self.loop.connect_write_pipe( self.assertIs(p, proto)
lambda: proto, pipeobj) self.assertIs(transport, proto.transport)
self.assertIs(p, proto) self.assertEqual('CONNECTED', proto.state)
self.assertIs(t, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport = t
self.loop.run_until_complete(connect())
transport.write(b'1') transport.write(b'1')
test_utils.run_briefly(self.loop)
data = os.read(rpipe, 1024) data = bytearray()
def reader(data):
chunk = os.read(rpipe, 1024)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1)
self.assertEqual(b'1', data) self.assertEqual(b'1', data)
transport.write(b'2345') transport.write(b'2345')
test_utils.run_briefly(self.loop) test_utils.run_until(self.loop, lambda: reader(data) >= 5)
data = os.read(rpipe, 1024) self.assertEqual(b'12345', data)
self.assertEqual(b'2345', data)
self.assertEqual('CONNECTED', proto.state) self.assertEqual('CONNECTED', proto.state)
os.close(rpipe) os.close(rpipe)
@ -1198,23 +1183,14 @@ def connect():
@unittest.skipUnless(sys.platform != 'win32', @unittest.skipUnless(sys.platform != 'win32',
"Don't support pipes for Windows") "Don't support pipes for Windows")
def test_write_pipe_disconnect_on_close(self): def test_write_pipe_disconnect_on_close(self):
proto = MyWritePipeProto(loop=self.loop)
transport = None
rsock, wsock = test_utils.socketpair() rsock, wsock = test_utils.socketpair()
pipeobj = io.open(wsock.detach(), 'wb', 1024) pipeobj = io.open(wsock.detach(), 'wb', 1024)
@asyncio.coroutine proto = MyWritePipeProto(loop=self.loop)
def connect(): connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
nonlocal transport transport, p = self.loop.run_until_complete(connect)
t, p = yield from self.loop.connect_write_pipe(lambda: proto, self.assertIs(p, proto)
pipeobj) self.assertIs(transport, proto.transport)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport = t
self.loop.run_until_complete(connect())
self.assertEqual('CONNECTED', proto.state) self.assertEqual('CONNECTED', proto.state)
transport.write(b'1') transport.write(b'1')
@ -1232,33 +1208,32 @@ def connect():
# older than 10.6 (Snow Leopard) # older than 10.6 (Snow Leopard)
@support.requires_mac_ver(10, 6) @support.requires_mac_ver(10, 6)
def test_write_pty(self): def test_write_pty(self):
proto = MyWritePipeProto(loop=self.loop)
transport = None
master, slave = os.openpty() master, slave = os.openpty()
slave_write_obj = io.open(slave, 'wb', 0) slave_write_obj = io.open(slave, 'wb', 0)
@asyncio.coroutine proto = MyWritePipeProto(loop=self.loop)
def connect(): connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
nonlocal transport transport, p = self.loop.run_until_complete(connect)
t, p = yield from self.loop.connect_write_pipe(lambda: proto, self.assertIs(p, proto)
slave_write_obj) self.assertIs(transport, proto.transport)
self.assertIs(p, proto) self.assertEqual('CONNECTED', proto.state)
self.assertIs(t, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport = t
self.loop.run_until_complete(connect())
transport.write(b'1') transport.write(b'1')
test_utils.run_briefly(self.loop)
data = os.read(master, 1024) data = bytearray()
def reader(data):
chunk = os.read(master, 1024)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1,
timeout=10)
self.assertEqual(b'1', data) self.assertEqual(b'1', data)
transport.write(b'2345') transport.write(b'2345')
test_utils.run_briefly(self.loop) test_utils.run_until(self.loop, lambda: reader(data) >= 5,
data = os.read(master, 1024) timeout=10)
self.assertEqual(b'2345', data) self.assertEqual(b'12345', data)
self.assertEqual('CONNECTED', proto.state) self.assertEqual('CONNECTED', proto.state)
os.close(master) os.close(master)
@ -1352,6 +1327,30 @@ def test_sock_connect_address(self):
self.assertIn('address must be resolved', self.assertIn('address must be resolved',
str(cm.exception)) str(cm.exception))
def test_remove_fds_after_closing(self):
loop = self.create_event_loop()
callback = lambda: None
r, w = test_utils.socketpair()
self.addCleanup(r.close)
self.addCleanup(w.close)
loop.add_reader(r, callback)
loop.add_writer(w, callback)
loop.close()
self.assertFalse(loop.remove_reader(r))
self.assertFalse(loop.remove_writer(w))
def test_add_fds_after_closing(self):
loop = self.create_event_loop()
callback = lambda: None
r, w = test_utils.socketpair()
self.addCleanup(r.close)
self.addCleanup(w.close)
loop.close()
with self.assertRaises(RuntimeError):
loop.add_reader(r, callback)
with self.assertRaises(RuntimeError):
loop.add_writer(w, callback)
class SubprocessTestsMixin: class SubprocessTestsMixin:
@ -1370,20 +1369,13 @@ def check_killed(self, returncode):
self.assertEqual(-signal.SIGKILL, returncode) self.assertEqual(-signal.SIGKILL, returncode)
def test_subprocess_exec(self): def test_subprocess_exec(self):
proto = None
transp = None
prog = os.path.join(os.path.dirname(__file__), 'echo.py') prog = os.path.join(os.path.dirname(__file__), 'echo.py')
@asyncio.coroutine connect = self.loop.subprocess_exec(
def connect(): functools.partial(MySubprocessProtocol, self.loop),
nonlocal proto, transp sys.executable, prog)
transp, proto = yield from self.loop.subprocess_exec( transp, proto = self.loop.run_until_complete(connect)
functools.partial(MySubprocessProtocol, self.loop), self.assertIsInstance(proto, MySubprocessProtocol)
sys.executable, prog)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.connected) self.loop.run_until_complete(proto.connected)
self.assertEqual('CONNECTED', proto.state) self.assertEqual('CONNECTED', proto.state)
@ -1396,20 +1388,13 @@ def connect():
self.assertEqual(b'Python The Winner', proto.data[1]) self.assertEqual(b'Python The Winner', proto.data[1])
def test_subprocess_interactive(self): def test_subprocess_interactive(self):
proto = None
transp = None
prog = os.path.join(os.path.dirname(__file__), 'echo.py') prog = os.path.join(os.path.dirname(__file__), 'echo.py')
@asyncio.coroutine connect = self.loop.subprocess_exec(
def connect(): functools.partial(MySubprocessProtocol, self.loop),
nonlocal proto, transp sys.executable, prog)
transp, proto = yield from self.loop.subprocess_exec( transp, proto = self.loop.run_until_complete(connect)
functools.partial(MySubprocessProtocol, self.loop), self.assertIsInstance(proto, MySubprocessProtocol)
sys.executable, prog)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.connected) self.loop.run_until_complete(proto.connected)
self.assertEqual('CONNECTED', proto.state) self.assertEqual('CONNECTED', proto.state)
@ -1430,18 +1415,11 @@ def connect():
self.check_terminated(proto.returncode) self.check_terminated(proto.returncode)
def test_subprocess_shell(self): def test_subprocess_shell(self):
proto = None connect = self.loop.subprocess_shell(
transp = None functools.partial(MySubprocessProtocol, self.loop),
'echo Python')
@asyncio.coroutine transp, proto = self.loop.run_until_complete(connect)
def connect(): self.assertIsInstance(proto, MySubprocessProtocol)
nonlocal proto, transp
transp, proto = yield from self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
'echo Python')
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.connected) self.loop.run_until_complete(proto.connected)
transp.get_pipe_transport(0).close() transp.get_pipe_transport(0).close()
@ -1452,33 +1430,20 @@ def connect():
self.assertEqual(proto.data[2], b'') self.assertEqual(proto.data[2], b'')
def test_subprocess_exitcode(self): def test_subprocess_exitcode(self):
proto = None connect = self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
@asyncio.coroutine 'exit 7', stdin=None, stdout=None, stderr=None)
def connect(): transp, proto = self.loop.run_until_complete(connect)
nonlocal proto self.assertIsInstance(proto, MySubprocessProtocol)
transp, proto = yield from self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
'exit 7', stdin=None, stdout=None, stderr=None)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.completed) self.loop.run_until_complete(proto.completed)
self.assertEqual(7, proto.returncode) self.assertEqual(7, proto.returncode)
def test_subprocess_close_after_finish(self): def test_subprocess_close_after_finish(self):
proto = None connect = self.loop.subprocess_shell(
transp = None functools.partial(MySubprocessProtocol, self.loop),
'exit 7', stdin=None, stdout=None, stderr=None)
@asyncio.coroutine transp, proto = self.loop.run_until_complete(connect)
def connect(): self.assertIsInstance(proto, MySubprocessProtocol)
nonlocal proto, transp
transp, proto = yield from self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
'exit 7', stdin=None, stdout=None, stderr=None)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.assertIsNone(transp.get_pipe_transport(0)) self.assertIsNone(transp.get_pipe_transport(0))
self.assertIsNone(transp.get_pipe_transport(1)) self.assertIsNone(transp.get_pipe_transport(1))
self.assertIsNone(transp.get_pipe_transport(2)) self.assertIsNone(transp.get_pipe_transport(2))
@ -1487,20 +1452,13 @@ def connect():
self.assertIsNone(transp.close()) self.assertIsNone(transp.close())
def test_subprocess_kill(self): def test_subprocess_kill(self):
proto = None
transp = None
prog = os.path.join(os.path.dirname(__file__), 'echo.py') prog = os.path.join(os.path.dirname(__file__), 'echo.py')
@asyncio.coroutine connect = self.loop.subprocess_exec(
def connect(): functools.partial(MySubprocessProtocol, self.loop),
nonlocal proto, transp sys.executable, prog)
transp, proto = yield from self.loop.subprocess_exec( transp, proto = self.loop.run_until_complete(connect)
functools.partial(MySubprocessProtocol, self.loop), self.assertIsInstance(proto, MySubprocessProtocol)
sys.executable, prog)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.connected) self.loop.run_until_complete(proto.connected)
transp.kill() transp.kill()
@ -1508,20 +1466,13 @@ def connect():
self.check_killed(proto.returncode) self.check_killed(proto.returncode)
def test_subprocess_terminate(self): def test_subprocess_terminate(self):
proto = None
transp = None
prog = os.path.join(os.path.dirname(__file__), 'echo.py') prog = os.path.join(os.path.dirname(__file__), 'echo.py')
@asyncio.coroutine connect = self.loop.subprocess_exec(
def connect(): functools.partial(MySubprocessProtocol, self.loop),
nonlocal proto, transp sys.executable, prog)
transp, proto = yield from self.loop.subprocess_exec( transp, proto = self.loop.run_until_complete(connect)
functools.partial(MySubprocessProtocol, self.loop), self.assertIsInstance(proto, MySubprocessProtocol)
sys.executable, prog)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.connected) self.loop.run_until_complete(proto.connected)
transp.terminate() transp.terminate()
@ -1530,20 +1481,13 @@ def connect():
@unittest.skipIf(sys.platform == 'win32', "Don't have SIGHUP") @unittest.skipIf(sys.platform == 'win32', "Don't have SIGHUP")
def test_subprocess_send_signal(self): def test_subprocess_send_signal(self):
proto = None
transp = None
prog = os.path.join(os.path.dirname(__file__), 'echo.py') prog = os.path.join(os.path.dirname(__file__), 'echo.py')
@asyncio.coroutine connect = self.loop.subprocess_exec(
def connect(): functools.partial(MySubprocessProtocol, self.loop),
nonlocal proto, transp sys.executable, prog)
transp, proto = yield from self.loop.subprocess_exec( transp, proto = self.loop.run_until_complete(connect)
functools.partial(MySubprocessProtocol, self.loop), self.assertIsInstance(proto, MySubprocessProtocol)
sys.executable, prog)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.connected) self.loop.run_until_complete(proto.connected)
transp.send_signal(signal.SIGHUP) transp.send_signal(signal.SIGHUP)
@ -1551,20 +1495,13 @@ def connect():
self.assertEqual(-signal.SIGHUP, proto.returncode) self.assertEqual(-signal.SIGHUP, proto.returncode)
def test_subprocess_stderr(self): def test_subprocess_stderr(self):
proto = None
transp = None
prog = os.path.join(os.path.dirname(__file__), 'echo2.py') prog = os.path.join(os.path.dirname(__file__), 'echo2.py')
@asyncio.coroutine connect = self.loop.subprocess_exec(
def connect(): functools.partial(MySubprocessProtocol, self.loop),
nonlocal proto, transp sys.executable, prog)
transp, proto = yield from self.loop.subprocess_exec( transp, proto = self.loop.run_until_complete(connect)
functools.partial(MySubprocessProtocol, self.loop), self.assertIsInstance(proto, MySubprocessProtocol)
sys.executable, prog)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.connected) self.loop.run_until_complete(proto.connected)
stdin = transp.get_pipe_transport(0) stdin = transp.get_pipe_transport(0)
@ -1578,20 +1515,13 @@ def connect():
self.assertEqual(0, proto.returncode) self.assertEqual(0, proto.returncode)
def test_subprocess_stderr_redirect_to_stdout(self): def test_subprocess_stderr_redirect_to_stdout(self):
proto = None
transp = None
prog = os.path.join(os.path.dirname(__file__), 'echo2.py') prog = os.path.join(os.path.dirname(__file__), 'echo2.py')
@asyncio.coroutine connect = self.loop.subprocess_exec(
def connect(): functools.partial(MySubprocessProtocol, self.loop),
nonlocal proto, transp sys.executable, prog, stderr=subprocess.STDOUT)
transp, proto = yield from self.loop.subprocess_exec( transp, proto = self.loop.run_until_complete(connect)
functools.partial(MySubprocessProtocol, self.loop), self.assertIsInstance(proto, MySubprocessProtocol)
sys.executable, prog, stderr=subprocess.STDOUT)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.connected) self.loop.run_until_complete(proto.connected)
stdin = transp.get_pipe_transport(0) stdin = transp.get_pipe_transport(0)
@ -1608,20 +1538,13 @@ def connect():
self.assertEqual(0, proto.returncode) self.assertEqual(0, proto.returncode)
def test_subprocess_close_client_stream(self): def test_subprocess_close_client_stream(self):
proto = None
transp = None
prog = os.path.join(os.path.dirname(__file__), 'echo3.py') prog = os.path.join(os.path.dirname(__file__), 'echo3.py')
@asyncio.coroutine connect = self.loop.subprocess_exec(
def connect(): functools.partial(MySubprocessProtocol, self.loop),
nonlocal proto, transp sys.executable, prog)
transp, proto = yield from self.loop.subprocess_exec( transp, proto = self.loop.run_until_complete(connect)
functools.partial(MySubprocessProtocol, self.loop), self.assertIsInstance(proto, MySubprocessProtocol)
sys.executable, prog)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.connected) self.loop.run_until_complete(proto.connected)
stdin = transp.get_pipe_transport(0) stdin = transp.get_pipe_transport(0)
@ -1647,20 +1570,13 @@ def connect():
self.check_terminated(proto.returncode) self.check_terminated(proto.returncode)
def test_subprocess_wait_no_same_group(self): def test_subprocess_wait_no_same_group(self):
proto = None # start the new process in a new session
transp = None connect = self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
@asyncio.coroutine 'exit 7', stdin=None, stdout=None, stderr=None,
def connect(): start_new_session=True)
nonlocal proto _, proto = yield self.loop.run_until_complete(connect)
# start the new process in a new session self.assertIsInstance(proto, MySubprocessProtocol)
transp, proto = yield from self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
'exit 7', stdin=None, stdout=None, stderr=None,
start_new_session=True)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(connect())
self.loop.run_until_complete(proto.completed) self.loop.run_until_complete(proto.completed)
self.assertEqual(7, proto.returncode) self.assertEqual(7, proto.returncode)
@ -1741,6 +1657,9 @@ def test_writer_callback_cancel(self):
def test_create_datagram_endpoint(self): def test_create_datagram_endpoint(self):
raise unittest.SkipTest( raise unittest.SkipTest(
"IocpEventLoop does not have create_datagram_endpoint()") "IocpEventLoop does not have create_datagram_endpoint()")
def test_remove_fds_after_closing(self):
raise unittest.SkipTest("IocpEventLoop does not have add_reader()")
else: else:
from asyncio import selectors from asyncio import selectors
@ -1812,7 +1731,7 @@ def callback(*args):
return args return args
args = () args = ()
h = asyncio.Handle(callback, args, unittest.mock.Mock()) h = asyncio.Handle(callback, args, mock.Mock())
self.assertIs(h._callback, callback) self.assertIs(h._callback, callback)
self.assertIs(h._args, args) self.assertIs(h._args, args)
self.assertFalse(h._cancelled) self.assertFalse(h._cancelled)
@ -1844,15 +1763,15 @@ def test_callback_with_exception(self):
def callback(): def callback():
raise ValueError() raise ValueError()
m_loop = unittest.mock.Mock() m_loop = mock.Mock()
m_loop.call_exception_handler = unittest.mock.Mock() m_loop.call_exception_handler = mock.Mock()
h = asyncio.Handle(callback, (), m_loop) h = asyncio.Handle(callback, (), m_loop)
h._run() h._run()
m_loop.call_exception_handler.assert_called_with({ m_loop.call_exception_handler.assert_called_with({
'message': test_utils.MockPattern('Exception in callback.*'), 'message': test_utils.MockPattern('Exception in callback.*'),
'exception': unittest.mock.ANY, 'exception': mock.ANY,
'handle': h 'handle': h
}) })
@ -1862,7 +1781,7 @@ class TimerTests(unittest.TestCase):
def test_hash(self): def test_hash(self):
when = time.monotonic() when = time.monotonic()
h = asyncio.TimerHandle(when, lambda: False, (), h = asyncio.TimerHandle(when, lambda: False, (),
unittest.mock.Mock()) mock.Mock())
self.assertEqual(hash(h), hash(when)) self.assertEqual(hash(h), hash(when))
def test_timer(self): def test_timer(self):
@ -1871,7 +1790,7 @@ def callback(*args):
args = () args = ()
when = time.monotonic() when = time.monotonic()
h = asyncio.TimerHandle(when, callback, args, unittest.mock.Mock()) h = asyncio.TimerHandle(when, callback, args, mock.Mock())
self.assertIs(h._callback, callback) self.assertIs(h._callback, callback)
self.assertIs(h._args, args) self.assertIs(h._args, args)
self.assertFalse(h._cancelled) self.assertFalse(h._cancelled)
@ -1887,10 +1806,10 @@ def callback(*args):
self.assertRaises(AssertionError, self.assertRaises(AssertionError,
asyncio.TimerHandle, None, callback, args, asyncio.TimerHandle, None, callback, args,
unittest.mock.Mock()) mock.Mock())
def test_timer_comparison(self): def test_timer_comparison(self):
loop = unittest.mock.Mock() loop = mock.Mock()
def callback(*args): def callback(*args):
return args return args
@ -1935,7 +1854,7 @@ def callback(*args):
class AbstractEventLoopTests(unittest.TestCase): class AbstractEventLoopTests(unittest.TestCase):
def test_not_implemented(self): def test_not_implemented(self):
f = unittest.mock.Mock() f = mock.Mock()
loop = asyncio.AbstractEventLoop() loop = asyncio.AbstractEventLoop()
self.assertRaises( self.assertRaises(
NotImplementedError, loop.run_forever) NotImplementedError, loop.run_forever)
@ -1995,13 +1914,13 @@ def test_not_implemented(self):
NotImplementedError, loop.remove_signal_handler, 1) NotImplementedError, loop.remove_signal_handler, 1)
self.assertRaises( self.assertRaises(
NotImplementedError, loop.connect_read_pipe, f, NotImplementedError, loop.connect_read_pipe, f,
unittest.mock.sentinel.pipe) mock.sentinel.pipe)
self.assertRaises( self.assertRaises(
NotImplementedError, loop.connect_write_pipe, f, NotImplementedError, loop.connect_write_pipe, f,
unittest.mock.sentinel.pipe) mock.sentinel.pipe)
self.assertRaises( self.assertRaises(
NotImplementedError, loop.subprocess_shell, f, NotImplementedError, loop.subprocess_shell, f,
unittest.mock.sentinel) mock.sentinel)
self.assertRaises( self.assertRaises(
NotImplementedError, loop.subprocess_exec, f) NotImplementedError, loop.subprocess_exec, f)
@ -2009,7 +1928,7 @@ def test_not_implemented(self):
class ProtocolsAbsTests(unittest.TestCase): class ProtocolsAbsTests(unittest.TestCase):
def test_empty(self): def test_empty(self):
f = unittest.mock.Mock() f = mock.Mock()
p = asyncio.Protocol() p = asyncio.Protocol()
self.assertIsNone(p.connection_made(f)) self.assertIsNone(p.connection_made(f))
self.assertIsNone(p.connection_lost(f)) self.assertIsNone(p.connection_lost(f))
@ -2055,7 +1974,7 @@ def test_get_event_loop(self):
def test_get_event_loop_calls_set_event_loop(self): def test_get_event_loop_calls_set_event_loop(self):
policy = asyncio.DefaultEventLoopPolicy() policy = asyncio.DefaultEventLoopPolicy()
with unittest.mock.patch.object( with mock.patch.object(
policy, "set_event_loop", policy, "set_event_loop",
wraps=policy.set_event_loop) as m_set_event_loop: wraps=policy.set_event_loop) as m_set_event_loop:
@ -2073,7 +1992,7 @@ def test_get_event_loop_after_set_none(self):
policy.set_event_loop(None) policy.set_event_loop(None)
self.assertRaises(AssertionError, policy.get_event_loop) self.assertRaises(AssertionError, policy.get_event_loop)
@unittest.mock.patch('asyncio.events.threading.current_thread') @mock.patch('asyncio.events.threading.current_thread')
def test_get_event_loop_thread(self, m_current_thread): def test_get_event_loop_thread(self, m_current_thread):
def f(): def f():

16
Lib/test/test_asyncio/test_futures.py
View file

@ -3,7 +3,7 @@
import concurrent.futures import concurrent.futures
import threading import threading
import unittest import unittest
import unittest.mock from unittest import mock
import asyncio import asyncio
from asyncio import test_utils from asyncio import test_utils
@ -174,20 +174,20 @@ def test():
self.assertRaises(AssertionError, test) self.assertRaises(AssertionError, test)
fut.cancel() fut.cancel()
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_abandoned(self, m_log): def test_tb_logger_abandoned(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
del fut del fut
self.assertFalse(m_log.error.called) self.assertFalse(m_log.error.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_result_unretrieved(self, m_log): def test_tb_logger_result_unretrieved(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
fut.set_result(42) fut.set_result(42)
del fut del fut
self.assertFalse(m_log.error.called) self.assertFalse(m_log.error.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_result_retrieved(self, m_log): def test_tb_logger_result_retrieved(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
fut.set_result(42) fut.set_result(42)
@ -195,7 +195,7 @@ def test_tb_logger_result_retrieved(self, m_log):
del fut del fut
self.assertFalse(m_log.error.called) self.assertFalse(m_log.error.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_exception_unretrieved(self, m_log): def test_tb_logger_exception_unretrieved(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
fut.set_exception(RuntimeError('boom')) fut.set_exception(RuntimeError('boom'))
@ -203,7 +203,7 @@ def test_tb_logger_exception_unretrieved(self, m_log):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.assertTrue(m_log.error.called) self.assertTrue(m_log.error.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_exception_retrieved(self, m_log): def test_tb_logger_exception_retrieved(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
fut.set_exception(RuntimeError('boom')) fut.set_exception(RuntimeError('boom'))
@ -211,7 +211,7 @@ def test_tb_logger_exception_retrieved(self, m_log):
del fut del fut
self.assertFalse(m_log.error.called) self.assertFalse(m_log.error.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_tb_logger_exception_result_retrieved(self, m_log): def test_tb_logger_exception_result_retrieved(self, m_log):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
fut.set_exception(RuntimeError('boom')) fut.set_exception(RuntimeError('boom'))
@ -236,7 +236,7 @@ def test_wrap_future_future(self):
f2 = asyncio.wrap_future(f1) f2 = asyncio.wrap_future(f1)
self.assertIs(f1, f2) self.assertIs(f1, f2)
@unittest.mock.patch('asyncio.futures.events') @mock.patch('asyncio.futures.events')
def test_wrap_future_use_global_loop(self, m_events): def test_wrap_future_use_global_loop(self, m_events):
def run(arg): def run(arg):
return (arg, threading.get_ident()) return (arg, threading.get_ident())

20
Lib/test/test_asyncio/test_locks.py
View file

@ -1,7 +1,7 @@
"""Tests for lock.py""" """Tests for lock.py"""
import unittest import unittest
import unittest.mock from unittest import mock
import re import re
import asyncio import asyncio
@ -27,7 +27,7 @@ def tearDown(self):
self.loop.close() self.loop.close()
def test_ctor_loop(self): def test_ctor_loop(self):
loop = unittest.mock.Mock() loop = mock.Mock()
lock = asyncio.Lock(loop=loop) lock = asyncio.Lock(loop=loop)
self.assertIs(lock._loop, loop) self.assertIs(lock._loop, loop)
@ -250,7 +250,7 @@ def tearDown(self):
self.loop.close() self.loop.close()
def test_ctor_loop(self): def test_ctor_loop(self):
loop = unittest.mock.Mock() loop = mock.Mock()
ev = asyncio.Event(loop=loop) ev = asyncio.Event(loop=loop)
self.assertIs(ev._loop, loop) self.assertIs(ev._loop, loop)
@ -275,7 +275,7 @@ def test_repr(self):
self.assertTrue(repr(ev).endswith('[set]>')) self.assertTrue(repr(ev).endswith('[set]>'))
self.assertTrue(RGX_REPR.match(repr(ev))) self.assertTrue(RGX_REPR.match(repr(ev)))
ev._waiters.append(unittest.mock.Mock()) ev._waiters.append(mock.Mock())
self.assertTrue('waiters:1' in repr(ev)) self.assertTrue('waiters:1' in repr(ev))
self.assertTrue(RGX_REPR.match(repr(ev))) self.assertTrue(RGX_REPR.match(repr(ev)))
@ -386,7 +386,7 @@ def tearDown(self):
self.loop.close() self.loop.close()
def test_ctor_loop(self): def test_ctor_loop(self):
loop = unittest.mock.Mock() loop = mock.Mock()
cond = asyncio.Condition(loop=loop) cond = asyncio.Condition(loop=loop)
self.assertIs(cond._loop, loop) self.assertIs(cond._loop, loop)
@ -644,11 +644,11 @@ def test_repr(self):
self.loop.run_until_complete(cond.acquire()) self.loop.run_until_complete(cond.acquire())
self.assertTrue('locked' in repr(cond)) self.assertTrue('locked' in repr(cond))
cond._waiters.append(unittest.mock.Mock()) cond._waiters.append(mock.Mock())
self.assertTrue('waiters:1' in repr(cond)) self.assertTrue('waiters:1' in repr(cond))
self.assertTrue(RGX_REPR.match(repr(cond))) self.assertTrue(RGX_REPR.match(repr(cond)))
cond._waiters.append(unittest.mock.Mock()) cond._waiters.append(mock.Mock())
self.assertTrue('waiters:2' in repr(cond)) self.assertTrue('waiters:2' in repr(cond))
self.assertTrue(RGX_REPR.match(repr(cond))) self.assertTrue(RGX_REPR.match(repr(cond)))
@ -688,7 +688,7 @@ def tearDown(self):
self.loop.close() self.loop.close()
def test_ctor_loop(self): def test_ctor_loop(self):
loop = unittest.mock.Mock() loop = mock.Mock()
sem = asyncio.Semaphore(loop=loop) sem = asyncio.Semaphore(loop=loop)
self.assertIs(sem._loop, loop) self.assertIs(sem._loop, loop)
@ -717,11 +717,11 @@ def test_repr(self):
self.assertTrue('waiters' not in repr(sem)) self.assertTrue('waiters' not in repr(sem))
self.assertTrue(RGX_REPR.match(repr(sem))) self.assertTrue(RGX_REPR.match(repr(sem)))
sem._waiters.append(unittest.mock.Mock()) sem._waiters.append(mock.Mock())
self.assertTrue('waiters:1' in repr(sem)) self.assertTrue('waiters:1' in repr(sem))
self.assertTrue(RGX_REPR.match(repr(sem))) self.assertTrue(RGX_REPR.match(repr(sem)))
sem._waiters.append(unittest.mock.Mock()) sem._waiters.append(mock.Mock())
self.assertTrue('waiters:2' in repr(sem)) self.assertTrue('waiters:2' in repr(sem))
self.assertTrue(RGX_REPR.match(repr(sem))) self.assertTrue(RGX_REPR.match(repr(sem)))

78
Lib/test/test_asyncio/test_proactor_events.py
View file

@ -2,7 +2,7 @@
import socket import socket
import unittest import unittest
import unittest.mock from unittest import mock
import asyncio import asyncio
from asyncio.proactor_events import BaseProactorEventLoop from asyncio.proactor_events import BaseProactorEventLoop
@ -16,10 +16,10 @@ class ProactorSocketTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.proactor = unittest.mock.Mock() self.proactor = mock.Mock()
self.loop._proactor = self.proactor self.loop._proactor = self.proactor
self.protocol = test_utils.make_test_protocol(asyncio.Protocol) self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
self.sock = unittest.mock.Mock(socket.socket) self.sock = mock.Mock(socket.socket)
def test_ctor(self): def test_ctor(self):
fut = asyncio.Future(loop=self.loop) fut = asyncio.Future(loop=self.loop)
@ -56,7 +56,7 @@ def test_loop_reading_no_data(self):
self.assertRaises(AssertionError, tr._loop_reading, res) self.assertRaises(AssertionError, tr._loop_reading, res)
tr.close = unittest.mock.Mock() tr.close = mock.Mock()
tr._read_fut = res tr._read_fut = res
tr._loop_reading(res) tr._loop_reading(res)
self.assertFalse(self.loop._proactor.recv.called) self.assertFalse(self.loop._proactor.recv.called)
@ -67,7 +67,7 @@ def test_loop_reading_aborted(self):
err = self.loop._proactor.recv.side_effect = ConnectionAbortedError() err = self.loop._proactor.recv.side_effect = ConnectionAbortedError()
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._loop_reading() tr._loop_reading()
tr._fatal_error.assert_called_with( tr._fatal_error.assert_called_with(
err, err,
@ -78,7 +78,7 @@ def test_loop_reading_aborted_closing(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._closing = True tr._closing = True
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._loop_reading() tr._loop_reading()
self.assertFalse(tr._fatal_error.called) self.assertFalse(tr._fatal_error.called)
@ -86,7 +86,7 @@ def test_loop_reading_aborted_is_fatal(self):
self.loop._proactor.recv.side_effect = ConnectionAbortedError() self.loop._proactor.recv.side_effect = ConnectionAbortedError()
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._closing = False tr._closing = False
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._loop_reading() tr._loop_reading()
self.assertTrue(tr._fatal_error.called) self.assertTrue(tr._fatal_error.called)
@ -95,8 +95,8 @@ def test_loop_reading_conn_reset_lost(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._closing = False tr._closing = False
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._force_close = unittest.mock.Mock() tr._force_close = mock.Mock()
tr._loop_reading() tr._loop_reading()
self.assertFalse(tr._fatal_error.called) self.assertFalse(tr._fatal_error.called)
tr._force_close.assert_called_with(err) tr._force_close.assert_called_with(err)
@ -105,7 +105,7 @@ def test_loop_reading_exception(self):
err = self.loop._proactor.recv.side_effect = (OSError()) err = self.loop._proactor.recv.side_effect = (OSError())
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._loop_reading() tr._loop_reading()
tr._fatal_error.assert_called_with( tr._fatal_error.assert_called_with(
err, err,
@ -113,7 +113,7 @@ def test_loop_reading_exception(self):
def test_write(self): def test_write(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._loop_writing = unittest.mock.Mock() tr._loop_writing = mock.Mock()
tr.write(b'data') tr.write(b'data')
self.assertEqual(tr._buffer, None) self.assertEqual(tr._buffer, None)
tr._loop_writing.assert_called_with(data=b'data') tr._loop_writing.assert_called_with(data=b'data')
@ -125,8 +125,8 @@ def test_write_no_data(self):
def test_write_more(self): def test_write_more(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._write_fut = unittest.mock.Mock() tr._write_fut = mock.Mock()
tr._loop_writing = unittest.mock.Mock() tr._loop_writing = mock.Mock()
tr.write(b'data') tr.write(b'data')
self.assertEqual(tr._buffer, b'data') self.assertEqual(tr._buffer, b'data')
self.assertFalse(tr._loop_writing.called) self.assertFalse(tr._loop_writing.called)
@ -139,11 +139,11 @@ def test_loop_writing(self):
self.loop._proactor.send.return_value.add_done_callback.\ self.loop._proactor.send.return_value.add_done_callback.\
assert_called_with(tr._loop_writing) assert_called_with(tr._loop_writing)
@unittest.mock.patch('asyncio.proactor_events.logger') @mock.patch('asyncio.proactor_events.logger')
def test_loop_writing_err(self, m_log): def test_loop_writing_err(self, m_log):
err = self.loop._proactor.send.side_effect = OSError() err = self.loop._proactor.send.side_effect = OSError()
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr._buffer = [b'da', b'ta'] tr._buffer = [b'da', b'ta']
tr._loop_writing() tr._loop_writing()
tr._fatal_error.assert_called_with( tr._fatal_error.assert_called_with(
@ -182,7 +182,7 @@ def test_loop_writing_closing(self):
def test_abort(self): def test_abort(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._force_close = unittest.mock.Mock() tr._force_close = mock.Mock()
tr.abort() tr.abort()
tr._force_close.assert_called_with(None) tr._force_close.assert_called_with(None)
@ -201,7 +201,7 @@ def test_close(self):
def test_close_write_fut(self): def test_close_write_fut(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._write_fut = unittest.mock.Mock() tr._write_fut = mock.Mock()
tr.close() tr.close()
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.assertFalse(self.protocol.connection_lost.called) self.assertFalse(self.protocol.connection_lost.called)
@ -213,10 +213,10 @@ def test_close_buffer(self):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.assertFalse(self.protocol.connection_lost.called) self.assertFalse(self.protocol.connection_lost.called)
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_fatal_error(self, m_logging): def test_fatal_error(self, m_logging):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._force_close = unittest.mock.Mock() tr._force_close = mock.Mock()
tr._fatal_error(None) tr._fatal_error(None)
self.assertTrue(tr._force_close.called) self.assertTrue(tr._force_close.called)
self.assertTrue(m_logging.error.called) self.assertTrue(m_logging.error.called)
@ -224,8 +224,8 @@ def test_fatal_error(self, m_logging):
def test_force_close(self): def test_force_close(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._buffer = [b'data'] tr._buffer = [b'data']
read_fut = tr._read_fut = unittest.mock.Mock() read_fut = tr._read_fut = mock.Mock()
write_fut = tr._write_fut = unittest.mock.Mock() write_fut = tr._write_fut = mock.Mock()
tr._force_close(None) tr._force_close(None)
read_fut.cancel.assert_called_with() read_fut.cancel.assert_called_with()
@ -346,10 +346,10 @@ def test_pause_resume_reading(self):
class BaseProactorEventLoopTests(unittest.TestCase): class BaseProactorEventLoopTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.sock = unittest.mock.Mock(socket.socket) self.sock = mock.Mock(socket.socket)
self.proactor = unittest.mock.Mock() self.proactor = mock.Mock()
self.ssock, self.csock = unittest.mock.Mock(), unittest.mock.Mock() self.ssock, self.csock = mock.Mock(), mock.Mock()
class EventLoop(BaseProactorEventLoop): class EventLoop(BaseProactorEventLoop):
def _socketpair(s): def _socketpair(s):
@ -357,11 +357,11 @@ def _socketpair(s):
self.loop = EventLoop(self.proactor) self.loop = EventLoop(self.proactor)
@unittest.mock.patch.object(BaseProactorEventLoop, 'call_soon') @mock.patch.object(BaseProactorEventLoop, 'call_soon')
@unittest.mock.patch.object(BaseProactorEventLoop, '_socketpair') @mock.patch.object(BaseProactorEventLoop, '_socketpair')
def test_ctor(self, socketpair, call_soon): def test_ctor(self, socketpair, call_soon):
ssock, csock = socketpair.return_value = ( ssock, csock = socketpair.return_value = (
unittest.mock.Mock(), unittest.mock.Mock()) mock.Mock(), mock.Mock())
loop = BaseProactorEventLoop(self.proactor) loop = BaseProactorEventLoop(self.proactor)
self.assertIs(loop._ssock, ssock) self.assertIs(loop._ssock, ssock)
self.assertIs(loop._csock, csock) self.assertIs(loop._csock, csock)
@ -377,7 +377,7 @@ def test_close_self_pipe(self):
self.assertIsNone(self.loop._csock) self.assertIsNone(self.loop._csock)
def test_close(self): def test_close(self):
self.loop._close_self_pipe = unittest.mock.Mock() self.loop._close_self_pipe = mock.Mock()
self.loop.close() self.loop.close()
self.assertTrue(self.loop._close_self_pipe.called) self.assertTrue(self.loop._close_self_pipe.called)
self.assertTrue(self.proactor.close.called) self.assertTrue(self.proactor.close.called)
@ -418,7 +418,7 @@ def test_loop_self_reading(self):
self.loop._loop_self_reading) self.loop._loop_self_reading)
def test_loop_self_reading_fut(self): def test_loop_self_reading_fut(self):
fut = unittest.mock.Mock() fut = mock.Mock()
self.loop._loop_self_reading(fut) self.loop._loop_self_reading(fut)
self.assertTrue(fut.result.called) self.assertTrue(fut.result.called)
self.proactor.recv.assert_called_with(self.ssock, 4096) self.proactor.recv.assert_called_with(self.ssock, 4096)
@ -426,7 +426,7 @@ def test_loop_self_reading_fut(self):
self.loop._loop_self_reading) self.loop._loop_self_reading)
def test_loop_self_reading_exception(self): def test_loop_self_reading_exception(self):
self.loop.close = unittest.mock.Mock() self.loop.close = mock.Mock()
self.proactor.recv.side_effect = OSError() self.proactor.recv.side_effect = OSError()
self.assertRaises(OSError, self.loop._loop_self_reading) self.assertRaises(OSError, self.loop._loop_self_reading)
self.assertTrue(self.loop.close.called) self.assertTrue(self.loop.close.called)
@ -438,10 +438,10 @@ def test_write_to_self(self):
def test_process_events(self): def test_process_events(self):
self.loop._process_events([]) self.loop._process_events([])
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_create_server(self, m_log): def test_create_server(self, m_log):
pf = unittest.mock.Mock() pf = mock.Mock()
call_soon = self.loop.call_soon = unittest.mock.Mock() call_soon = self.loop.call_soon = mock.Mock()
self.loop._start_serving(pf, self.sock) self.loop._start_serving(pf, self.sock)
self.assertTrue(call_soon.called) self.assertTrue(call_soon.called)
@ -452,10 +452,10 @@ def test_create_server(self, m_log):
self.proactor.accept.assert_called_with(self.sock) self.proactor.accept.assert_called_with(self.sock)
# conn # conn
fut = unittest.mock.Mock() fut = mock.Mock()
fut.result.return_value = (unittest.mock.Mock(), unittest.mock.Mock()) fut.result.return_value = (mock.Mock(), mock.Mock())
make_tr = self.loop._make_socket_transport = unittest.mock.Mock() make_tr = self.loop._make_socket_transport = mock.Mock()
loop(fut) loop(fut)
self.assertTrue(fut.result.called) self.assertTrue(fut.result.called)
self.assertTrue(make_tr.called) self.assertTrue(make_tr.called)
@ -467,8 +467,8 @@ def test_create_server(self, m_log):
self.assertTrue(m_log.error.called) self.assertTrue(m_log.error.called)
def test_create_server_cancel(self): def test_create_server_cancel(self):
pf = unittest.mock.Mock() pf = mock.Mock()
call_soon = self.loop.call_soon = unittest.mock.Mock() call_soon = self.loop.call_soon = mock.Mock()
self.loop._start_serving(pf, self.sock) self.loop._start_serving(pf, self.sock)
loop = call_soon.call_args[0][0] loop = call_soon.call_args[0][0]
@ -480,7 +480,7 @@ def test_create_server_cancel(self):
self.assertTrue(self.sock.close.called) self.assertTrue(self.sock.close.called)
def test_stop_serving(self): def test_stop_serving(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._stop_serving(sock) self.loop._stop_serving(sock)
self.assertTrue(sock.close.called) self.assertTrue(sock.close.called)
self.proactor._stop_serving.assert_called_with(sock) self.proactor._stop_serving.assert_called_with(sock)

4
Lib/test/test_asyncio/test_queues.py
View file

@ -1,7 +1,7 @@
"""Tests for queues.py""" """Tests for queues.py"""
import unittest import unittest
import unittest.mock from unittest import mock
import asyncio import asyncio
from asyncio import test_utils from asyncio import test_utils
@ -72,7 +72,7 @@ def add_putter():
self.assertTrue('_queue=[1]' in fn(q)) self.assertTrue('_queue=[1]' in fn(q))
def test_ctor_loop(self): def test_ctor_loop(self):
loop = unittest.mock.Mock() loop = mock.Mock()
q = asyncio.Queue(loop=loop) q = asyncio.Queue(loop=loop)
self.assertIs(q._loop, loop) self.assertIs(q._loop, loop)

273
Lib/test/test_asyncio/test_selector_events.py
View file

@ -1,13 +1,12 @@
"""Tests for selector_events.py""" """Tests for selector_events.py"""
import collections
import errno import errno
import gc import gc
import pprint import pprint
import socket import socket
import sys import sys
import unittest import unittest
import unittest.mock from unittest import mock
try: try:
import ssl import ssl
except ImportError: except ImportError:
@ -23,14 +22,14 @@
from asyncio.selector_events import _SelectorDatagramTransport from asyncio.selector_events import _SelectorDatagramTransport
MOCK_ANY = unittest.mock.ANY MOCK_ANY = mock.ANY
class TestBaseSelectorEventLoop(BaseSelectorEventLoop): class TestBaseSelectorEventLoop(BaseSelectorEventLoop):
def _make_self_pipe(self): def _make_self_pipe(self):
self._ssock = unittest.mock.Mock() self._ssock = mock.Mock()
self._csock = unittest.mock.Mock() self._csock = mock.Mock()
self._internal_fds += 1 self._internal_fds += 1
@ -41,34 +40,34 @@ def list_to_buffer(l=()):
class BaseSelectorEventLoopTests(unittest.TestCase): class BaseSelectorEventLoopTests(unittest.TestCase):
def setUp(self): def setUp(self):
selector = unittest.mock.Mock() selector = mock.Mock()
self.loop = TestBaseSelectorEventLoop(selector) self.loop = TestBaseSelectorEventLoop(selector)
def test_make_socket_transport(self): def test_make_socket_transport(self):
m = unittest.mock.Mock() m = mock.Mock()
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
transport = self.loop._make_socket_transport(m, asyncio.Protocol()) transport = self.loop._make_socket_transport(m, asyncio.Protocol())
self.assertIsInstance(transport, _SelectorSocketTransport) self.assertIsInstance(transport, _SelectorSocketTransport)
@unittest.skipIf(ssl is None, 'No ssl module') @unittest.skipIf(ssl is None, 'No ssl module')
def test_make_ssl_transport(self): def test_make_ssl_transport(self):
m = unittest.mock.Mock() m = mock.Mock()
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
waiter = asyncio.Future(loop=self.loop) waiter = asyncio.Future(loop=self.loop)
transport = self.loop._make_ssl_transport( transport = self.loop._make_ssl_transport(
m, asyncio.Protocol(), m, waiter) m, asyncio.Protocol(), m, waiter)
self.assertIsInstance(transport, _SelectorSslTransport) self.assertIsInstance(transport, _SelectorSslTransport)
@unittest.mock.patch('asyncio.selector_events.ssl', None) @mock.patch('asyncio.selector_events.ssl', None)
def test_make_ssl_transport_without_ssl_error(self): def test_make_ssl_transport_without_ssl_error(self):
m = unittest.mock.Mock() m = mock.Mock()
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
with self.assertRaises(RuntimeError): with self.assertRaises(RuntimeError):
self.loop._make_ssl_transport(m, m, m, m) self.loop._make_ssl_transport(m, m, m, m)
@ -77,10 +76,10 @@ def test_close(self):
ssock.fileno.return_value = 7 ssock.fileno.return_value = 7
csock = self.loop._csock csock = self.loop._csock
csock.fileno.return_value = 1 csock.fileno.return_value = 1
remove_reader = self.loop.remove_reader = unittest.mock.Mock() remove_reader = self.loop.remove_reader = mock.Mock()
self.loop._selector.close() self.loop._selector.close()
self.loop._selector = selector = unittest.mock.Mock() self.loop._selector = selector = mock.Mock()
self.loop.close() self.loop.close()
self.assertIsNone(self.loop._selector) self.assertIsNone(self.loop._selector)
self.assertIsNone(self.loop._csock) self.assertIsNone(self.loop._csock)
@ -96,7 +95,7 @@ def test_close(self):
def test_close_no_selector(self): def test_close_no_selector(self):
ssock = self.loop._ssock ssock = self.loop._ssock
csock = self.loop._csock csock = self.loop._csock
remove_reader = self.loop.remove_reader = unittest.mock.Mock() remove_reader = self.loop.remove_reader = mock.Mock()
self.loop._selector.close() self.loop._selector.close()
self.loop._selector = None self.loop._selector = None
@ -126,15 +125,15 @@ def test_write_to_self_exception(self):
self.assertRaises(OSError, self.loop._write_to_self) self.assertRaises(OSError, self.loop._write_to_self)
def test_sock_recv(self): def test_sock_recv(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._sock_recv = unittest.mock.Mock() self.loop._sock_recv = mock.Mock()
f = self.loop.sock_recv(sock, 1024) f = self.loop.sock_recv(sock, 1024)
self.assertIsInstance(f, asyncio.Future) self.assertIsInstance(f, asyncio.Future)
self.loop._sock_recv.assert_called_with(f, False, sock, 1024) self.loop._sock_recv.assert_called_with(f, False, sock, 1024)
def test__sock_recv_canceled_fut(self): def test__sock_recv_canceled_fut(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
@ -143,30 +142,30 @@ def test__sock_recv_canceled_fut(self):
self.assertFalse(sock.recv.called) self.assertFalse(sock.recv.called)
def test__sock_recv_unregister(self): def test__sock_recv_unregister(self):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop._sock_recv(f, True, sock, 1024) self.loop._sock_recv(f, True, sock, 1024)
self.assertEqual((10,), self.loop.remove_reader.call_args[0]) self.assertEqual((10,), self.loop.remove_reader.call_args[0])
def test__sock_recv_tryagain(self): def test__sock_recv_tryagain(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.recv.side_effect = BlockingIOError sock.recv.side_effect = BlockingIOError
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
self.loop._sock_recv(f, False, sock, 1024) self.loop._sock_recv(f, False, sock, 1024)
self.assertEqual((10, self.loop._sock_recv, f, True, sock, 1024), self.assertEqual((10, self.loop._sock_recv, f, True, sock, 1024),
self.loop.add_reader.call_args[0]) self.loop.add_reader.call_args[0])
def test__sock_recv_exception(self): def test__sock_recv_exception(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
err = sock.recv.side_effect = OSError() err = sock.recv.side_effect = OSError()
@ -174,8 +173,8 @@ def test__sock_recv_exception(self):
self.assertIs(err, f.exception()) self.assertIs(err, f.exception())
def test_sock_sendall(self): def test_sock_sendall(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._sock_sendall = unittest.mock.Mock() self.loop._sock_sendall = mock.Mock()
f = self.loop.sock_sendall(sock, b'data') f = self.loop.sock_sendall(sock, b'data')
self.assertIsInstance(f, asyncio.Future) self.assertIsInstance(f, asyncio.Future)
@ -184,8 +183,8 @@ def test_sock_sendall(self):
self.loop._sock_sendall.call_args[0]) self.loop._sock_sendall.call_args[0])
def test_sock_sendall_nodata(self): def test_sock_sendall_nodata(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._sock_sendall = unittest.mock.Mock() self.loop._sock_sendall = mock.Mock()
f = self.loop.sock_sendall(sock, b'') f = self.loop.sock_sendall(sock, b'')
self.assertIsInstance(f, asyncio.Future) self.assertIsInstance(f, asyncio.Future)
@ -194,7 +193,7 @@ def test_sock_sendall_nodata(self):
self.assertFalse(self.loop._sock_sendall.called) self.assertFalse(self.loop._sock_sendall.called)
def test__sock_sendall_canceled_fut(self): def test__sock_sendall_canceled_fut(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
@ -203,23 +202,23 @@ def test__sock_sendall_canceled_fut(self):
self.assertFalse(sock.send.called) self.assertFalse(sock.send.called)
def test__sock_sendall_unregister(self): def test__sock_sendall_unregister(self):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.loop._sock_sendall(f, True, sock, b'data') self.loop._sock_sendall(f, True, sock, b'data')
self.assertEqual((10,), self.loop.remove_writer.call_args[0]) self.assertEqual((10,), self.loop.remove_writer.call_args[0])
def test__sock_sendall_tryagain(self): def test__sock_sendall_tryagain(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.send.side_effect = BlockingIOError sock.send.side_effect = BlockingIOError
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop._sock_sendall(f, False, sock, b'data') self.loop._sock_sendall(f, False, sock, b'data')
self.assertEqual( self.assertEqual(
(10, self.loop._sock_sendall, f, True, sock, b'data'), (10, self.loop._sock_sendall, f, True, sock, b'data'),
@ -227,11 +226,11 @@ def test__sock_sendall_tryagain(self):
def test__sock_sendall_interrupted(self): def test__sock_sendall_interrupted(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.send.side_effect = InterruptedError sock.send.side_effect = InterruptedError
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop._sock_sendall(f, False, sock, b'data') self.loop._sock_sendall(f, False, sock, b'data')
self.assertEqual( self.assertEqual(
(10, self.loop._sock_sendall, f, True, sock, b'data'), (10, self.loop._sock_sendall, f, True, sock, b'data'),
@ -239,7 +238,7 @@ def test__sock_sendall_interrupted(self):
def test__sock_sendall_exception(self): def test__sock_sendall_exception(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
err = sock.send.side_effect = OSError() err = sock.send.side_effect = OSError()
@ -247,7 +246,7 @@ def test__sock_sendall_exception(self):
self.assertIs(f.exception(), err) self.assertIs(f.exception(), err)
def test__sock_sendall(self): def test__sock_sendall(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock.fileno.return_value = 10 sock.fileno.return_value = 10
@ -258,13 +257,13 @@ def test__sock_sendall(self):
self.assertIsNone(f.result()) self.assertIsNone(f.result())
def test__sock_sendall_partial(self): def test__sock_sendall_partial(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.send.return_value = 2 sock.send.return_value = 2
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop._sock_sendall(f, False, sock, b'data') self.loop._sock_sendall(f, False, sock, b'data')
self.assertFalse(f.done()) self.assertFalse(f.done())
self.assertEqual( self.assertEqual(
@ -272,13 +271,13 @@ def test__sock_sendall_partial(self):
self.loop.add_writer.call_args[0]) self.loop.add_writer.call_args[0])
def test__sock_sendall_none(self): def test__sock_sendall_none(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.send.return_value = 0 sock.send.return_value = 0
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop._sock_sendall(f, False, sock, b'data') self.loop._sock_sendall(f, False, sock, b'data')
self.assertFalse(f.done()) self.assertFalse(f.done())
self.assertEqual( self.assertEqual(
@ -286,8 +285,8 @@ def test__sock_sendall_none(self):
self.loop.add_writer.call_args[0]) self.loop.add_writer.call_args[0])
def test_sock_connect(self): def test_sock_connect(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._sock_connect = unittest.mock.Mock() self.loop._sock_connect = mock.Mock()
f = self.loop.sock_connect(sock, ('127.0.0.1', 8080)) f = self.loop.sock_connect(sock, ('127.0.0.1', 8080))
self.assertIsInstance(f, asyncio.Future) self.assertIsInstance(f, asyncio.Future)
@ -298,7 +297,7 @@ def test_sock_connect(self):
def test__sock_connect(self): def test__sock_connect(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
self.loop._sock_connect(f, False, sock, ('127.0.0.1', 8080)) self.loop._sock_connect(f, False, sock, ('127.0.0.1', 8080))
@ -307,7 +306,7 @@ def test__sock_connect(self):
self.assertTrue(sock.connect.called) self.assertTrue(sock.connect.called)
def test__sock_connect_canceled_fut(self): def test__sock_connect_canceled_fut(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
@ -316,24 +315,24 @@ def test__sock_connect_canceled_fut(self):
self.assertFalse(sock.connect.called) self.assertFalse(sock.connect.called)
def test__sock_connect_unregister(self): def test__sock_connect_unregister(self):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080)) self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080))
self.assertEqual((10,), self.loop.remove_writer.call_args[0]) self.assertEqual((10,), self.loop.remove_writer.call_args[0])
def test__sock_connect_tryagain(self): def test__sock_connect_tryagain(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.getsockopt.return_value = errno.EAGAIN sock.getsockopt.return_value = errno.EAGAIN
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080)) self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080))
self.assertEqual( self.assertEqual(
@ -343,17 +342,17 @@ def test__sock_connect_tryagain(self):
def test__sock_connect_exception(self): def test__sock_connect_exception(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.getsockopt.return_value = errno.ENOTCONN sock.getsockopt.return_value = errno.ENOTCONN
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080)) self.loop._sock_connect(f, True, sock, ('127.0.0.1', 8080))
self.assertIsInstance(f.exception(), OSError) self.assertIsInstance(f.exception(), OSError)
def test_sock_accept(self): def test_sock_accept(self):
sock = unittest.mock.Mock() sock = mock.Mock()
self.loop._sock_accept = unittest.mock.Mock() self.loop._sock_accept = mock.Mock()
f = self.loop.sock_accept(sock) f = self.loop.sock_accept(sock)
self.assertIsInstance(f, asyncio.Future) self.assertIsInstance(f, asyncio.Future)
@ -363,9 +362,9 @@ def test_sock_accept(self):
def test__sock_accept(self): def test__sock_accept(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
conn = unittest.mock.Mock() conn = mock.Mock()
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.accept.return_value = conn, ('127.0.0.1', 1000) sock.accept.return_value = conn, ('127.0.0.1', 1000)
@ -375,7 +374,7 @@ def test__sock_accept(self):
self.assertEqual((False,), conn.setblocking.call_args[0]) self.assertEqual((False,), conn.setblocking.call_args[0])
def test__sock_accept_canceled_fut(self): def test__sock_accept_canceled_fut(self):
sock = unittest.mock.Mock() sock = mock.Mock()
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
@ -384,23 +383,23 @@ def test__sock_accept_canceled_fut(self):
self.assertFalse(sock.accept.called) self.assertFalse(sock.accept.called)
def test__sock_accept_unregister(self): def test__sock_accept_unregister(self):
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
f.cancel() f.cancel()
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop._sock_accept(f, True, sock) self.loop._sock_accept(f, True, sock)
self.assertEqual((10,), self.loop.remove_reader.call_args[0]) self.assertEqual((10,), self.loop.remove_reader.call_args[0])
def test__sock_accept_tryagain(self): def test__sock_accept_tryagain(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
sock.accept.side_effect = BlockingIOError sock.accept.side_effect = BlockingIOError
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
self.loop._sock_accept(f, False, sock) self.loop._sock_accept(f, False, sock)
self.assertEqual( self.assertEqual(
(10, self.loop._sock_accept, f, True, sock), (10, self.loop._sock_accept, f, True, sock),
@ -408,7 +407,7 @@ def test__sock_accept_tryagain(self):
def test__sock_accept_exception(self): def test__sock_accept_exception(self):
f = asyncio.Future(loop=self.loop) f = asyncio.Future(loop=self.loop)
sock = unittest.mock.Mock() sock = mock.Mock()
sock.fileno.return_value = 10 sock.fileno.return_value = 10
err = sock.accept.side_effect = OSError() err = sock.accept.side_effect = OSError()
@ -428,8 +427,8 @@ def test_add_reader(self):
self.assertIsNone(w) self.assertIsNone(w)
def test_add_reader_existing(self): def test_add_reader_existing(self):
reader = unittest.mock.Mock() reader = mock.Mock()
writer = unittest.mock.Mock() writer = mock.Mock()
self.loop._selector.get_key.return_value = selectors.SelectorKey( self.loop._selector.get_key.return_value = selectors.SelectorKey(
1, 1, selectors.EVENT_WRITE, (reader, writer)) 1, 1, selectors.EVENT_WRITE, (reader, writer))
cb = lambda: True cb = lambda: True
@ -445,7 +444,7 @@ def test_add_reader_existing(self):
self.assertEqual(writer, w) self.assertEqual(writer, w)
def test_add_reader_existing_writer(self): def test_add_reader_existing_writer(self):
writer = unittest.mock.Mock() writer = mock.Mock()
self.loop._selector.get_key.return_value = selectors.SelectorKey( self.loop._selector.get_key.return_value = selectors.SelectorKey(
1, 1, selectors.EVENT_WRITE, (None, writer)) 1, 1, selectors.EVENT_WRITE, (None, writer))
cb = lambda: True cb = lambda: True
@ -467,8 +466,8 @@ def test_remove_reader(self):
self.assertTrue(self.loop._selector.unregister.called) self.assertTrue(self.loop._selector.unregister.called)
def test_remove_reader_read_write(self): def test_remove_reader_read_write(self):
reader = unittest.mock.Mock() reader = mock.Mock()
writer = unittest.mock.Mock() writer = mock.Mock()
self.loop._selector.get_key.return_value = selectors.SelectorKey( self.loop._selector.get_key.return_value = selectors.SelectorKey(
1, 1, selectors.EVENT_READ | selectors.EVENT_WRITE, 1, 1, selectors.EVENT_READ | selectors.EVENT_WRITE,
(reader, writer)) (reader, writer))
@ -498,8 +497,8 @@ def test_add_writer(self):
self.assertEqual(cb, w._callback) self.assertEqual(cb, w._callback)
def test_add_writer_existing(self): def test_add_writer_existing(self):
reader = unittest.mock.Mock() reader = mock.Mock()
writer = unittest.mock.Mock() writer = mock.Mock()
self.loop._selector.get_key.return_value = selectors.SelectorKey( self.loop._selector.get_key.return_value = selectors.SelectorKey(
1, 1, selectors.EVENT_READ, (reader, writer)) 1, 1, selectors.EVENT_READ, (reader, writer))
cb = lambda: True cb = lambda: True
@ -522,8 +521,8 @@ def test_remove_writer(self):
self.assertTrue(self.loop._selector.unregister.called) self.assertTrue(self.loop._selector.unregister.called)
def test_remove_writer_read_write(self): def test_remove_writer_read_write(self):
reader = unittest.mock.Mock() reader = mock.Mock()
writer = unittest.mock.Mock() writer = mock.Mock()
self.loop._selector.get_key.return_value = selectors.SelectorKey( self.loop._selector.get_key.return_value = selectors.SelectorKey(
1, 1, selectors.EVENT_READ | selectors.EVENT_WRITE, 1, 1, selectors.EVENT_READ | selectors.EVENT_WRITE,
(reader, writer)) (reader, writer))
@ -541,10 +540,10 @@ def test_remove_writer_unknown(self):
self.loop.remove_writer(1)) self.loop.remove_writer(1))
def test_process_events_read(self): def test_process_events_read(self):
reader = unittest.mock.Mock() reader = mock.Mock()
reader._cancelled = False reader._cancelled = False
self.loop._add_callback = unittest.mock.Mock() self.loop._add_callback = mock.Mock()
self.loop._process_events( self.loop._process_events(
[(selectors.SelectorKey( [(selectors.SelectorKey(
1, 1, selectors.EVENT_READ, (reader, None)), 1, 1, selectors.EVENT_READ, (reader, None)),
@ -553,10 +552,10 @@ def test_process_events_read(self):
self.loop._add_callback.assert_called_with(reader) self.loop._add_callback.assert_called_with(reader)
def test_process_events_read_cancelled(self): def test_process_events_read_cancelled(self):
reader = unittest.mock.Mock() reader = mock.Mock()
reader.cancelled = True reader.cancelled = True
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop._process_events( self.loop._process_events(
[(selectors.SelectorKey( [(selectors.SelectorKey(
1, 1, selectors.EVENT_READ, (reader, None)), 1, 1, selectors.EVENT_READ, (reader, None)),
@ -564,10 +563,10 @@ def test_process_events_read_cancelled(self):
self.loop.remove_reader.assert_called_with(1) self.loop.remove_reader.assert_called_with(1)
def test_process_events_write(self): def test_process_events_write(self):
writer = unittest.mock.Mock() writer = mock.Mock()
writer._cancelled = False writer._cancelled = False
self.loop._add_callback = unittest.mock.Mock() self.loop._add_callback = mock.Mock()
self.loop._process_events( self.loop._process_events(
[(selectors.SelectorKey(1, 1, selectors.EVENT_WRITE, [(selectors.SelectorKey(1, 1, selectors.EVENT_WRITE,
(None, writer)), (None, writer)),
@ -575,9 +574,9 @@ def test_process_events_write(self):
self.loop._add_callback.assert_called_with(writer) self.loop._add_callback.assert_called_with(writer)
def test_process_events_write_cancelled(self): def test_process_events_write_cancelled(self):
writer = unittest.mock.Mock() writer = mock.Mock()
writer.cancelled = True writer.cancelled = True
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.loop._process_events( self.loop._process_events(
[(selectors.SelectorKey(1, 1, selectors.EVENT_WRITE, [(selectors.SelectorKey(1, 1, selectors.EVENT_WRITE,
@ -591,7 +590,7 @@ class SelectorTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.Protocol) self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
self.sock = unittest.mock.Mock(socket.socket) self.sock = mock.Mock(socket.socket)
self.sock.fileno.return_value = 7 self.sock.fileno.return_value = 7
def test_ctor(self): def test_ctor(self):
@ -602,7 +601,7 @@ def test_ctor(self):
def test_abort(self): def test_abort(self):
tr = _SelectorTransport(self.loop, self.sock, self.protocol, None) tr = _SelectorTransport(self.loop, self.sock, self.protocol, None)
tr._force_close = unittest.mock.Mock() tr._force_close = mock.Mock()
tr.abort() tr.abort()
tr._force_close.assert_called_with(None) tr._force_close.assert_called_with(None)
@ -632,8 +631,8 @@ def test_close_write_buffer(self):
def test_force_close(self): def test_force_close(self):
tr = _SelectorTransport(self.loop, self.sock, self.protocol, None) tr = _SelectorTransport(self.loop, self.sock, self.protocol, None)
tr._buffer.extend(b'1') tr._buffer.extend(b'1')
self.loop.add_reader(7, unittest.mock.sentinel) self.loop.add_reader(7, mock.sentinel)
self.loop.add_writer(7, unittest.mock.sentinel) self.loop.add_writer(7, mock.sentinel)
tr._force_close(None) tr._force_close(None)
self.assertTrue(tr._closing) self.assertTrue(tr._closing)
@ -646,11 +645,11 @@ def test_force_close(self):
self.assertFalse(self.loop.readers) self.assertFalse(self.loop.readers)
self.assertEqual(1, self.loop.remove_reader_count[7]) self.assertEqual(1, self.loop.remove_reader_count[7])
@unittest.mock.patch('asyncio.log.logger.error') @mock.patch('asyncio.log.logger.error')
def test_fatal_error(self, m_exc): def test_fatal_error(self, m_exc):
exc = OSError() exc = OSError()
tr = _SelectorTransport(self.loop, self.sock, self.protocol, None) tr = _SelectorTransport(self.loop, self.sock, self.protocol, None)
tr._force_close = unittest.mock.Mock() tr._force_close = mock.Mock()
tr._fatal_error(exc) tr._fatal_error(exc)
m_exc.assert_called_with( m_exc.assert_called_with(
@ -682,7 +681,7 @@ class SelectorSocketTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.Protocol) self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
self.sock = unittest.mock.Mock(socket.socket) self.sock = mock.Mock(socket.socket)
self.sock_fd = self.sock.fileno.return_value = 7 self.sock_fd = self.sock.fileno.return_value = 7
def test_ctor(self): def test_ctor(self):
@ -724,7 +723,7 @@ def test_read_ready(self):
def test_read_ready_eof(self): def test_read_ready_eof(self):
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport.close = unittest.mock.Mock() transport.close = mock.Mock()
self.sock.recv.return_value = b'' self.sock.recv.return_value = b''
transport._read_ready() transport._read_ready()
@ -735,7 +734,7 @@ def test_read_ready_eof(self):
def test_read_ready_eof_keep_open(self): def test_read_ready_eof_keep_open(self):
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport.close = unittest.mock.Mock() transport.close = mock.Mock()
self.sock.recv.return_value = b'' self.sock.recv.return_value = b''
self.protocol.eof_received.return_value = True self.protocol.eof_received.return_value = True
@ -744,45 +743,45 @@ def test_read_ready_eof_keep_open(self):
self.protocol.eof_received.assert_called_with() self.protocol.eof_received.assert_called_with()
self.assertFalse(transport.close.called) self.assertFalse(transport.close.called)
@unittest.mock.patch('logging.exception') @mock.patch('logging.exception')
def test_read_ready_tryagain(self, m_exc): def test_read_ready_tryagain(self, m_exc):
self.sock.recv.side_effect = BlockingIOError self.sock.recv.side_effect = BlockingIOError
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
@unittest.mock.patch('logging.exception') @mock.patch('logging.exception')
def test_read_ready_tryagain_interrupted(self, m_exc): def test_read_ready_tryagain_interrupted(self, m_exc):
self.sock.recv.side_effect = InterruptedError self.sock.recv.side_effect = InterruptedError
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
@unittest.mock.patch('logging.exception') @mock.patch('logging.exception')
def test_read_ready_conn_reset(self, m_exc): def test_read_ready_conn_reset(self, m_exc):
err = self.sock.recv.side_effect = ConnectionResetError() err = self.sock.recv.side_effect = ConnectionResetError()
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._force_close = unittest.mock.Mock() transport._force_close = mock.Mock()
transport._read_ready() transport._read_ready()
transport._force_close.assert_called_with(err) transport._force_close.assert_called_with(err)
@unittest.mock.patch('logging.exception') @mock.patch('logging.exception')
def test_read_ready_err(self, m_exc): def test_read_ready_err(self, m_exc):
err = self.sock.recv.side_effect = OSError() err = self.sock.recv.side_effect = OSError()
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
@ -891,14 +890,14 @@ def test_write_tryagain(self):
self.loop.assert_writer(7, transport._write_ready) self.loop.assert_writer(7, transport._write_ready)
self.assertEqual(list_to_buffer([b'data']), transport._buffer) self.assertEqual(list_to_buffer([b'data']), transport._buffer)
@unittest.mock.patch('asyncio.selector_events.logger') @mock.patch('asyncio.selector_events.logger')
def test_write_exception(self, m_log): def test_write_exception(self, m_log):
err = self.sock.send.side_effect = OSError() err = self.sock.send.side_effect = OSError()
data = b'data' data = b'data'
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport.write(data) transport.write(data)
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
err, err,
@ -1002,17 +1001,17 @@ def test_write_ready_exception(self):
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._buffer.extend(b'data') transport._buffer.extend(b'data')
transport._write_ready() transport._write_ready()
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
err, err,
'Fatal write error on socket transport') 'Fatal write error on socket transport')
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_write_ready_exception_and_close(self, m_log): def test_write_ready_exception_and_close(self, m_log):
self.sock.send.side_effect = OSError() self.sock.send.side_effect = OSError()
remove_writer = self.loop.remove_writer = unittest.mock.Mock() remove_writer = self.loop.remove_writer = mock.Mock()
transport = _SelectorSocketTransport( transport = _SelectorSocketTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
@ -1053,11 +1052,11 @@ class SelectorSslTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.Protocol) self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
self.sock = unittest.mock.Mock(socket.socket) self.sock = mock.Mock(socket.socket)
self.sock.fileno.return_value = 7 self.sock.fileno.return_value = 7
self.sslsock = unittest.mock.Mock() self.sslsock = mock.Mock()
self.sslsock.fileno.return_value = 1 self.sslsock.fileno.return_value = 1
self.sslcontext = unittest.mock.Mock() self.sslcontext = mock.Mock()
self.sslcontext.wrap_socket.return_value = self.sslsock self.sslcontext.wrap_socket.return_value = self.sslsock
def _make_one(self, create_waiter=None): def _make_one(self, create_waiter=None):
@ -1162,7 +1161,7 @@ def test_write_closing(self):
transport.write(b'data') transport.write(b'data')
self.assertEqual(transport._conn_lost, 2) self.assertEqual(transport._conn_lost, 2)
@unittest.mock.patch('asyncio.selector_events.logger') @mock.patch('asyncio.selector_events.logger')
def test_write_exception(self, m_log): def test_write_exception(self, m_log):
transport = self._make_one() transport = self._make_one()
transport._conn_lost = 1 transport._conn_lost = 1
@ -1182,11 +1181,11 @@ def test_read_ready_recv(self):
self.assertEqual((b'data',), self.protocol.data_received.call_args[0]) self.assertEqual((b'data',), self.protocol.data_received.call_args[0])
def test_read_ready_write_wants_read(self): def test_read_ready_write_wants_read(self):
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.sslsock.recv.side_effect = BlockingIOError self.sslsock.recv.side_effect = BlockingIOError
transport = self._make_one() transport = self._make_one()
transport._write_wants_read = True transport._write_wants_read = True
transport._write_ready = unittest.mock.Mock() transport._write_ready = mock.Mock()
transport._buffer.extend(b'data') transport._buffer.extend(b'data')
transport._read_ready() transport._read_ready()
@ -1198,7 +1197,7 @@ def test_read_ready_write_wants_read(self):
def test_read_ready_recv_eof(self): def test_read_ready_recv_eof(self):
self.sslsock.recv.return_value = b'' self.sslsock.recv.return_value = b''
transport = self._make_one() transport = self._make_one()
transport.close = unittest.mock.Mock() transport.close = mock.Mock()
transport._read_ready() transport._read_ready()
transport.close.assert_called_with() transport.close.assert_called_with()
self.protocol.eof_received.assert_called_with() self.protocol.eof_received.assert_called_with()
@ -1206,7 +1205,7 @@ def test_read_ready_recv_eof(self):
def test_read_ready_recv_conn_reset(self): def test_read_ready_recv_conn_reset(self):
err = self.sslsock.recv.side_effect = ConnectionResetError() err = self.sslsock.recv.side_effect = ConnectionResetError()
transport = self._make_one() transport = self._make_one()
transport._force_close = unittest.mock.Mock() transport._force_close = mock.Mock()
transport._read_ready() transport._read_ready()
transport._force_close.assert_called_with(err) transport._force_close.assert_called_with(err)
@ -1226,8 +1225,8 @@ def test_read_ready_recv_retry(self):
self.assertFalse(self.protocol.data_received.called) self.assertFalse(self.protocol.data_received.called)
def test_read_ready_recv_write(self): def test_read_ready_recv_write(self):
self.loop.remove_reader = unittest.mock.Mock() self.loop.remove_reader = mock.Mock()
self.loop.add_writer = unittest.mock.Mock() self.loop.add_writer = mock.Mock()
self.sslsock.recv.side_effect = ssl.SSLWantWriteError self.sslsock.recv.side_effect = ssl.SSLWantWriteError
transport = self._make_one() transport = self._make_one()
transport._read_ready() transport._read_ready()
@ -1241,7 +1240,7 @@ def test_read_ready_recv_write(self):
def test_read_ready_recv_exc(self): def test_read_ready_recv_exc(self):
err = self.sslsock.recv.side_effect = OSError() err = self.sslsock.recv.side_effect = OSError()
transport = self._make_one() transport = self._make_one()
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
err, err,
@ -1313,7 +1312,7 @@ def test_write_ready_send_read(self):
transport = self._make_one() transport = self._make_one()
transport._buffer = list_to_buffer([b'data']) transport._buffer = list_to_buffer([b'data'])
self.loop.remove_writer = unittest.mock.Mock() self.loop.remove_writer = mock.Mock()
self.sslsock.send.side_effect = ssl.SSLWantReadError self.sslsock.send.side_effect = ssl.SSLWantReadError
transport._write_ready() transport._write_ready()
self.assertFalse(self.protocol.data_received.called) self.assertFalse(self.protocol.data_received.called)
@ -1325,7 +1324,7 @@ def test_write_ready_send_exc(self):
transport = self._make_one() transport = self._make_one()
transport._buffer = list_to_buffer([b'data']) transport._buffer = list_to_buffer([b'data'])
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._write_ready() transport._write_ready()
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
err, err,
@ -1333,11 +1332,11 @@ def test_write_ready_send_exc(self):
self.assertEqual(list_to_buffer(), transport._buffer) self.assertEqual(list_to_buffer(), transport._buffer)
def test_write_ready_read_wants_write(self): def test_write_ready_read_wants_write(self):
self.loop.add_reader = unittest.mock.Mock() self.loop.add_reader = mock.Mock()
self.sslsock.send.side_effect = BlockingIOError self.sslsock.send.side_effect = BlockingIOError
transport = self._make_one() transport = self._make_one()
transport._read_wants_write = True transport._read_wants_write = True
transport._read_ready = unittest.mock.Mock() transport._read_ready = mock.Mock()
transport._write_ready() transport._write_ready()
self.assertFalse(transport._read_wants_write) self.assertFalse(transport._read_wants_write)
@ -1374,11 +1373,11 @@ def test_server_hostname(self):
class SelectorSslWithoutSslTransportTests(unittest.TestCase): class SelectorSslWithoutSslTransportTests(unittest.TestCase):
@unittest.mock.patch('asyncio.selector_events.ssl', None) @mock.patch('asyncio.selector_events.ssl', None)
def test_ssl_transport_requires_ssl_module(self): def test_ssl_transport_requires_ssl_module(self):
Mock = unittest.mock.Mock Mock = mock.Mock
with self.assertRaises(RuntimeError): with self.assertRaises(RuntimeError):
transport = _SelectorSslTransport(Mock(), Mock(), Mock(), Mock()) _SelectorSslTransport(Mock(), Mock(), Mock(), Mock())
class SelectorDatagramTransportTests(unittest.TestCase): class SelectorDatagramTransportTests(unittest.TestCase):
@ -1386,7 +1385,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.DatagramProtocol) self.protocol = test_utils.make_test_protocol(asyncio.DatagramProtocol)
self.sock = unittest.mock.Mock(spec_set=socket.socket) self.sock = mock.Mock(spec_set=socket.socket)
self.sock.fileno.return_value = 7 self.sock.fileno.return_value = 7
def test_read_ready(self): def test_read_ready(self):
@ -1404,7 +1403,7 @@ def test_read_ready_tryagain(self):
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
self.sock.recvfrom.side_effect = BlockingIOError self.sock.recvfrom.side_effect = BlockingIOError
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
@ -1414,7 +1413,7 @@ def test_read_ready_err(self):
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
err = self.sock.recvfrom.side_effect = RuntimeError() err = self.sock.recvfrom.side_effect = RuntimeError()
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
transport._fatal_error.assert_called_with( transport._fatal_error.assert_called_with(
@ -1426,7 +1425,7 @@ def test_read_ready_oserr(self):
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
err = self.sock.recvfrom.side_effect = OSError() err = self.sock.recvfrom.side_effect = OSError()
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._read_ready() transport._read_ready()
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
@ -1518,14 +1517,14 @@ def test_sendto_tryagain(self):
self.assertEqual( self.assertEqual(
[(b'data', ('0.0.0.0', 12345))], list(transport._buffer)) [(b'data', ('0.0.0.0', 12345))], list(transport._buffer))
@unittest.mock.patch('asyncio.selector_events.logger') @mock.patch('asyncio.selector_events.logger')
def test_sendto_exception(self, m_log): def test_sendto_exception(self, m_log):
data = b'data' data = b'data'
err = self.sock.sendto.side_effect = RuntimeError() err = self.sock.sendto.side_effect = RuntimeError()
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport.sendto(data, ()) transport.sendto(data, ())
self.assertTrue(transport._fatal_error.called) self.assertTrue(transport._fatal_error.called)
@ -1549,7 +1548,7 @@ def test_sendto_error_received(self):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport.sendto(data, ()) transport.sendto(data, ())
self.assertEqual(transport._conn_lost, 0) self.assertEqual(transport._conn_lost, 0)
@ -1562,7 +1561,7 @@ def test_sendto_error_received_connected(self):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol, ('0.0.0.0', 1)) self.loop, self.sock, self.protocol, ('0.0.0.0', 1))
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport.sendto(data) transport.sendto(data)
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
@ -1643,7 +1642,7 @@ def test_sendto_ready_exception(self):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._buffer.append((b'data', ())) transport._buffer.append((b'data', ()))
transport._sendto_ready() transport._sendto_ready()
@ -1656,7 +1655,7 @@ def test_sendto_ready_error_received(self):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol) self.loop, self.sock, self.protocol)
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._buffer.append((b'data', ())) transport._buffer.append((b'data', ()))
transport._sendto_ready() transport._sendto_ready()
@ -1667,14 +1666,14 @@ def test_sendto_ready_error_received_connection(self):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol, ('0.0.0.0', 1)) self.loop, self.sock, self.protocol, ('0.0.0.0', 1))
transport._fatal_error = unittest.mock.Mock() transport._fatal_error = mock.Mock()
transport._buffer.append((b'data', ())) transport._buffer.append((b'data', ()))
transport._sendto_ready() transport._sendto_ready()
self.assertFalse(transport._fatal_error.called) self.assertFalse(transport._fatal_error.called)
self.assertTrue(self.protocol.error_received.called) self.assertTrue(self.protocol.error_received.called)
@unittest.mock.patch('asyncio.base_events.logger.error') @mock.patch('asyncio.base_events.logger.error')
def test_fatal_error_connected(self, m_exc): def test_fatal_error_connected(self, m_exc):
transport = _SelectorDatagramTransport( transport = _SelectorDatagramTransport(
self.loop, self.sock, self.protocol, ('0.0.0.0', 1)) self.loop, self.sock, self.protocol, ('0.0.0.0', 1))

5
Lib/test/test_asyncio/test_streams.py
View file

@ -1,10 +1,9 @@
"""Tests for streams.py.""" """Tests for streams.py."""
import functools
import gc import gc
import socket import socket
import unittest import unittest
import unittest.mock from unittest import mock
try: try:
import ssl import ssl
except ImportError: except ImportError:
@ -29,7 +28,7 @@ def tearDown(self):
self.loop.close() self.loop.close()
gc.collect() gc.collect()
@unittest.mock.patch('asyncio.streams.events') @mock.patch('asyncio.streams.events')
def test_ctor_global_loop(self, m_events): def test_ctor_global_loop(self, m_events):
stream = asyncio.StreamReader() stream = asyncio.StreamReader()
self.assertIs(stream._loop, m_events.get_event_loop.return_value) self.assertIs(stream._loop, m_events.get_event_loop.return_value)

8
Lib/test/test_asyncio/test_tasks.py
View file

@ -830,7 +830,7 @@ def foo():
v = yield from f v = yield from f
self.assertEqual(v, 'a') self.assertEqual(v, 'a')
res = loop.run_until_complete(asyncio.Task(foo(), loop=loop)) loop.run_until_complete(asyncio.Task(foo(), loop=loop))
def test_as_completed_reverse_wait(self): def test_as_completed_reverse_wait(self):
@ -964,13 +964,9 @@ def gen():
loop = test_utils.TestLoop(gen) loop = test_utils.TestLoop(gen)
self.addCleanup(loop.close) self.addCleanup(loop.close)
sleepfut = None
@asyncio.coroutine @asyncio.coroutine
def sleep(dt): def sleep(dt):
nonlocal sleepfut yield from asyncio.sleep(dt, loop=loop)
sleepfut = asyncio.sleep(dt, loop=loop)
yield from sleepfut
@asyncio.coroutine @asyncio.coroutine
def doit(): def doit():

6
Lib/test/test_asyncio/test_transports.py
View file

@ -1,7 +1,7 @@
"""Tests for transports.py.""" """Tests for transports.py."""
import unittest import unittest
import unittest.mock from unittest import mock
import asyncio import asyncio
from asyncio import transports from asyncio import transports
@ -23,7 +23,7 @@ def test_get_extra_info(self):
def test_writelines(self): def test_writelines(self):
transport = asyncio.Transport() transport = asyncio.Transport()
transport.write = unittest.mock.Mock() transport.write = mock.Mock()
transport.writelines([b'line1', transport.writelines([b'line1',
bytearray(b'line2'), bytearray(b'line2'),
@ -70,7 +70,7 @@ def get_write_buffer_size(self):
return 512 return 512
transport = MyTransport() transport = MyTransport()
transport._protocol = unittest.mock.Mock() transport._protocol = mock.Mock()
self.assertFalse(transport._protocol_paused) self.assertFalse(transport._protocol_paused)

200
Lib/test/test_asyncio/test_unix_events.py
View file

@ -13,7 +13,7 @@
import tempfile import tempfile
import threading import threading
import unittest import unittest
import unittest.mock from unittest import mock
if sys.platform == 'win32': if sys.platform == 'win32':
raise unittest.SkipTest('UNIX only') raise unittest.SkipTest('UNIX only')
@ -25,7 +25,7 @@
from asyncio import unix_events from asyncio import unix_events
MOCK_ANY = unittest.mock.ANY MOCK_ANY = mock.ANY
@unittest.skipUnless(signal, 'Signals are not supported') @unittest.skipUnless(signal, 'Signals are not supported')
@ -48,15 +48,15 @@ def test_handle_signal_no_handler(self):
self.loop._handle_signal(signal.NSIG + 1, ()) self.loop._handle_signal(signal.NSIG + 1, ())
def test_handle_signal_cancelled_handler(self): def test_handle_signal_cancelled_handler(self):
h = asyncio.Handle(unittest.mock.Mock(), (), h = asyncio.Handle(mock.Mock(), (),
loop=unittest.mock.Mock()) loop=mock.Mock())
h.cancel() h.cancel()
self.loop._signal_handlers[signal.NSIG + 1] = h self.loop._signal_handlers[signal.NSIG + 1] = h
self.loop.remove_signal_handler = unittest.mock.Mock() self.loop.remove_signal_handler = mock.Mock()
self.loop._handle_signal(signal.NSIG + 1, ()) self.loop._handle_signal(signal.NSIG + 1, ())
self.loop.remove_signal_handler.assert_called_with(signal.NSIG + 1) self.loop.remove_signal_handler.assert_called_with(signal.NSIG + 1)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_add_signal_handler_setup_error(self, m_signal): def test_add_signal_handler_setup_error(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
m_signal.set_wakeup_fd.side_effect = ValueError m_signal.set_wakeup_fd.side_effect = ValueError
@ -66,7 +66,7 @@ def test_add_signal_handler_setup_error(self, m_signal):
self.loop.add_signal_handler, self.loop.add_signal_handler,
signal.SIGINT, lambda: True) signal.SIGINT, lambda: True)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_add_signal_handler(self, m_signal): def test_add_signal_handler(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
@ -76,7 +76,7 @@ def test_add_signal_handler(self, m_signal):
self.assertIsInstance(h, asyncio.Handle) self.assertIsInstance(h, asyncio.Handle)
self.assertEqual(h._callback, cb) self.assertEqual(h._callback, cb)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_add_signal_handler_install_error(self, m_signal): def test_add_signal_handler_install_error(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
@ -94,8 +94,8 @@ class Err(OSError):
self.loop.add_signal_handler, self.loop.add_signal_handler,
signal.SIGINT, lambda: True) signal.SIGINT, lambda: True)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_add_signal_handler_install_error2(self, m_logging, m_signal): def test_add_signal_handler_install_error2(self, m_logging, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
@ -111,8 +111,8 @@ class Err(OSError):
self.assertFalse(m_logging.info.called) self.assertFalse(m_logging.info.called)
self.assertEqual(1, m_signal.set_wakeup_fd.call_count) self.assertEqual(1, m_signal.set_wakeup_fd.call_count)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_add_signal_handler_install_error3(self, m_logging, m_signal): def test_add_signal_handler_install_error3(self, m_logging, m_signal):
class Err(OSError): class Err(OSError):
errno = errno.EINVAL errno = errno.EINVAL
@ -126,7 +126,7 @@ class Err(OSError):
self.assertFalse(m_logging.info.called) self.assertFalse(m_logging.info.called)
self.assertEqual(2, m_signal.set_wakeup_fd.call_count) self.assertEqual(2, m_signal.set_wakeup_fd.call_count)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_remove_signal_handler(self, m_signal): def test_remove_signal_handler(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
@ -139,7 +139,7 @@ def test_remove_signal_handler(self, m_signal):
self.assertEqual( self.assertEqual(
(signal.SIGHUP, m_signal.SIG_DFL), m_signal.signal.call_args[0]) (signal.SIGHUP, m_signal.SIG_DFL), m_signal.signal.call_args[0])
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_remove_signal_handler_2(self, m_signal): def test_remove_signal_handler_2(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
m_signal.SIGINT = signal.SIGINT m_signal.SIGINT = signal.SIGINT
@ -156,8 +156,8 @@ def test_remove_signal_handler_2(self, m_signal):
(signal.SIGINT, m_signal.default_int_handler), (signal.SIGINT, m_signal.default_int_handler),
m_signal.signal.call_args[0]) m_signal.signal.call_args[0])
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
@unittest.mock.patch('asyncio.base_events.logger') @mock.patch('asyncio.base_events.logger')
def test_remove_signal_handler_cleanup_error(self, m_logging, m_signal): def test_remove_signal_handler_cleanup_error(self, m_logging, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
self.loop.add_signal_handler(signal.SIGHUP, lambda: True) self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
@ -167,7 +167,7 @@ def test_remove_signal_handler_cleanup_error(self, m_logging, m_signal):
self.loop.remove_signal_handler(signal.SIGHUP) self.loop.remove_signal_handler(signal.SIGHUP)
self.assertTrue(m_logging.info) self.assertTrue(m_logging.info)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_remove_signal_handler_error(self, m_signal): def test_remove_signal_handler_error(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
self.loop.add_signal_handler(signal.SIGHUP, lambda: True) self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
@ -177,7 +177,7 @@ def test_remove_signal_handler_error(self, m_signal):
self.assertRaises( self.assertRaises(
OSError, self.loop.remove_signal_handler, signal.SIGHUP) OSError, self.loop.remove_signal_handler, signal.SIGHUP)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_remove_signal_handler_error2(self, m_signal): def test_remove_signal_handler_error2(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
self.loop.add_signal_handler(signal.SIGHUP, lambda: True) self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
@ -189,7 +189,7 @@ class Err(OSError):
self.assertRaises( self.assertRaises(
RuntimeError, self.loop.remove_signal_handler, signal.SIGHUP) RuntimeError, self.loop.remove_signal_handler, signal.SIGHUP)
@unittest.mock.patch('asyncio.unix_events.signal') @mock.patch('asyncio.unix_events.signal')
def test_close(self, m_signal): def test_close(self, m_signal):
m_signal.NSIG = signal.NSIG m_signal.NSIG = signal.NSIG
@ -291,16 +291,16 @@ class UnixReadPipeTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.Protocol) self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
self.pipe = unittest.mock.Mock(spec_set=io.RawIOBase) self.pipe = mock.Mock(spec_set=io.RawIOBase)
self.pipe.fileno.return_value = 5 self.pipe.fileno.return_value = 5
fcntl_patcher = unittest.mock.patch('fcntl.fcntl') fcntl_patcher = mock.patch('fcntl.fcntl')
fcntl_patcher.start() fcntl_patcher.start()
self.addCleanup(fcntl_patcher.stop) self.addCleanup(fcntl_patcher.stop)
fstat_patcher = unittest.mock.patch('os.fstat') fstat_patcher = mock.patch('os.fstat')
m_fstat = fstat_patcher.start() m_fstat = fstat_patcher.start()
st = unittest.mock.Mock() st = mock.Mock()
st.st_mode = stat.S_IFIFO st.st_mode = stat.S_IFIFO
m_fstat.return_value = st m_fstat.return_value = st
self.addCleanup(fstat_patcher.stop) self.addCleanup(fstat_patcher.stop)
@ -319,7 +319,7 @@ def test_ctor_with_waiter(self):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.assertIsNone(fut.result()) self.assertIsNone(fut.result())
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test__read_ready(self, m_read): def test__read_ready(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -329,7 +329,7 @@ def test__read_ready(self, m_read):
m_read.assert_called_with(5, tr.max_size) m_read.assert_called_with(5, tr.max_size)
self.protocol.data_received.assert_called_with(b'data') self.protocol.data_received.assert_called_with(b'data')
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test__read_ready_eof(self, m_read): def test__read_ready_eof(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -342,7 +342,7 @@ def test__read_ready_eof(self, m_read):
self.protocol.eof_received.assert_called_with() self.protocol.eof_received.assert_called_with()
self.protocol.connection_lost.assert_called_with(None) self.protocol.connection_lost.assert_called_with(None)
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test__read_ready_blocked(self, m_read): def test__read_ready_blocked(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -353,14 +353,14 @@ def test__read_ready_blocked(self, m_read):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.assertFalse(self.protocol.data_received.called) self.assertFalse(self.protocol.data_received.called)
@unittest.mock.patch('asyncio.log.logger.error') @mock.patch('asyncio.log.logger.error')
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test__read_ready_error(self, m_read, m_logexc): def test__read_ready_error(self, m_read, m_logexc):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
err = OSError() err = OSError()
m_read.side_effect = err m_read.side_effect = err
tr._close = unittest.mock.Mock() tr._close = mock.Mock()
tr._read_ready() tr._read_ready()
m_read.assert_called_with(5, tr.max_size) m_read.assert_called_with(5, tr.max_size)
@ -371,17 +371,17 @@ def test__read_ready_error(self, m_read, m_logexc):
'\nprotocol:.*\ntransport:.*'), '\nprotocol:.*\ntransport:.*'),
exc_info=(OSError, MOCK_ANY, MOCK_ANY)) exc_info=(OSError, MOCK_ANY, MOCK_ANY))
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test_pause_reading(self, m_read): def test_pause_reading(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
m = unittest.mock.Mock() m = mock.Mock()
self.loop.add_reader(5, m) self.loop.add_reader(5, m)
tr.pause_reading() tr.pause_reading()
self.assertFalse(self.loop.readers) self.assertFalse(self.loop.readers)
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test_resume_reading(self, m_read): def test_resume_reading(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -389,26 +389,26 @@ def test_resume_reading(self, m_read):
tr.resume_reading() tr.resume_reading()
self.loop.assert_reader(5, tr._read_ready) self.loop.assert_reader(5, tr._read_ready)
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test_close(self, m_read): def test_close(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
tr._close = unittest.mock.Mock() tr._close = mock.Mock()
tr.close() tr.close()
tr._close.assert_called_with(None) tr._close.assert_called_with(None)
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test_close_already_closing(self, m_read): def test_close_already_closing(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
tr._closing = True tr._closing = True
tr._close = unittest.mock.Mock() tr._close = mock.Mock()
tr.close() tr.close()
self.assertFalse(tr._close.called) self.assertFalse(tr._close.called)
@unittest.mock.patch('os.read') @mock.patch('os.read')
def test__close(self, m_read): def test__close(self, m_read):
tr = unix_events._UnixReadPipeTransport( tr = unix_events._UnixReadPipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -459,16 +459,16 @@ class UnixWritePipeTransportTests(unittest.TestCase):
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.protocol = test_utils.make_test_protocol(asyncio.BaseProtocol) self.protocol = test_utils.make_test_protocol(asyncio.BaseProtocol)
self.pipe = unittest.mock.Mock(spec_set=io.RawIOBase) self.pipe = mock.Mock(spec_set=io.RawIOBase)
self.pipe.fileno.return_value = 5 self.pipe.fileno.return_value = 5
fcntl_patcher = unittest.mock.patch('fcntl.fcntl') fcntl_patcher = mock.patch('fcntl.fcntl')
fcntl_patcher.start() fcntl_patcher.start()
self.addCleanup(fcntl_patcher.stop) self.addCleanup(fcntl_patcher.stop)
fstat_patcher = unittest.mock.patch('os.fstat') fstat_patcher = mock.patch('os.fstat')
m_fstat = fstat_patcher.start() m_fstat = fstat_patcher.start()
st = unittest.mock.Mock() st = mock.Mock()
st.st_mode = stat.S_IFSOCK st.st_mode = stat.S_IFSOCK
m_fstat.return_value = st m_fstat.return_value = st
self.addCleanup(fstat_patcher.stop) self.addCleanup(fstat_patcher.stop)
@ -493,7 +493,7 @@ def test_can_write_eof(self):
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
self.assertTrue(tr.can_write_eof()) self.assertTrue(tr.can_write_eof())
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write(self, m_write): def test_write(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -504,7 +504,7 @@ def test_write(self, m_write):
self.assertFalse(self.loop.writers) self.assertFalse(self.loop.writers)
self.assertEqual([], tr._buffer) self.assertEqual([], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_no_data(self, m_write): def test_write_no_data(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -514,7 +514,7 @@ def test_write_no_data(self, m_write):
self.assertFalse(self.loop.writers) self.assertFalse(self.loop.writers)
self.assertEqual([], tr._buffer) self.assertEqual([], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_partial(self, m_write): def test_write_partial(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -525,7 +525,7 @@ def test_write_partial(self, m_write):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'ta'], tr._buffer) self.assertEqual([b'ta'], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_buffer(self, m_write): def test_write_buffer(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -537,7 +537,7 @@ def test_write_buffer(self, m_write):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'previous', b'data'], tr._buffer) self.assertEqual([b'previous', b'data'], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_again(self, m_write): def test_write_again(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -548,15 +548,15 @@ def test_write_again(self, m_write):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'data'], tr._buffer) self.assertEqual([b'data'], tr._buffer)
@unittest.mock.patch('asyncio.unix_events.logger') @mock.patch('asyncio.unix_events.logger')
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_err(self, m_write, m_log): def test_write_err(self, m_write, m_log):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
err = OSError() err = OSError()
m_write.side_effect = err m_write.side_effect = err
tr._fatal_error = unittest.mock.Mock() tr._fatal_error = mock.Mock()
tr.write(b'data') tr.write(b'data')
m_write.assert_called_with(5, b'data') m_write.assert_called_with(5, b'data')
self.assertFalse(self.loop.writers) self.assertFalse(self.loop.writers)
@ -576,7 +576,7 @@ def test_write_err(self, m_write, m_log):
m_log.warning.assert_called_with( m_log.warning.assert_called_with(
'pipe closed by peer or os.write(pipe, data) raised exception.') 'pipe closed by peer or os.write(pipe, data) raised exception.')
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_write_close(self, m_write): def test_write_close(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -597,7 +597,7 @@ def test__read_ready(self):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.protocol.connection_lost.assert_called_with(None) self.protocol.connection_lost.assert_called_with(None)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready(self, m_write): def test__write_ready(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -609,7 +609,7 @@ def test__write_ready(self, m_write):
self.assertFalse(self.loop.writers) self.assertFalse(self.loop.writers)
self.assertEqual([], tr._buffer) self.assertEqual([], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready_partial(self, m_write): def test__write_ready_partial(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -622,7 +622,7 @@ def test__write_ready_partial(self, m_write):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'a'], tr._buffer) self.assertEqual([b'a'], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready_again(self, m_write): def test__write_ready_again(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -635,7 +635,7 @@ def test__write_ready_again(self, m_write):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'data'], tr._buffer) self.assertEqual([b'data'], tr._buffer)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready_empty(self, m_write): def test__write_ready_empty(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -648,8 +648,8 @@ def test__write_ready_empty(self, m_write):
self.loop.assert_writer(5, tr._write_ready) self.loop.assert_writer(5, tr._write_ready)
self.assertEqual([b'data'], tr._buffer) self.assertEqual([b'data'], tr._buffer)
@unittest.mock.patch('asyncio.log.logger.error') @mock.patch('asyncio.log.logger.error')
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready_err(self, m_write, m_logexc): def test__write_ready_err(self, m_write, m_logexc):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -672,7 +672,7 @@ def test__write_ready_err(self, m_write, m_logexc):
test_utils.run_briefly(self.loop) test_utils.run_briefly(self.loop)
self.protocol.connection_lost.assert_called_with(err) self.protocol.connection_lost.assert_called_with(err)
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test__write_ready_closing(self, m_write): def test__write_ready_closing(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -689,7 +689,7 @@ def test__write_ready_closing(self, m_write):
self.protocol.connection_lost.assert_called_with(None) self.protocol.connection_lost.assert_called_with(None)
self.pipe.close.assert_called_with() self.pipe.close.assert_called_with()
@unittest.mock.patch('os.write') @mock.patch('os.write')
def test_abort(self, m_write): def test_abort(self, m_write):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
@ -742,7 +742,7 @@ def test_close(self):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
tr.write_eof = unittest.mock.Mock() tr.write_eof = mock.Mock()
tr.close() tr.close()
tr.write_eof.assert_called_with() tr.write_eof.assert_called_with()
@ -750,7 +750,7 @@ def test_close_closing(self):
tr = unix_events._UnixWritePipeTransport( tr = unix_events._UnixWritePipeTransport(
self.loop, self.pipe, self.protocol) self.loop, self.pipe, self.protocol)
tr.write_eof = unittest.mock.Mock() tr.write_eof = mock.Mock()
tr._closing = True tr._closing = True
tr.close() tr.close()
self.assertFalse(tr.write_eof.called) self.assertFalse(tr.write_eof.called)
@ -777,7 +777,7 @@ def test_write_eof_pending(self):
class AbstractChildWatcherTests(unittest.TestCase): class AbstractChildWatcherTests(unittest.TestCase):
def test_not_implemented(self): def test_not_implemented(self):
f = unittest.mock.Mock() f = mock.Mock()
watcher = asyncio.AbstractChildWatcher() watcher = asyncio.AbstractChildWatcher()
self.assertRaises( self.assertRaises(
NotImplementedError, watcher.add_child_handler, f, f) NotImplementedError, watcher.add_child_handler, f, f)
@ -796,7 +796,7 @@ def test_not_implemented(self):
class BaseChildWatcherTests(unittest.TestCase): class BaseChildWatcherTests(unittest.TestCase):
def test_not_implemented(self): def test_not_implemented(self):
f = unittest.mock.Mock() f = mock.Mock()
watcher = unix_events.BaseChildWatcher() watcher = unix_events.BaseChildWatcher()
self.assertRaises( self.assertRaises(
NotImplementedError, watcher._do_waitpid, f) NotImplementedError, watcher._do_waitpid, f)
@ -813,14 +813,14 @@ def test_not_implemented(self):
class ChildWatcherTestsMixin: class ChildWatcherTestsMixin:
ignore_warnings = unittest.mock.patch.object(log.logger, "warning") ignore_warnings = mock.patch.object(log.logger, "warning")
def setUp(self): def setUp(self):
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
self.running = False self.running = False
self.zombies = {} self.zombies = {}
with unittest.mock.patch.object( with mock.patch.object(
self.loop, "add_signal_handler") as self.m_add_signal_handler: self.loop, "add_signal_handler") as self.m_add_signal_handler:
self.watcher = self.create_watcher() self.watcher = self.create_watcher()
self.watcher.attach_loop(self.loop) self.watcher.attach_loop(self.loop)
@ -864,8 +864,8 @@ def test_create_watcher(self):
def waitpid_mocks(func): def waitpid_mocks(func):
def wrapped_func(self): def wrapped_func(self):
def patch(target, wrapper): def patch(target, wrapper):
return unittest.mock.patch(target, wraps=wrapper, return mock.patch(target, wraps=wrapper,
new_callable=unittest.mock.Mock) new_callable=mock.Mock)
with patch('os.WTERMSIG', self.WTERMSIG) as m_WTERMSIG, \ with patch('os.WTERMSIG', self.WTERMSIG) as m_WTERMSIG, \
patch('os.WEXITSTATUS', self.WEXITSTATUS) as m_WEXITSTATUS, \ patch('os.WEXITSTATUS', self.WEXITSTATUS) as m_WEXITSTATUS, \
@ -881,7 +881,7 @@ def patch(target, wrapper):
@waitpid_mocks @waitpid_mocks
def test_sigchld(self, m): def test_sigchld(self, m):
# register a child # register a child
callback = unittest.mock.Mock() callback = mock.Mock()
with self.watcher: with self.watcher:
self.running = True self.running = True
@ -941,8 +941,8 @@ def test_sigchld(self, m):
@waitpid_mocks @waitpid_mocks
def test_sigchld_two_children(self, m): def test_sigchld_two_children(self, m):
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
# register child 1 # register child 1
with self.watcher: with self.watcher:
@ -1045,8 +1045,8 @@ def test_sigchld_two_children(self, m):
@waitpid_mocks @waitpid_mocks
def test_sigchld_two_children_terminating_together(self, m): def test_sigchld_two_children_terminating_together(self, m):
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
# register child 1 # register child 1
with self.watcher: with self.watcher:
@ -1115,7 +1115,7 @@ def test_sigchld_two_children_terminating_together(self, m):
@waitpid_mocks @waitpid_mocks
def test_sigchld_race_condition(self, m): def test_sigchld_race_condition(self, m):
# register a child # register a child
callback = unittest.mock.Mock() callback = mock.Mock()
with self.watcher: with self.watcher:
# child terminates before being registered # child terminates before being registered
@ -1136,8 +1136,8 @@ def test_sigchld_race_condition(self, m):
@waitpid_mocks @waitpid_mocks
def test_sigchld_replace_handler(self, m): def test_sigchld_replace_handler(self, m):
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
# register a child # register a child
with self.watcher: with self.watcher:
@ -1189,7 +1189,7 @@ def test_sigchld_replace_handler(self, m):
@waitpid_mocks @waitpid_mocks
def test_sigchld_remove_handler(self, m): def test_sigchld_remove_handler(self, m):
callback = unittest.mock.Mock() callback = mock.Mock()
# register a child # register a child
with self.watcher: with self.watcher:
@ -1221,7 +1221,7 @@ def test_sigchld_remove_handler(self, m):
@waitpid_mocks @waitpid_mocks
def test_sigchld_unknown_status(self, m): def test_sigchld_unknown_status(self, m):
callback = unittest.mock.Mock() callback = mock.Mock()
# register a child # register a child
with self.watcher: with self.watcher:
@ -1258,9 +1258,9 @@ def test_sigchld_unknown_status(self, m):
@waitpid_mocks @waitpid_mocks
def test_remove_child_handler(self, m): def test_remove_child_handler(self, m):
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
callback3 = unittest.mock.Mock() callback3 = mock.Mock()
# register children # register children
with self.watcher: with self.watcher:
@ -1291,7 +1291,7 @@ def test_remove_child_handler(self, m):
@waitpid_mocks @waitpid_mocks
def test_sigchld_unhandled_exception(self, m): def test_sigchld_unhandled_exception(self, m):
callback = unittest.mock.Mock() callback = mock.Mock()
# register a child # register a child
with self.watcher: with self.watcher:
@ -1301,8 +1301,8 @@ def test_sigchld_unhandled_exception(self, m):
# raise an exception # raise an exception
m.waitpid.side_effect = ValueError m.waitpid.side_effect = ValueError
with unittest.mock.patch.object(log.logger, with mock.patch.object(log.logger,
'error') as m_error: 'error') as m_error:
self.assertEqual(self.watcher._sig_chld(), None) self.assertEqual(self.watcher._sig_chld(), None)
self.assertTrue(m_error.called) self.assertTrue(m_error.called)
@ -1310,7 +1310,7 @@ def test_sigchld_unhandled_exception(self, m):
@waitpid_mocks @waitpid_mocks
def test_sigchld_child_reaped_elsewhere(self, m): def test_sigchld_child_reaped_elsewhere(self, m):
# register a child # register a child
callback = unittest.mock.Mock() callback = mock.Mock()
with self.watcher: with self.watcher:
self.running = True self.running = True
@ -1346,8 +1346,8 @@ def test_sigchld_child_reaped_elsewhere(self, m):
@waitpid_mocks @waitpid_mocks
def test_sigchld_unknown_pid_during_registration(self, m): def test_sigchld_unknown_pid_during_registration(self, m):
# register two children # register two children
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
with self.ignore_warnings, self.watcher: with self.ignore_warnings, self.watcher:
self.running = True self.running = True
@ -1367,7 +1367,7 @@ def test_sigchld_unknown_pid_during_registration(self, m):
@waitpid_mocks @waitpid_mocks
def test_set_loop(self, m): def test_set_loop(self, m):
# register a child # register a child
callback = unittest.mock.Mock() callback = mock.Mock()
with self.watcher: with self.watcher:
self.running = True self.running = True
@ -1376,19 +1376,16 @@ def test_set_loop(self, m):
# attach a new loop # attach a new loop
old_loop = self.loop old_loop = self.loop
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
patch = mock.patch.object
with unittest.mock.patch.object( with patch(old_loop, "remove_signal_handler") as m_old_remove, \
old_loop, patch(self.loop, "add_signal_handler") as m_new_add:
"remove_signal_handler") as m_old_remove_signal_handler, \
unittest.mock.patch.object(
self.loop,
"add_signal_handler") as m_new_add_signal_handler:
self.watcher.attach_loop(self.loop) self.watcher.attach_loop(self.loop)
m_old_remove_signal_handler.assert_called_once_with( m_old_remove.assert_called_once_with(
signal.SIGCHLD) signal.SIGCHLD)
m_new_add_signal_handler.assert_called_once_with( m_new_add.assert_called_once_with(
signal.SIGCHLD, self.watcher._sig_chld) signal.SIGCHLD, self.watcher._sig_chld)
# child terminates # child terminates
@ -1401,9 +1398,9 @@ def test_set_loop(self, m):
@waitpid_mocks @waitpid_mocks
def test_set_loop_race_condition(self, m): def test_set_loop_race_condition(self, m):
# register 3 children # register 3 children
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock() callback2 = mock.Mock()
callback3 = unittest.mock.Mock() callback3 = mock.Mock()
with self.watcher: with self.watcher:
self.running = True self.running = True
@ -1415,7 +1412,7 @@ def test_set_loop_race_condition(self, m):
old_loop = self.loop old_loop = self.loop
self.loop = None self.loop = None
with unittest.mock.patch.object( with mock.patch.object(
old_loop, "remove_signal_handler") as m_remove_signal_handler: old_loop, "remove_signal_handler") as m_remove_signal_handler:
self.watcher.attach_loop(None) self.watcher.attach_loop(None)
@ -1435,7 +1432,7 @@ def test_set_loop_race_condition(self, m):
# attach a new loop # attach a new loop
self.loop = test_utils.TestLoop() self.loop = test_utils.TestLoop()
with unittest.mock.patch.object( with mock.patch.object(
self.loop, "add_signal_handler") as m_add_signal_handler: self.loop, "add_signal_handler") as m_add_signal_handler:
self.watcher.attach_loop(self.loop) self.watcher.attach_loop(self.loop)
@ -1461,8 +1458,7 @@ def test_set_loop_race_condition(self, m):
@waitpid_mocks @waitpid_mocks
def test_close(self, m): def test_close(self, m):
# register two children # register two children
callback1 = unittest.mock.Mock() callback1 = mock.Mock()
callback2 = unittest.mock.Mock()
with self.watcher: with self.watcher:
self.running = True self.running = True
@ -1479,7 +1475,7 @@ def test_close(self, m):
if isinstance(self.watcher, asyncio.FastChildWatcher): if isinstance(self.watcher, asyncio.FastChildWatcher):
self.assertEqual(len(self.watcher._zombies), 1) self.assertEqual(len(self.watcher._zombies), 1)
with unittest.mock.patch.object( with mock.patch.object(
self.loop, self.loop,
"remove_signal_handler") as m_remove_signal_handler: "remove_signal_handler") as m_remove_signal_handler:

3
Lib/test/test_asyncio/test_windows_events.py
View file

@ -8,7 +8,6 @@
import _winapi import _winapi
import asyncio import asyncio
from asyncio import test_utils
from asyncio import _overlapped from asyncio import _overlapped
from asyncio import windows_events from asyncio import windows_events
@ -50,7 +49,7 @@ def test_double_bind(self):
ADDRESS = r'\\.\pipe\test_double_bind-%s' % os.getpid() ADDRESS = r'\\.\pipe\test_double_bind-%s' % os.getpid()
server1 = windows_events.PipeServer(ADDRESS) server1 = windows_events.PipeServer(ADDRESS)
with self.assertRaises(PermissionError): with self.assertRaises(PermissionError):
server2 = windows_events.PipeServer(ADDRESS) windows_events.PipeServer(ADDRESS)
server1.close() server1.close()
def test_pipe(self): def test_pipe(self):

31
Lib/test/test_asyncio/test_windows_utils.py
View file

@ -1,9 +1,11 @@
"""Tests for window_utils""" """Tests for window_utils"""
import socket
import sys import sys
import test.support import test.support
import unittest import unittest
import unittest.mock from test.support import IPV6_ENABLED
from unittest import mock
if sys.platform != 'win32': if sys.platform != 'win32':
raise unittest.SkipTest('Windows only') raise unittest.SkipTest('Windows only')
@ -16,23 +18,40 @@
class WinsocketpairTests(unittest.TestCase): class WinsocketpairTests(unittest.TestCase):
def test_winsocketpair(self): def check_winsocketpair(self, ssock, csock):
ssock, csock = windows_utils.socketpair()
csock.send(b'xxx') csock.send(b'xxx')
self.assertEqual(b'xxx', ssock.recv(1024)) self.assertEqual(b'xxx', ssock.recv(1024))
csock.close() csock.close()
ssock.close() ssock.close()
@unittest.mock.patch('asyncio.windows_utils.socket') def test_winsocketpair(self):
ssock, csock = windows_utils.socketpair()
self.check_winsocketpair(ssock, csock)
@unittest.skipUnless(IPV6_ENABLED, 'IPv6 not supported or enabled')
def test_winsocketpair_ipv6(self):
ssock, csock = windows_utils.socketpair(family=socket.AF_INET6)
self.check_winsocketpair(ssock, csock)
@mock.patch('asyncio.windows_utils.socket')
def test_winsocketpair_exc(self, m_socket): def test_winsocketpair_exc(self, m_socket):
m_socket.AF_INET = socket.AF_INET
m_socket.SOCK_STREAM = socket.SOCK_STREAM
m_socket.socket.return_value.getsockname.return_value = ('', 12345) m_socket.socket.return_value.getsockname.return_value = ('', 12345)
m_socket.socket.return_value.accept.return_value = object(), object() m_socket.socket.return_value.accept.return_value = object(), object()
m_socket.socket.return_value.connect.side_effect = OSError() m_socket.socket.return_value.connect.side_effect = OSError()
self.assertRaises(OSError, windows_utils.socketpair) self.assertRaises(OSError, windows_utils.socketpair)
def test_winsocketpair_invalid_args(self):
self.assertRaises(ValueError,
windows_utils.socketpair, family=socket.AF_UNSPEC)
self.assertRaises(ValueError,
windows_utils.socketpair, type=socket.SOCK_DGRAM)
self.assertRaises(ValueError,
windows_utils.socketpair, proto=1)
class PipeTests(unittest.TestCase): class PipeTests(unittest.TestCase):

1
Lib/test/test_copy.py
View file

@ -98,6 +98,7 @@ class WithMetaclass(metaclass=abc.ABCMeta):
pass pass
tests = [None, 42, 2**100, 3.14, True, False, 1j, tests = [None, 42, 2**100, 3.14, True, False, 1j,
"hello", "hello\u1234", f.__code__, "hello", "hello\u1234", f.__code__,
b"world", bytes(range(256)),
NewStyle, range(10), Classic, max, WithMetaclass] NewStyle, range(10), Classic, max, WithMetaclass]
for x in tests: for x in tests:
self.assertIs(copy.copy(x), x) self.assertIs(copy.copy(x), x)

8
Lib/test/test_email/test_email.py
View file

@ -124,6 +124,14 @@ def test_set_payload_to_list(self):
msg.set_payload([]) msg.set_payload([])
self.assertEqual(msg.get_payload(), []) self.assertEqual(msg.get_payload(), [])
def test_attach_when_payload_is_string(self):
msg = Message()
msg['Content-Type'] = 'multipart/mixed'
msg.set_payload('string payload')
sub_msg = MIMEMessage(Message())
self.assertRaisesRegex(TypeError, "[Aa]ttach.*non-multipart",
msg.attach, sub_msg)
def test_get_charsets(self): def test_get_charsets(self):
eq = self.assertEqual eq = self.assertEqual

9
Lib/test/test_email/test_policy.py
View file

@ -319,5 +319,14 @@ def test_message_policy_used_by_as_string(self):
self.assertEqual(msg.as_string(), "Subject: testXTo: fooXX") self.assertEqual(msg.as_string(), "Subject: testXTo: fooXX")
class TestConcretePolicies(unittest.TestCase):
def test_header_store_parse_rejects_newlines(self):
instance = email.policy.EmailPolicy()
self.assertRaises(ValueError,
instance.header_store_parse,
'From', 'spam\negg@foo.py')
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

41
Lib/test/test_fileinput.py
View file

@ -260,6 +260,27 @@ def __call__(self, *args):
fi.readline() fi.readline()
self.assertTrue(custom_open_hook.invoked, "openhook not invoked") self.assertTrue(custom_open_hook.invoked, "openhook not invoked")
def test_readline(self):
with open(TESTFN, 'wb') as f:
f.write(b'A\nB\r\nC\r')
# Fill TextIOWrapper buffer.
f.write(b'123456789\n' * 1000)
# Issue #20501: readline() shouldn't read whole file.
f.write(b'\x80')
self.addCleanup(safe_unlink, TESTFN)
with FileInput(files=TESTFN,
openhook=hook_encoded('ascii'), bufsize=8) as fi:
try:
self.assertEqual(fi.readline(), 'A\n')
self.assertEqual(fi.readline(), 'B\n')
self.assertEqual(fi.readline(), 'C\n')
except UnicodeDecodeError:
self.fail('Read to end of file')
with self.assertRaises(UnicodeDecodeError):
# Read to the end of file.
list(fi)
def test_context_manager(self): def test_context_manager(self):
try: try:
t1 = writeTmp(1, ["A\nB\nC"]) t1 = writeTmp(1, ["A\nB\nC"])
@ -837,6 +858,26 @@ def test(self):
self.assertIs(kwargs.pop('encoding'), encoding) self.assertIs(kwargs.pop('encoding'), encoding)
self.assertFalse(kwargs) self.assertFalse(kwargs)
def test_modes(self):
with open(TESTFN, 'wb') as f:
# UTF-7 is a convenient, seldom used encoding
f.write(b'A\nB\r\nC\rD+IKw-')
self.addCleanup(safe_unlink, TESTFN)
def check(mode, expected_lines):
with FileInput(files=TESTFN, mode=mode,
openhook=hook_encoded('utf-7')) as fi:
lines = list(fi)
self.assertEqual(lines, expected_lines)
check('r', ['A\n', 'B\n', 'C\n', 'D\u20ac'])
with self.assertWarns(DeprecationWarning):
check('rU', ['A\n', 'B\n', 'C\n', 'D\u20ac'])
with self.assertWarns(DeprecationWarning):
check('U', ['A\n', 'B\n', 'C\n', 'D\u20ac'])
with self.assertRaises(ValueError):
check('rb', ['A\n', 'B\r\n', 'C\r', 'D\u20ac'])
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

30
Lib/test/test_genericpath.py
View file

@ -329,7 +329,6 @@ def test_expandvars(self):
self.assertEqual(expandvars("$[foo]bar"), "$[foo]bar") self.assertEqual(expandvars("$[foo]bar"), "$[foo]bar")
self.assertEqual(expandvars("$bar bar"), "$bar bar") self.assertEqual(expandvars("$bar bar"), "$bar bar")
self.assertEqual(expandvars("$?bar"), "$?bar") self.assertEqual(expandvars("$?bar"), "$?bar")
self.assertEqual(expandvars("${foo}bar"), "barbar")
self.assertEqual(expandvars("$foo}bar"), "bar}bar") self.assertEqual(expandvars("$foo}bar"), "bar}bar")
self.assertEqual(expandvars("${foo"), "${foo") self.assertEqual(expandvars("${foo"), "${foo")
self.assertEqual(expandvars("${{foo}}"), "baz1}") self.assertEqual(expandvars("${{foo}}"), "baz1}")
@ -342,13 +341,40 @@ def test_expandvars(self):
self.assertEqual(expandvars(b"$[foo]bar"), b"$[foo]bar") self.assertEqual(expandvars(b"$[foo]bar"), b"$[foo]bar")
self.assertEqual(expandvars(b"$bar bar"), b"$bar bar") self.assertEqual(expandvars(b"$bar bar"), b"$bar bar")
self.assertEqual(expandvars(b"$?bar"), b"$?bar") self.assertEqual(expandvars(b"$?bar"), b"$?bar")
self.assertEqual(expandvars(b"${foo}bar"), b"barbar")
self.assertEqual(expandvars(b"$foo}bar"), b"bar}bar") self.assertEqual(expandvars(b"$foo}bar"), b"bar}bar")
self.assertEqual(expandvars(b"${foo"), b"${foo") self.assertEqual(expandvars(b"${foo"), b"${foo")
self.assertEqual(expandvars(b"${{foo}}"), b"baz1}") self.assertEqual(expandvars(b"${{foo}}"), b"baz1}")
self.assertEqual(expandvars(b"$foo$foo"), b"barbar") self.assertEqual(expandvars(b"$foo$foo"), b"barbar")
self.assertEqual(expandvars(b"$bar$bar"), b"$bar$bar") self.assertEqual(expandvars(b"$bar$bar"), b"$bar$bar")
@unittest.skipUnless(support.FS_NONASCII, 'need support.FS_NONASCII')
def test_expandvars_nonascii(self):
if self.pathmodule.__name__ == 'macpath':
self.skipTest('macpath.expandvars is a stub')
expandvars = self.pathmodule.expandvars
def check(value, expected):
self.assertEqual(expandvars(value), expected)
with support.EnvironmentVarGuard() as env:
env.clear()
nonascii = support.FS_NONASCII
env['spam'] = nonascii
env[nonascii] = 'ham' + nonascii
check(nonascii, nonascii)
check('$spam bar', '%s bar' % nonascii)
check('${spam}bar', '%sbar' % nonascii)
check('${%s}bar' % nonascii, 'ham%sbar' % nonascii)
check('$bar%s bar' % nonascii, '$bar%s bar' % nonascii)
check('$spam}bar', '%s}bar' % nonascii)
check(os.fsencode(nonascii), os.fsencode(nonascii))
check(b'$spam bar', os.fsencode('%s bar' % nonascii))
check(b'${spam}bar', os.fsencode('%sbar' % nonascii))
check(os.fsencode('${%s}bar' % nonascii),
os.fsencode('ham%sbar' % nonascii))
check(os.fsencode('$bar%s bar' % nonascii),
os.fsencode('$bar%s bar' % nonascii))
check(b'$spam}bar', os.fsencode('%s}bar' % nonascii))
def test_abspath(self): def test_abspath(self):
self.assertIn("foo", self.pathmodule.abspath("foo")) self.assertIn("foo", self.pathmodule.abspath("foo"))
with warnings.catch_warnings(): with warnings.catch_warnings():

4
Lib/test/test_grammar.py
View file

@ -319,8 +319,8 @@ class Spam:
def f(self, *, __kw:1): def f(self, *, __kw:1):
pass pass
class Ham(Spam): pass class Ham(Spam): pass
self.assertEquals(Spam.f.__annotations__, {'_Spam__kw': 1}) self.assertEqual(Spam.f.__annotations__, {'_Spam__kw': 1})
self.assertEquals(Ham.f.__annotations__, {'_Spam__kw': 1}) self.assertEqual(Ham.f.__annotations__, {'_Spam__kw': 1})
# Check for SF Bug #1697248 - mixing decorators and a return annotation # Check for SF Bug #1697248 - mixing decorators and a return annotation
def null(x): return x def null(x): return x
@null @null

7
Lib/test/test_gzip.py
View file

@ -421,6 +421,13 @@ def test_read_with_extra(self):
with gzip.GzipFile(fileobj=io.BytesIO(gzdata)) as f: with gzip.GzipFile(fileobj=io.BytesIO(gzdata)) as f:
self.assertEqual(f.read(), b'Test') self.assertEqual(f.read(), b'Test')
def test_prepend_error(self):
# See issue #20875
with gzip.open(self.filename, "wb") as f:
f.write(data1)
with gzip.open(self.filename, "rb") as f:
f.fileobj.prepend()
class TestOpen(BaseTest): class TestOpen(BaseTest):
def test_binary_modes(self): def test_binary_modes(self):
uncompressed = data1 * 50 uncompressed = data1 * 50

1
Lib/test/test_idle.py
View file

@ -14,6 +14,7 @@
try: try:
root = tk.Tk() root = tk.Tk()
root.destroy() root.destroy()
del root
except tk.TclError: except tk.TclError:
while 'gui' in use_resources: while 'gui' in use_resources:
use_resources.remove('gui') use_resources.remove('gui')

1
Lib/test/test_importlib/source/test_file_loader.py
View file

@ -190,6 +190,7 @@ def test_file_from_empty_string_dir(self):
if os.path.exists(pycache): if os.path.exists(pycache):
shutil.rmtree(pycache) shutil.rmtree(pycache)
@source_util.writes_bytecode_files
def test_timestamp_overflow(self): def test_timestamp_overflow(self):
# When a modification timestamp is larger than 2**32, it should be # When a modification timestamp is larger than 2**32, it should be
# truncated rather than raise an OverflowError. # truncated rather than raise an OverflowError.

38
Lib/test/test_io.py
View file

@ -855,6 +855,16 @@ def test_constructor(self):
bufio.__init__(rawio) bufio.__init__(rawio)
self.assertEqual(b"abc", bufio.read()) self.assertEqual(b"abc", bufio.read())
def test_uninitialized(self):
bufio = self.tp.__new__(self.tp)
del bufio
bufio = self.tp.__new__(self.tp)
self.assertRaisesRegex((ValueError, AttributeError),
'uninitialized|has no attribute',
bufio.read, 0)
bufio.__init__(self.MockRawIO())
self.assertEqual(bufio.read(0), b'')
def test_read(self): def test_read(self):
for arg in (None, 7): for arg in (None, 7):
rawio = self.MockRawIO((b"abc", b"d", b"efg")) rawio = self.MockRawIO((b"abc", b"d", b"efg"))
@ -1106,6 +1116,16 @@ def test_constructor(self):
bufio.flush() bufio.flush()
self.assertEqual(b"".join(rawio._write_stack), b"abcghi") self.assertEqual(b"".join(rawio._write_stack), b"abcghi")
def test_uninitialized(self):
bufio = self.tp.__new__(self.tp)
del bufio
bufio = self.tp.__new__(self.tp)
self.assertRaisesRegex((ValueError, AttributeError),
'uninitialized|has no attribute',
bufio.write, b'')
bufio.__init__(self.MockRawIO())
self.assertEqual(bufio.write(b''), 0)
def test_detach_flush(self): def test_detach_flush(self):
raw = self.MockRawIO() raw = self.MockRawIO()
buf = self.tp(raw) buf = self.tp(raw)
@ -1390,6 +1410,20 @@ def test_constructor(self):
pair = self.tp(self.MockRawIO(), self.MockRawIO()) pair = self.tp(self.MockRawIO(), self.MockRawIO())
self.assertFalse(pair.closed) self.assertFalse(pair.closed)
def test_uninitialized(self):
pair = self.tp.__new__(self.tp)
del pair
pair = self.tp.__new__(self.tp)
self.assertRaisesRegex((ValueError, AttributeError),
'uninitialized|has no attribute',
pair.read, 0)
self.assertRaisesRegex((ValueError, AttributeError),
'uninitialized|has no attribute',
pair.write, b'')
pair.__init__(self.MockRawIO(), self.MockRawIO())
self.assertEqual(pair.read(0), b'')
self.assertEqual(pair.write(b''), 0)
def test_detach(self): def test_detach(self):
pair = self.tp(self.MockRawIO(), self.MockRawIO()) pair = self.tp(self.MockRawIO(), self.MockRawIO())
self.assertRaises(self.UnsupportedOperation, pair.detach) self.assertRaises(self.UnsupportedOperation, pair.detach)
@ -1516,6 +1550,10 @@ def test_constructor(self):
BufferedReaderTest.test_constructor(self) BufferedReaderTest.test_constructor(self)
BufferedWriterTest.test_constructor(self) BufferedWriterTest.test_constructor(self)
def test_uninitialized(self):
BufferedReaderTest.test_uninitialized(self)
BufferedWriterTest.test_uninitialized(self)
def test_read_and_write(self): def test_read_and_write(self):
raw = self.MockRawIO((b"asdf", b"ghjk")) raw = self.MockRawIO((b"asdf", b"ghjk"))
rw = self.tp(raw, 8) rw = self.tp(raw, 8)

20
Lib/test/test_modulefinder.py
View file

@ -1,5 +1,7 @@
import os import os
import errno import errno
import importlib.machinery
import py_compile
import shutil import shutil
import unittest import unittest
import tempfile import tempfile
@ -208,6 +210,14 @@ def foo(): pass
from . import * from . import *
"""] """]
bytecode_test = [
"a",
["a"],
[],
[],
""
]
def open_file(path): def open_file(path):
dirname = os.path.dirname(path) dirname = os.path.dirname(path)
@ -288,6 +298,16 @@ def test_relative_imports_3(self):
def test_relative_imports_4(self): def test_relative_imports_4(self):
self._do_test(relative_import_test_4) self._do_test(relative_import_test_4)
def test_bytecode(self):
base_path = os.path.join(TEST_DIR, 'a')
source_path = base_path + importlib.machinery.SOURCE_SUFFIXES[0]
bytecode_path = base_path + importlib.machinery.BYTECODE_SUFFIXES[0]
with open_file(source_path) as file:
file.write('testing_modulefinder = True\n')
py_compile.compile(source_path, cfile=bytecode_path)
os.remove(source_path)
self._do_test(bytecode_test)
def test_main(): def test_main():
support.run_unittest(ModuleFinderTest) support.run_unittest(ModuleFinderTest)

27
Lib/test/test_ntpath.py
View file

@ -22,13 +22,15 @@ def tester(fn, wantResult):
fn = fn.replace('["', '[b"') fn = fn.replace('["', '[b"')
fn = fn.replace(", '", ", b'") fn = fn.replace(", '", ", b'")
fn = fn.replace(', "', ', b"') fn = fn.replace(', "', ', b"')
fn = os.fsencode(fn).decode('latin1')
fn = fn.encode('ascii', 'backslashreplace').decode('ascii')
with warnings.catch_warnings(): with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning) warnings.simplefilter("ignore", DeprecationWarning)
gotResult = eval(fn) gotResult = eval(fn)
if isinstance(wantResult, str): if isinstance(wantResult, str):
wantResult = wantResult.encode('ascii') wantResult = os.fsencode(wantResult)
elif isinstance(wantResult, tuple): elif isinstance(wantResult, tuple):
wantResult = tuple(r.encode('ascii') for r in wantResult) wantResult = tuple(os.fsencode(r) for r in wantResult)
gotResult = eval(fn) gotResult = eval(fn)
if wantResult != gotResult: if wantResult != gotResult:
@ -223,7 +225,6 @@ def test_expandvars(self):
tester('ntpath.expandvars("$[foo]bar")', "$[foo]bar") tester('ntpath.expandvars("$[foo]bar")', "$[foo]bar")
tester('ntpath.expandvars("$bar bar")', "$bar bar") tester('ntpath.expandvars("$bar bar")', "$bar bar")
tester('ntpath.expandvars("$?bar")', "$?bar") tester('ntpath.expandvars("$?bar")', "$?bar")
tester('ntpath.expandvars("${foo}bar")', "barbar")
tester('ntpath.expandvars("$foo}bar")', "bar}bar") tester('ntpath.expandvars("$foo}bar")', "bar}bar")
tester('ntpath.expandvars("${foo")', "${foo") tester('ntpath.expandvars("${foo")', "${foo")
tester('ntpath.expandvars("${{foo}}")', "baz1}") tester('ntpath.expandvars("${{foo}}")', "baz1}")
@ -237,6 +238,26 @@ def test_expandvars(self):
tester('ntpath.expandvars("%foo%%bar")', "bar%bar") tester('ntpath.expandvars("%foo%%bar")', "bar%bar")
tester('ntpath.expandvars("\'%foo%\'%bar")', "\'%foo%\'%bar") tester('ntpath.expandvars("\'%foo%\'%bar")', "\'%foo%\'%bar")
@unittest.skipUnless(support.FS_NONASCII, 'need support.FS_NONASCII')
def test_expandvars_nonascii(self):
def check(value, expected):
tester('ntpath.expandvars(%r)' % value, expected)
with support.EnvironmentVarGuard() as env:
env.clear()
nonascii = support.FS_NONASCII
env['spam'] = nonascii
env[nonascii] = 'ham' + nonascii
check('$spam bar', '%s bar' % nonascii)
check('$%s bar' % nonascii, '$%s bar' % nonascii)
check('${spam}bar', '%sbar' % nonascii)
check('${%s}bar' % nonascii, 'ham%sbar' % nonascii)
check('$spam}bar', '%s}bar' % nonascii)
check('$%s}bar' % nonascii, '$%s}bar' % nonascii)
check('%spam% bar', '%s bar' % nonascii)
check('%{}% bar'.format(nonascii), 'ham%s bar' % nonascii)
check('%spam%bar', '%sbar' % nonascii)
check('%{}%bar'.format(nonascii), 'ham%sbar' % nonascii)
def test_abspath(self): def test_abspath(self):
# ntpath.abspath() can only be used on a system with the "nt" module # ntpath.abspath() can only be used on a system with the "nt" module
# (reasonably), so we protect this test with "import nt". This allows # (reasonably), so we protect this test with "import nt". This allows

5
Lib/test/test_pkgutil.py
View file

@ -368,6 +368,11 @@ def test_iter_importers_avoids_emulation(self):
def test_main(): def test_main():
run_unittest(PkgutilTests, PkgutilPEP302Tests, ExtendPathTests, run_unittest(PkgutilTests, PkgutilPEP302Tests, ExtendPathTests,
NestedNamespacePackageTest, ImportlibMigrationTests) NestedNamespacePackageTest, ImportlibMigrationTests)
# this is necessary if test is run repeated (like when finding leaks)
import zipimport
import importlib
zipimport._zip_directory_cache.clear()
importlib.invalidate_caches()
if __name__ == '__main__': if __name__ == '__main__':

2
Lib/test/test_posix.py
View file

@ -1161,7 +1161,7 @@ def tearDown(self):
def test_initgroups(self): def test_initgroups(self):
# find missing group # find missing group
g = max(self.saved_groups) + 1 g = max(self.saved_groups or [0]) + 1
name = pwd.getpwuid(posix.getuid()).pw_name name = pwd.getpwuid(posix.getuid()).pw_name
posix.initgroups(name, g) posix.initgroups(name, g)
self.assertIn(g, posix.getgroups()) self.assertIn(g, posix.getgroups())

10
Lib/test/test_pydoc.py
View file

@ -387,6 +387,16 @@ def test_text_doc(self):
print_diffs(expected_text, result) print_diffs(expected_text, result)
self.fail("outputs are not equal, see diff above") self.fail("outputs are not equal, see diff above")
def test_text_enum_member_with_value_zero(self):
# Test issue #20654 to ensure enum member with value 0 can be
# displayed. It used to throw KeyError: 'zero'.
import enum
class BinaryInteger(enum.IntEnum):
zero = 0
one = 1
doc = pydoc.render_doc(BinaryInteger)
self.assertIn('<BinaryInteger.zero: 0>', doc)
def test_issue8225(self): def test_issue8225(self):
# Test issue8225 to ensure no doc link appears for xml.etree # Test issue8225 to ensure no doc link appears for xml.etree
result, doc_loc = get_pydoc_text(xml.etree) result, doc_loc = get_pydoc_text(xml.etree)

24
Lib/test/test_range.py
View file

@ -380,6 +380,30 @@ def test_iterator_pickling(self):
it = pickle.loads(d) it = pickle.loads(d)
self.assertEqual(list(it), data[1:]) self.assertEqual(list(it), data[1:])
def test_exhausted_iterator_pickling(self):
r = range(2**65, 2**65+2)
i = iter(r)
while True:
r = next(i)
if r == 2**65+1:
break
d = pickle.dumps(i)
i2 = pickle.loads(d)
self.assertEqual(list(i), [])
self.assertEqual(list(i2), [])
def test_large_exhausted_iterator_pickling(self):
r = range(20)
i = iter(r)
while True:
r = next(i)
if r == 19:
break
d = pickle.dumps(i)
i2 = pickle.loads(d)
self.assertEqual(list(i), [])
self.assertEqual(list(i2), [])
def test_odd_bug(self): def test_odd_bug(self):
# This used to raise a "SystemError: NULL result without error" # This used to raise a "SystemError: NULL result without error"
# because the range validation step was eating the exception # because the range validation step was eating the exception

18
Lib/test/test_re.py
View file

@ -1205,6 +1205,24 @@ def test_debug_flag(self):
self.assertEqual(out.getvalue().splitlines(), self.assertEqual(out.getvalue().splitlines(),
['literal 102 ', 'literal 111 ', 'literal 111 ']) ['literal 102 ', 'literal 111 ', 'literal 111 '])
def test_keyword_parameters(self):
# Issue #20283: Accepting the string keyword parameter.
pat = re.compile(r'(ab)')
self.assertEqual(
pat.match(string='abracadabra', pos=7, endpos=10).span(), (7, 9))
self.assertEqual(
pat.fullmatch(string='abracadabra', pos=7, endpos=9).span(), (7, 9))
self.assertEqual(
pat.search(string='abracadabra', pos=3, endpos=10).span(), (7, 9))
self.assertEqual(
pat.findall(string='abracadabra', pos=3, endpos=10), ['ab'])
self.assertEqual(
pat.split(string='abracadabra', maxsplit=1),
['', 'ab', 'racadabra'])
self.assertEqual(
pat.scanner(string='abracadabra', pos=3, endpos=10).search().span(),
(7, 9))
class PatternReprTests(unittest.TestCase): class PatternReprTests(unittest.TestCase):
def check(self, pattern, expected): def check(self, pattern, expected):

1
Lib/test/test_robotparser.py
View file

@ -275,6 +275,7 @@ def testPasswordProtectedSite(self):
self.skipTest('%s is unavailable' % url) self.skipTest('%s is unavailable' % url)
self.assertEqual(parser.can_fetch("*", robots_url), False) self.assertEqual(parser.can_fetch("*", robots_url), False)
@unittest.skip('does not handle the gzip encoding delivered by pydotorg')
def testPythonOrg(self): def testPythonOrg(self):
support.requires('network') support.requires('network')
with support.transient_internet('www.python.org'): with support.transient_internet('www.python.org'):

9
Lib/test/test_shutil.py
View file

@ -1492,6 +1492,15 @@ def test_move_dir_to_dir_other_fs(self):
# Move a dir inside an existing dir on another filesystem. # Move a dir inside an existing dir on another filesystem.
self.test_move_dir_to_dir() self.test_move_dir_to_dir()
def test_move_dir_sep_to_dir(self):
self._check_move_dir(self.src_dir + os.path.sep, self.dst_dir,
os.path.join(self.dst_dir, os.path.basename(self.src_dir)))
@unittest.skipUnless(os.path.altsep, 'requires os.path.altsep')
def test_move_dir_altsep_to_dir(self):
self._check_move_dir(self.src_dir + os.path.altsep, self.dst_dir,
os.path.join(self.dst_dir, os.path.basename(self.src_dir)))
def test_existing_file_inside_dest_dir(self): def test_existing_file_inside_dest_dir(self):
# A file with the same name inside the destination dir already exists. # A file with the same name inside the destination dir already exists.
with open(self.dst_file, "wb"): with open(self.dst_file, "wb"):

10
Lib/test/test_socket.py
View file

@ -1234,9 +1234,15 @@ def testGetaddrinfo(self):
# Issue #6697. # Issue #6697.
self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800') self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800')
# Issue 17269 # Issue 17269: test workaround for OS X platform bug segfault
if hasattr(socket, 'AI_NUMERICSERV'): if hasattr(socket, 'AI_NUMERICSERV'):
socket.getaddrinfo("localhost", None, 0, 0, 0, socket.AI_NUMERICSERV) try:
# The arguments here are undefined and the call may succeed
# or fail. All we care here is that it doesn't segfault.
socket.getaddrinfo("localhost", None, 0, 0, 0,
socket.AI_NUMERICSERV)
except socket.gaierror:
pass
def test_getnameinfo(self): def test_getnameinfo(self):
# only IP addresses are allowed # only IP addresses are allowed

10
Lib/test/test_source_encoding.py
View file

@ -5,6 +5,7 @@
import importlib import importlib
import os import os
import sys import sys
import subprocess
class SourceEncodingTest(unittest.TestCase): class SourceEncodingTest(unittest.TestCase):
@ -58,6 +59,15 @@ def test_issue7820(self):
# two bytes in common with the UTF-8 BOM # two bytes in common with the UTF-8 BOM
self.assertRaises(SyntaxError, eval, b'\xef\xbb\x20') self.assertRaises(SyntaxError, eval, b'\xef\xbb\x20')
def test_20731(self):
sub = subprocess.Popen([sys.executable,
os.path.join(os.path.dirname(__file__),
'coding20731.py')],
stderr=subprocess.PIPE)
err = sub.communicate()[1]
self.assertEqual(sub.returncode, 0)
self.assertNotIn(b'SyntaxError', err)
def test_error_message(self): def test_error_message(self):
compile(b'# -*- coding: iso-8859-15 -*-\n', 'dummy', 'exec') compile(b'# -*- coding: iso-8859-15 -*-\n', 'dummy', 'exec')
compile(b'\xef\xbb\xbf\n', 'dummy', 'exec') compile(b'\xef\xbb\xbf\n', 'dummy', 'exec')

2
Lib/test/test_support.py
View file

@ -102,7 +102,7 @@ def test_temp_dir(self):
self.assertTrue(os.path.isdir(path)) self.assertTrue(os.path.isdir(path))
self.assertFalse(os.path.isdir(path)) self.assertFalse(os.path.isdir(path))
finally: finally:
shutil.rmtree(parent_dir) support.rmtree(parent_dir)
def test_temp_dir__path_none(self): def test_temp_dir__path_none(self):
"""Test passing no path.""" """Test passing no path."""

85
Lib/test/test_sys.py
View file

@ -1,4 +1,5 @@
import unittest, test.support import unittest, test.support
from test.script_helper import assert_python_ok, assert_python_failure
import sys, io, os import sys, io, os
import struct import struct
import subprocess import subprocess
@ -89,74 +90,54 @@ def test_excepthook(self):
# Python/pythonrun.c::PyErr_PrintEx() is tricky. # Python/pythonrun.c::PyErr_PrintEx() is tricky.
def test_exit(self): def test_exit(self):
# call with two arguments
self.assertRaises(TypeError, sys.exit, 42, 42) self.assertRaises(TypeError, sys.exit, 42, 42)
# call without argument # call without argument
try: with self.assertRaises(SystemExit) as cm:
sys.exit(0) sys.exit()
except SystemExit as exc: self.assertIsNone(cm.exception.code)
self.assertEqual(exc.code, 0)
except: rc, out, err = assert_python_ok('-c', 'import sys; sys.exit()')
self.fail("wrong exception") self.assertEqual(rc, 0)
else: self.assertEqual(out, b'')
self.fail("no exception") self.assertEqual(err, b'')
# call with integer argument
with self.assertRaises(SystemExit) as cm:
sys.exit(42)
self.assertEqual(cm.exception.code, 42)
# call with tuple argument with one entry # call with tuple argument with one entry
# entry will be unpacked # entry will be unpacked
try: with self.assertRaises(SystemExit) as cm:
sys.exit(42)
except SystemExit as exc:
self.assertEqual(exc.code, 42)
except:
self.fail("wrong exception")
else:
self.fail("no exception")
# call with integer argument
try:
sys.exit((42,)) sys.exit((42,))
except SystemExit as exc: self.assertEqual(cm.exception.code, 42)
self.assertEqual(exc.code, 42)
except:
self.fail("wrong exception")
else:
self.fail("no exception")
# call with string argument # call with string argument
try: with self.assertRaises(SystemExit) as cm:
sys.exit("exit") sys.exit("exit")
except SystemExit as exc: self.assertEqual(cm.exception.code, "exit")
self.assertEqual(exc.code, "exit")
except:
self.fail("wrong exception")
else:
self.fail("no exception")
# call with tuple argument with two entries # call with tuple argument with two entries
try: with self.assertRaises(SystemExit) as cm:
sys.exit((17, 23)) sys.exit((17, 23))
except SystemExit as exc: self.assertEqual(cm.exception.code, (17, 23))
self.assertEqual(exc.code, (17, 23))
except:
self.fail("wrong exception")
else:
self.fail("no exception")
# test that the exit machinery handles SystemExits properly # test that the exit machinery handles SystemExits properly
rc = subprocess.call([sys.executable, "-c", rc, out, err = assert_python_failure('-c', 'raise SystemExit(47)')
"raise SystemExit(47)"])
self.assertEqual(rc, 47) self.assertEqual(rc, 47)
self.assertEqual(out, b'')
self.assertEqual(err, b'')
def check_exit_message(code, expected, env=None): def check_exit_message(code, expected, **env_vars):
process = subprocess.Popen([sys.executable, "-c", code], rc, out, err = assert_python_failure('-c', code, **env_vars)
stderr=subprocess.PIPE, env=env) self.assertEqual(rc, 1)
stdout, stderr = process.communicate() self.assertEqual(out, b'')
self.assertEqual(process.returncode, 1) self.assertTrue(err.startswith(expected),
self.assertTrue(stderr.startswith(expected), "%s doesn't start with %s" % (ascii(err), ascii(expected)))
"%s doesn't start with %s" % (ascii(stderr), ascii(expected)))
# test that stderr buffer if flushed before the exit message is written # test that stderr buffer is flushed before the exit message is written
# into stderr # into stderr
check_exit_message( check_exit_message(
r'import sys; sys.stderr.write("unflushed,"); sys.exit("message")', r'import sys; sys.stderr.write("unflushed,"); sys.exit("message")',
@ -170,11 +151,9 @@ def check_exit_message(code, expected, env=None):
# test that the unicode message is encoded to the stderr encoding # test that the unicode message is encoded to the stderr encoding
# instead of the default encoding (utf8) # instead of the default encoding (utf8)
env = os.environ.copy()
env['PYTHONIOENCODING'] = 'latin-1'
check_exit_message( check_exit_message(
r'import sys; sys.exit("h\xe9")', r'import sys; sys.exit("h\xe9")',
b"h\xe9", env=env) b"h\xe9", PYTHONIOENCODING='latin-1')
def test_getdefaultencoding(self): def test_getdefaultencoding(self):
self.assertRaises(TypeError, sys.getdefaultencoding, 42) self.assertRaises(TypeError, sys.getdefaultencoding, 42)

18
Lib/test/test_tarfile.py
View file

@ -240,14 +240,16 @@ def test_list(self):
self.assertIn(b'ustar/dirtype/', out) self.assertIn(b'ustar/dirtype/', out)
self.assertIn(b'ustar/dirtype-with-size/', out) self.assertIn(b'ustar/dirtype-with-size/', out)
# Make sure it is able to print unencodable characters # Make sure it is able to print unencodable characters
self.assertIn(br'ustar/umlauts-' def conv(b):
br'\udcc4\udcd6\udcdc\udce4\udcf6\udcfc\udcdf', out) s = b.decode(self.tar.encoding, 'surrogateescape')
self.assertIn(br'misc/regtype-hpux-signed-chksum-' return s.encode('ascii', 'backslashreplace')
br'\udcc4\udcd6\udcdc\udce4\udcf6\udcfc\udcdf', out) self.assertIn(conv(b'ustar/umlauts-\xc4\xd6\xdc\xe4\xf6\xfc\xdf'), out)
self.assertIn(br'misc/regtype-old-v7-signed-chksum-' self.assertIn(conv(b'misc/regtype-hpux-signed-chksum-'
br'\udcc4\udcd6\udcdc\udce4\udcf6\udcfc\udcdf', out) b'\xc4\xd6\xdc\xe4\xf6\xfc\xdf'), out)
self.assertIn(br'pax/bad-pax-\udce4\udcf6\udcfc', out) self.assertIn(conv(b'misc/regtype-old-v7-signed-chksum-'
self.assertIn(br'pax/hdrcharset-\udce4\udcf6\udcfc', out) b'\xc4\xd6\xdc\xe4\xf6\xfc\xdf'), out)
self.assertIn(conv(b'pax/bad-pax-\xe4\xf6\xfc'), out)
self.assertIn(conv(b'pax/hdrcharset-\xe4\xf6\xfc'), out)
# Make sure it prints files separated by one newline without any # Make sure it prints files separated by one newline without any
# 'ls -l'-like accessories if verbose flag is not being used # 'ls -l'-like accessories if verbose flag is not being used
# ... # ...

1
Lib/test/test_tcl.py
View file

@ -376,6 +376,7 @@ def testfunc(arg):
result = arg result = arg
return arg return arg
self.interp.createcommand('testfunc', testfunc) self.interp.createcommand('testfunc', testfunc)
self.addCleanup(self.interp.tk.deletecommand, 'testfunc')
def check(value, expected, eq=self.assertEqual): def check(value, expected, eq=self.assertEqual):
r = self.interp.call('testfunc', value) r = self.interp.call('testfunc', value)
self.assertIsInstance(result, str) self.assertIsInstance(result, str)

6
Lib/test/test_threadsignals.py
View file

@ -74,6 +74,9 @@ def alarm_interrupt(self, sig, frame):
@unittest.skipIf(USING_PTHREAD_COND, @unittest.skipIf(USING_PTHREAD_COND,
'POSIX condition variables cannot be interrupted') 'POSIX condition variables cannot be interrupted')
# Issue #20564: sem_timedwait() cannot be interrupted on OpenBSD
@unittest.skipIf(sys.platform.startswith('openbsd'),
'lock cannot be interrupted on OpenBSD')
def test_lock_acquire_interruption(self): def test_lock_acquire_interruption(self):
# Mimic receiving a SIGINT (KeyboardInterrupt) with SIGALRM while stuck # Mimic receiving a SIGINT (KeyboardInterrupt) with SIGALRM while stuck
# in a deadlock. # in a deadlock.
@ -97,6 +100,9 @@ def test_lock_acquire_interruption(self):
@unittest.skipIf(USING_PTHREAD_COND, @unittest.skipIf(USING_PTHREAD_COND,
'POSIX condition variables cannot be interrupted') 'POSIX condition variables cannot be interrupted')
# Issue #20564: sem_timedwait() cannot be interrupted on OpenBSD
@unittest.skipIf(sys.platform.startswith('openbsd'),
'lock cannot be interrupted on OpenBSD')
def test_rlock_acquire_interruption(self): def test_rlock_acquire_interruption(self):
# Mimic receiving a SIGINT (KeyboardInterrupt) with SIGALRM while stuck # Mimic receiving a SIGINT (KeyboardInterrupt) with SIGALRM while stuck
# in a deadlock. # in a deadlock.

139
Lib/test/test_time.py
View file

@ -14,6 +14,8 @@
SIZEOF_INT = sysconfig.get_config_var('SIZEOF_INT') or 4 SIZEOF_INT = sysconfig.get_config_var('SIZEOF_INT') or 4
TIME_MAXYEAR = (1 << 8 * SIZEOF_INT - 1) - 1 TIME_MAXYEAR = (1 << 8 * SIZEOF_INT - 1) - 1
TIME_MINYEAR = -TIME_MAXYEAR - 1 TIME_MINYEAR = -TIME_MAXYEAR - 1
_PyTime_ROUND_DOWN = 0
_PyTime_ROUND_UP = 1
class TimeTestCase(unittest.TestCase): class TimeTestCase(unittest.TestCase):
@ -226,7 +228,7 @@ def test_ctime(self):
self.assertEqual(time.ctime(t), 'Sun Sep 16 01:03:52 1973') self.assertEqual(time.ctime(t), 'Sun Sep 16 01:03:52 1973')
t = time.mktime((2000, 1, 1, 0, 0, 0, 0, 0, -1)) t = time.mktime((2000, 1, 1, 0, 0, 0, 0, 0, -1))
self.assertEqual(time.ctime(t), 'Sat Jan 1 00:00:00 2000') self.assertEqual(time.ctime(t), 'Sat Jan 1 00:00:00 2000')
for year in [-100, 100, 1000, 2000, 10000]: for year in [-100, 100, 1000, 2000, 2050, 10000]:
try: try:
testval = time.mktime((year, 1, 10) + (0,)*6) testval = time.mktime((year, 1, 10) + (0,)*6)
except (ValueError, OverflowError): except (ValueError, OverflowError):
@ -344,6 +346,13 @@ def test_localtime_without_arg(self):
def test_mktime(self): def test_mktime(self):
# Issue #1726687 # Issue #1726687
for t in (-2, -1, 0, 1): for t in (-2, -1, 0, 1):
if sys.platform.startswith('aix') and t == -1:
# Issue #11188, #19748: mktime() returns -1 on error. On Linux,
# the tm_wday field is used as a sentinel () to detect if -1 is
# really an error or a valid timestamp. On AIX, tm_wday is
# unchanged even on success and so cannot be used as a
# sentinel.
continue
try: try:
tt = time.localtime(t) tt = time.localtime(t)
except (OverflowError, OSError): except (OverflowError, OSError):
@ -585,58 +594,116 @@ def setUp(self):
@support.cpython_only @support.cpython_only
def test_time_t(self): def test_time_t(self):
from _testcapi import pytime_object_to_time_t from _testcapi import pytime_object_to_time_t
for obj, time_t in ( for obj, time_t, rnd in (
(0, 0), # Round towards zero
(-1, -1), (0, 0, _PyTime_ROUND_DOWN),
(-1.0, -1), (-1, -1, _PyTime_ROUND_DOWN),
(-1.9, -1), (-1.0, -1, _PyTime_ROUND_DOWN),
(1.0, 1), (-1.9, -1, _PyTime_ROUND_DOWN),
(1.9, 1), (1.0, 1, _PyTime_ROUND_DOWN),
(1.9, 1, _PyTime_ROUND_DOWN),
# Round away from zero
(0, 0, _PyTime_ROUND_UP),
(-1, -1, _PyTime_ROUND_UP),
(-1.0, -1, _PyTime_ROUND_UP),
(-1.9, -2, _PyTime_ROUND_UP),
(1.0, 1, _PyTime_ROUND_UP),
(1.9, 2, _PyTime_ROUND_UP),
): ):
self.assertEqual(pytime_object_to_time_t(obj), time_t) self.assertEqual(pytime_object_to_time_t(obj, rnd), time_t)
rnd = _PyTime_ROUND_DOWN
for invalid in self.invalid_values: for invalid in self.invalid_values:
self.assertRaises(OverflowError, pytime_object_to_time_t, invalid) self.assertRaises(OverflowError,
pytime_object_to_time_t, invalid, rnd)
@support.cpython_only @support.cpython_only
def test_timeval(self): def test_timeval(self):
from _testcapi import pytime_object_to_timeval from _testcapi import pytime_object_to_timeval
for obj, timeval in ( for obj, timeval, rnd in (
(0, (0, 0)), # Round towards zero
(-1, (-1, 0)), (0, (0, 0), _PyTime_ROUND_DOWN),
(-1.0, (-1, 0)), (-1, (-1, 0), _PyTime_ROUND_DOWN),
(1e-6, (0, 1)), (-1.0, (-1, 0), _PyTime_ROUND_DOWN),
(-1e-6, (-1, 999999)), (1e-6, (0, 1), _PyTime_ROUND_DOWN),
(-1.2, (-2, 800000)), (1e-7, (0, 0), _PyTime_ROUND_DOWN),
(1.1234560, (1, 123456)), (-1e-6, (-1, 999999), _PyTime_ROUND_DOWN),
(1.1234569, (1, 123456)), (-1e-7, (-1, 999999), _PyTime_ROUND_DOWN),
(-1.1234560, (-2, 876544)), (-1.2, (-2, 800000), _PyTime_ROUND_DOWN),
(-1.1234561, (-2, 876543)), (0.9999999, (0, 999999), _PyTime_ROUND_DOWN),
(0.0000041, (0, 4), _PyTime_ROUND_DOWN),
(1.1234560, (1, 123456), _PyTime_ROUND_DOWN),
(1.1234569, (1, 123456), _PyTime_ROUND_DOWN),
(-0.0000040, (-1, 999996), _PyTime_ROUND_DOWN),
(-0.0000041, (-1, 999995), _PyTime_ROUND_DOWN),
(-1.1234560, (-2, 876544), _PyTime_ROUND_DOWN),
(-1.1234561, (-2, 876543), _PyTime_ROUND_DOWN),
# Round away from zero
(0, (0, 0), _PyTime_ROUND_UP),
(-1, (-1, 0), _PyTime_ROUND_UP),
(-1.0, (-1, 0), _PyTime_ROUND_UP),
(1e-6, (0, 1), _PyTime_ROUND_UP),
(1e-7, (0, 1), _PyTime_ROUND_UP),
(-1e-6, (-1, 999999), _PyTime_ROUND_UP),
(-1e-7, (-1, 999999), _PyTime_ROUND_UP),
(-1.2, (-2, 800000), _PyTime_ROUND_UP),
(0.9999999, (1, 0), _PyTime_ROUND_UP),
(0.0000041, (0, 5), _PyTime_ROUND_UP),
(1.1234560, (1, 123457), _PyTime_ROUND_UP),
(1.1234569, (1, 123457), _PyTime_ROUND_UP),
(-0.0000040, (-1, 999996), _PyTime_ROUND_UP),
(-0.0000041, (-1, 999995), _PyTime_ROUND_UP),
(-1.1234560, (-2, 876544), _PyTime_ROUND_UP),
(-1.1234561, (-2, 876543), _PyTime_ROUND_UP),
): ):
self.assertEqual(pytime_object_to_timeval(obj), timeval) with self.subTest(obj=obj, round=rnd, timeval=timeval):
self.assertEqual(pytime_object_to_timeval(obj, rnd), timeval)
rnd = _PyTime_ROUND_DOWN
for invalid in self.invalid_values: for invalid in self.invalid_values:
self.assertRaises(OverflowError, pytime_object_to_timeval, invalid) self.assertRaises(OverflowError,
pytime_object_to_timeval, invalid, rnd)
@support.cpython_only @support.cpython_only
def test_timespec(self): def test_timespec(self):
from _testcapi import pytime_object_to_timespec from _testcapi import pytime_object_to_timespec
for obj, timespec in ( for obj, timespec, rnd in (
(0, (0, 0)), # Round towards zero
(-1, (-1, 0)), (0, (0, 0), _PyTime_ROUND_DOWN),
(-1.0, (-1, 0)), (-1, (-1, 0), _PyTime_ROUND_DOWN),
(1e-9, (0, 1)), (-1.0, (-1, 0), _PyTime_ROUND_DOWN),
(-1e-9, (-1, 999999999)), (1e-9, (0, 1), _PyTime_ROUND_DOWN),
(-1.2, (-2, 800000000)), (1e-10, (0, 0), _PyTime_ROUND_DOWN),
(1.1234567890, (1, 123456789)), (-1e-9, (-1, 999999999), _PyTime_ROUND_DOWN),
(1.1234567899, (1, 123456789)), (-1e-10, (-1, 999999999), _PyTime_ROUND_DOWN),
(-1.1234567890, (-2, 876543211)), (-1.2, (-2, 800000000), _PyTime_ROUND_DOWN),
(-1.1234567891, (-2, 876543210)), (0.9999999999, (0, 999999999), _PyTime_ROUND_DOWN),
(1.1234567890, (1, 123456789), _PyTime_ROUND_DOWN),
(1.1234567899, (1, 123456789), _PyTime_ROUND_DOWN),
(-1.1234567890, (-2, 876543211), _PyTime_ROUND_DOWN),
(-1.1234567891, (-2, 876543210), _PyTime_ROUND_DOWN),
# Round away from zero
(0, (0, 0), _PyTime_ROUND_UP),
(-1, (-1, 0), _PyTime_ROUND_UP),
(-1.0, (-1, 0), _PyTime_ROUND_UP),
(1e-9, (0, 1), _PyTime_ROUND_UP),
(1e-10, (0, 1), _PyTime_ROUND_UP),
(-1e-9, (-1, 999999999), _PyTime_ROUND_UP),
(-1e-10, (-1, 999999999), _PyTime_ROUND_UP),
(-1.2, (-2, 800000000), _PyTime_ROUND_UP),
(0.9999999999, (1, 0), _PyTime_ROUND_UP),
(1.1234567890, (1, 123456790), _PyTime_ROUND_UP),
(1.1234567899, (1, 123456790), _PyTime_ROUND_UP),
(-1.1234567890, (-2, 876543211), _PyTime_ROUND_UP),
(-1.1234567891, (-2, 876543210), _PyTime_ROUND_UP),
): ):
self.assertEqual(pytime_object_to_timespec(obj), timespec) with self.subTest(obj=obj, round=rnd, timespec=timespec):
self.assertEqual(pytime_object_to_timespec(obj, rnd), timespec)
rnd = _PyTime_ROUND_DOWN
for invalid in self.invalid_values: for invalid in self.invalid_values:
self.assertRaises(OverflowError, pytime_object_to_timespec, invalid) self.assertRaises(OverflowError,
pytime_object_to_timespec, invalid, rnd)
@unittest.skipUnless(time._STRUCT_TM_ITEMS == 11, "needs tm_zone support") @unittest.skipUnless(time._STRUCT_TM_ITEMS == 11, "needs tm_zone support")
def test_localtime_timezone(self): def test_localtime_timezone(self):

98
Lib/test/test_tokenize.py
View file

@ -2,7 +2,7 @@
Tests for the tokenize module. Tests for the tokenize module.
The tests can be really simple. Given a small fragment of source The tests can be really simple. Given a small fragment of source
code, print out a table with tokens. The ENDMARK is omitted for code, print out a table with tokens. The ENDMARKER is omitted for
brevity. brevity.
>>> dump_tokens("1 + 1") >>> dump_tokens("1 + 1")
@ -578,9 +578,15 @@
>>> tempdir = os.path.dirname(f) or os.curdir >>> tempdir = os.path.dirname(f) or os.curdir
>>> testfiles = glob.glob(os.path.join(tempdir, "test*.py")) >>> testfiles = glob.glob(os.path.join(tempdir, "test*.py"))
tokenize is broken on test_pep3131.py because regular expressions are broken on Tokenize is broken on test_pep3131.py because regular expressions are
the obscure unicode identifiers in it. *sigh* broken on the obscure unicode identifiers in it. *sigh*
With roundtrip extended to test the 5-tuple mode of untokenize,
7 more testfiles fail. Remove them also until the failure is diagnosed.
>>> testfiles.remove(os.path.join(tempdir, "test_pep3131.py")) >>> testfiles.remove(os.path.join(tempdir, "test_pep3131.py"))
>>> for f in ('buffer', 'builtin', 'fileio', 'inspect', 'os', 'platform', 'sys'):
... testfiles.remove(os.path.join(tempdir, "test_%s.py") % f)
...
>>> if not support.is_resource_enabled("cpu"): >>> if not support.is_resource_enabled("cpu"):
... testfiles = random.sample(testfiles, 10) ... testfiles = random.sample(testfiles, 10)
... ...
@ -638,7 +644,7 @@
from test import support from test import support
from tokenize import (tokenize, _tokenize, untokenize, NUMBER, NAME, OP, from tokenize import (tokenize, _tokenize, untokenize, NUMBER, NAME, OP,
STRING, ENDMARKER, ENCODING, tok_name, detect_encoding, STRING, ENDMARKER, ENCODING, tok_name, detect_encoding,
open as tokenize_open) open as tokenize_open, Untokenizer)
from io import BytesIO from io import BytesIO
from unittest import TestCase from unittest import TestCase
import os, sys, glob import os, sys, glob
@ -659,21 +665,39 @@ def dump_tokens(s):
def roundtrip(f): def roundtrip(f):
""" """
Test roundtrip for `untokenize`. `f` is an open file or a string. Test roundtrip for `untokenize`. `f` is an open file or a string.
The source code in f is tokenized, converted back to source code via The source code in f is tokenized to both 5- and 2-tuples.
tokenize.untokenize(), and tokenized again from the latter. The test Both sequences are converted back to source code via
fails if the second tokenization doesn't match the first. tokenize.untokenize(), and the latter tokenized again to 2-tuples.
The test fails if the 3 pair tokenizations do not match.
When untokenize bugs are fixed, untokenize with 5-tuples should
reproduce code that does not contain a backslash continuation
following spaces. A proper test should test this.
This function would be more useful for correcting bugs if it reported
the first point of failure, like assertEqual, rather than just
returning False -- or if it were only used in unittests and not
doctest and actually used assertEqual.
""" """
# Get source code and original tokenizations
if isinstance(f, str): if isinstance(f, str):
f = BytesIO(f.encode('utf-8')) code = f.encode('utf-8')
try: else:
token_list = list(tokenize(f.readline)) code = f.read()
finally:
f.close() f.close()
tokens1 = [tok[:2] for tok in token_list] readline = iter(code.splitlines(keepends=True)).__next__
new_bytes = untokenize(tokens1) tokens5 = list(tokenize(readline))
readline = (line for line in new_bytes.splitlines(keepends=True)).__next__ tokens2 = [tok[:2] for tok in tokens5]
tokens2 = [tok[:2] for tok in tokenize(readline)] # Reproduce tokens2 from pairs
return tokens1 == tokens2 bytes_from2 = untokenize(tokens2)
readline2 = iter(bytes_from2.splitlines(keepends=True)).__next__
tokens2_from2 = [tok[:2] for tok in tokenize(readline2)]
# Reproduce tokens2 from 5-tuples
bytes_from5 = untokenize(tokens5)
readline5 = iter(bytes_from5.splitlines(keepends=True)).__next__
tokens2_from5 = [tok[:2] for tok in tokenize(readline5)]
# Compare 3 versions
return tokens2 == tokens2_from2 == tokens2_from5
# This is an example from the docs, set up as a doctest. # This is an example from the docs, set up as a doctest.
def decistmt(s): def decistmt(s):
@ -1153,6 +1177,47 @@ def test_pathological_trailing_whitespace(self):
# See http://bugs.python.org/issue16152 # See http://bugs.python.org/issue16152
self.assertExactTypeEqual('@ ', token.AT) self.assertExactTypeEqual('@ ', token.AT)
class UntokenizeTest(TestCase):
def test_bad_input_order(self):
# raise if previous row
u = Untokenizer()
u.prev_row = 2
u.prev_col = 2
with self.assertRaises(ValueError) as cm:
u.add_whitespace((1,3))
self.assertEqual(cm.exception.args[0],
'start (1,3) precedes previous end (2,2)')
# raise if previous column in row
self.assertRaises(ValueError, u.add_whitespace, (2,1))
def test_backslash_continuation(self):
# The problem is that <whitespace>\<newline> leaves no token
u = Untokenizer()
u.prev_row = 1
u.prev_col = 1
u.tokens = []
u.add_whitespace((2, 0))
self.assertEqual(u.tokens, ['\\\n'])
u.prev_row = 2
u.add_whitespace((4, 4))
self.assertEqual(u.tokens, ['\\\n', '\\\n\\\n', ' '])
self.assertTrue(roundtrip('a\n b\n c\n \\\n c\n'))
def test_iter_compat(self):
u = Untokenizer()
token = (NAME, 'Hello')
tokens = [(ENCODING, 'utf-8'), token]
u.compat(token, iter([]))
self.assertEqual(u.tokens, ["Hello "])
u = Untokenizer()
self.assertEqual(u.untokenize(iter([token])), 'Hello ')
u = Untokenizer()
self.assertEqual(u.untokenize(iter(tokens)), 'Hello ')
self.assertEqual(u.encoding, 'utf-8')
self.assertEqual(untokenize(iter(tokens)), b'Hello ')
__test__ = {"doctests" : doctests, 'decistmt': decistmt} __test__ = {"doctests" : doctests, 'decistmt': decistmt}
def test_main(): def test_main():
@ -1162,6 +1227,7 @@ def test_main():
support.run_unittest(Test_Tokenize) support.run_unittest(Test_Tokenize)
support.run_unittest(TestDetectEncoding) support.run_unittest(TestDetectEncoding)
support.run_unittest(TestTokenize) support.run_unittest(TestTokenize)
support.run_unittest(UntokenizeTest)
if __name__ == "__main__": if __name__ == "__main__":
test_main() test_main()

2
Lib/test/test_tracemalloc.py
View file

@ -346,6 +346,8 @@ def test_filter_traces(self):
self.assertIsNot(snapshot5.traces, snapshot.traces) self.assertIsNot(snapshot5.traces, snapshot.traces)
self.assertEqual(snapshot5.traces, snapshot.traces) self.assertEqual(snapshot5.traces, snapshot.traces)
self.assertRaises(TypeError, snapshot.filter_traces, filter1)
def test_snapshot_group_by_line(self): def test_snapshot_group_by_line(self):
snapshot, snapshot2 = create_snapshots() snapshot, snapshot2 = create_snapshots()
tb_0 = traceback_lineno('<unknown>', 0) tb_0 = traceback_lineno('<unknown>', 0)

26
Lib/test/test_types.py
View file

@ -1,6 +1,6 @@
# Python test set -- part 6, built-in types # Python test set -- part 6, built-in types
from test.support import run_unittest, run_with_locale from test.support import run_unittest, run_with_locale, cpython_only
import collections import collections
import pickle import pickle
import locale import locale
@ -1170,9 +1170,31 @@ def test_pickle(self):
self.assertEqual(ns, ns_roundtrip, pname) self.assertEqual(ns, ns_roundtrip, pname)
class SharedKeyTests(unittest.TestCase):
@cpython_only
def test_subclasses(self):
# Verify that subclasses can share keys (per PEP 412)
class A:
pass
class B(A):
pass
a, b = A(), B()
self.assertEqual(sys.getsizeof(vars(a)), sys.getsizeof(vars(b)))
self.assertLess(sys.getsizeof(vars(a)), sys.getsizeof({}))
a.x, a.y, a.z, a.w = range(4)
self.assertNotEqual(sys.getsizeof(vars(a)), sys.getsizeof(vars(b)))
a2 = A()
self.assertEqual(sys.getsizeof(vars(a)), sys.getsizeof(vars(a2)))
self.assertLess(sys.getsizeof(vars(a)), sys.getsizeof({}))
b.u, b.v, b.w, b.t = range(4)
self.assertLess(sys.getsizeof(vars(b)), sys.getsizeof({}))
def test_main(): def test_main():
run_unittest(TypesTests, MappingProxyTests, ClassCreationTests, run_unittest(TypesTests, MappingProxyTests, ClassCreationTests,
SimpleNamespaceTests) SimpleNamespaceTests, SharedKeyTests)
if __name__ == '__main__': if __name__ == '__main__':
test_main() test_main()

3
Lib/test/test_urllib2.py
View file

@ -1227,7 +1227,8 @@ def test_osx_proxy_bypass(self):
self.assertTrue(_proxy_bypass_macosx_sysconf(host, bypass), self.assertTrue(_proxy_bypass_macosx_sysconf(host, bypass),
'expected bypass of %s to be True' % host) 'expected bypass of %s to be True' % host)
# Check hosts that should not trigger the proxy bypass # Check hosts that should not trigger the proxy bypass
for host in ('abc.foo.bar', 'bar.com', '127.0.0.2', '10.11.0.1', 'test'): for host in ('abc.foo.bar', 'bar.com', '127.0.0.2', '10.11.0.1',
'notinbypass'):
self.assertFalse(_proxy_bypass_macosx_sysconf(host, bypass), self.assertFalse(_proxy_bypass_macosx_sysconf(host, bypass),
'expected bypass of %s to be False' % host) 'expected bypass of %s to be False' % host)

29
Lib/tkinter/__init__.py
View file

@ -1339,6 +1339,21 @@ def grid_bbox(self, column=None, row=None, col2=None, row2=None):
args = args + (col2, row2) args = args + (col2, row2)
return self._getints(self.tk.call(*args)) or None return self._getints(self.tk.call(*args)) or None
bbox = grid_bbox bbox = grid_bbox
def _gridconvvalue(self, value):
if isinstance(value, (str, _tkinter.Tcl_Obj)):
try:
svalue = str(value)
if not svalue:
return None
elif '.' in svalue:
return getdouble(svalue)
else:
return getint(svalue)
except ValueError:
pass
return value
def _grid_configure(self, command, index, cnf, kw): def _grid_configure(self, command, index, cnf, kw):
"""Internal function.""" """Internal function."""
if isinstance(cnf, str) and not kw: if isinstance(cnf, str) and not kw:
@ -1357,22 +1372,14 @@ def _grid_configure(self, command, index, cnf, kw):
for i in range(0, len(words), 2): for i in range(0, len(words), 2):
key = words[i][1:] key = words[i][1:]
value = words[i+1] value = words[i+1]
if not value: dict[key] = self._gridconvvalue(value)
value = None
elif '.' in str(value):
value = getdouble(value)
else:
value = getint(value)
dict[key] = value
return dict return dict
res = self.tk.call( res = self.tk.call(
('grid', command, self._w, index) ('grid', command, self._w, index)
+ options) + options)
if len(options) == 1: if len(options) == 1:
if not res: return None return self._gridconvvalue(res)
# In Tk 7.5, -width can be a float
if '.' in res: return getdouble(res)
return getint(res)
def grid_columnconfigure(self, index, cnf={}, **kw): def grid_columnconfigure(self, index, cnf={}, **kw):
"""Configure column INDEX of a grid. """Configure column INDEX of a grid.

34
Lib/tokenize.py
View file

@ -25,12 +25,14 @@
'Skip Montanaro, Raymond Hettinger, Trent Nelson, ' 'Skip Montanaro, Raymond Hettinger, Trent Nelson, '
'Michael Foord') 'Michael Foord')
import builtins import builtins
import re
import sys
from token import *
from codecs import lookup, BOM_UTF8 from codecs import lookup, BOM_UTF8
import collections import collections
from io import TextIOWrapper from io import TextIOWrapper
from itertools import chain
import re
import sys
from token import *
cookie_re = re.compile(r'^[ \t\f]*#.*coding[:=][ \t]*([-\w.]+)', re.ASCII) cookie_re = re.compile(r'^[ \t\f]*#.*coding[:=][ \t]*([-\w.]+)', re.ASCII)
blank_re = re.compile(br'^[ \t\f]*(?:[#\r\n]|$)', re.ASCII) blank_re = re.compile(br'^[ \t\f]*(?:[#\r\n]|$)', re.ASCII)
@ -229,20 +231,29 @@ def __init__(self):
def add_whitespace(self, start): def add_whitespace(self, start):
row, col = start row, col = start
assert row <= self.prev_row if row < self.prev_row or row == self.prev_row and col < self.prev_col:
raise ValueError("start ({},{}) precedes previous end ({},{})"
.format(row, col, self.prev_row, self.prev_col))
row_offset = row - self.prev_row
if row_offset:
self.tokens.append("\\\n" * row_offset)
self.prev_col = 0
col_offset = col - self.prev_col col_offset = col - self.prev_col
if col_offset: if col_offset:
self.tokens.append(" " * col_offset) self.tokens.append(" " * col_offset)
def untokenize(self, iterable): def untokenize(self, iterable):
for t in iterable: it = iter(iterable)
for t in it:
if len(t) == 2: if len(t) == 2:
self.compat(t, iterable) self.compat(t, it)
break break
tok_type, token, start, end, line = t tok_type, token, start, end, line = t
if tok_type == ENCODING: if tok_type == ENCODING:
self.encoding = token self.encoding = token
continue continue
if tok_type == ENDMARKER:
break
self.add_whitespace(start) self.add_whitespace(start)
self.tokens.append(token) self.tokens.append(token)
self.prev_row, self.prev_col = end self.prev_row, self.prev_col = end
@ -252,17 +263,12 @@ def untokenize(self, iterable):
return "".join(self.tokens) return "".join(self.tokens)
def compat(self, token, iterable): def compat(self, token, iterable):
startline = False
indents = [] indents = []
toks_append = self.tokens.append toks_append = self.tokens.append
toknum, tokval = token startline = token[0] in (NEWLINE, NL)
if toknum in (NAME, NUMBER):
tokval += ' '
if toknum in (NEWLINE, NL):
startline = True
prevstring = False prevstring = False
for tok in iterable:
for tok in chain([token], iterable):
toknum, tokval = tok[:2] toknum, tokval = tok[:2]
if toknum == ENCODING: if toknum == ENCODING:
self.encoding = tokval self.encoding = tokval

Some files were not shown because too many files have changed in this diff Show more