Merged revisions 55817-55961 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/branches/p3yk
................
r55837 | guido.van.rossum | 2007-06-08 16:04:42 -0700 (Fri, 08 Jun 2007) | 2 lines
PEP 3119 -- the abc module.
................
r55838 | guido.van.rossum | 2007-06-08 17:38:55 -0700 (Fri, 08 Jun 2007) | 2 lines
Implement part of PEP 3119 -- One Trick Ponies.
................
r55847 | guido.van.rossum | 2007-06-09 08:28:06 -0700 (Sat, 09 Jun 2007) | 2 lines
Different way to do one trick ponies, allowing registration (per PEP strawman).
................
r55849 | guido.van.rossum | 2007-06-09 18:06:38 -0700 (Sat, 09 Jun 2007) | 3 lines
Make sure that the magic looking for __hash__ (etc.) doesn't apply to
real subclasses of Hashable.
................
r55852 | guido.van.rossum | 2007-06-10 08:29:51 -0700 (Sun, 10 Jun 2007) | 2 lines
Add some more examples, e.g. generators and dict views.
................
r55853 | guido.van.rossum | 2007-06-10 08:31:59 -0700 (Sun, 10 Jun 2007) | 2 lines
keys() and items() *are* containers -- just values() isn't.
................
r55864 | georg.brandl | 2007-06-10 15:29:40 -0700 (Sun, 10 Jun 2007) | 2 lines
PEP 3127: new octal literals, binary literals.
................
r55865 | georg.brandl | 2007-06-10 15:31:37 -0700 (Sun, 10 Jun 2007) | 2 lines
Some octal literal fixes in Tools.
................
r55866 | georg.brandl | 2007-06-10 15:37:43 -0700 (Sun, 10 Jun 2007) | 2 lines
Tokenizer changes for PEP 3127.
................
r55867 | georg.brandl | 2007-06-10 15:37:55 -0700 (Sun, 10 Jun 2007) | 2 lines
Some docs for PEP 3127.
................
r55868 | georg.brandl | 2007-06-10 15:44:39 -0700 (Sun, 10 Jun 2007) | 2 lines
Missed a place in intobject.c. Is that used anymore anyway?
................
r55871 | neal.norwitz | 2007-06-10 18:31:49 -0700 (Sun, 10 Jun 2007) | 182 lines
Merged revisions 55729-55868 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r55731 | neal.norwitz | 2007-06-01 00:29:12 -0700 (Fri, 01 Jun 2007) | 7 lines
SF 1668596/1720897: distutils now copies data files
even if package_dir is empty.
This needs to be backported. I'm too tired tonight. It would be great
if someone backports this if the buildbots are ok with it. Otherwise,
I will try to get to it tomorrow.
........
r55732 | georg.brandl | 2007-06-01 04:33:33 -0700 (Fri, 01 Jun 2007) | 2 lines
Bug #1722484: remove docstrings again when running with -OO.
........
r55735 | georg.brandl | 2007-06-01 12:20:27 -0700 (Fri, 01 Jun 2007) | 2 lines
Fix wrong issue number.
........
r55739 | brett.cannon | 2007-06-01 20:02:29 -0700 (Fri, 01 Jun 2007) | 3 lines
Have configure raise an error when building on AtheOS. Code specific to AtheOS
will be removed in Python 2.7.
........
r55746 | neal.norwitz | 2007-06-02 11:33:53 -0700 (Sat, 02 Jun 2007) | 1 line
Update expected birthday of 2.6
........
r55751 | neal.norwitz | 2007-06-03 13:32:50 -0700 (Sun, 03 Jun 2007) | 10 lines
Backout the original 'fix' to 1721309 which had no effect.
Different versions of Berkeley DB handle this differently.
The comments and bug report should have the details. Memory is allocated
in 4.4 (and presumably earlier), but not in 4.5. Thus
4.5 has the free error, but not earlier versions.
Mostly update comments, plus make the free conditional.
This fix was already applied to the 2.5 branch.
........
r55752 | brett.cannon | 2007-06-03 16:13:41 -0700 (Sun, 03 Jun 2007) | 6 lines
Make _strptime.TimeRE().pattern() use ``\s+`` for matching whitespace instead
of ``\s*``. This prevents patterns from "stealing" bits from other patterns in
order to make a match work.
Closes bug #1730389. Will be backported.
........
r55766 | hyeshik.chang | 2007-06-05 11:16:52 -0700 (Tue, 05 Jun 2007) | 4 lines
Fix build on FreeBSD. Bluetooth HCI API in FreeBSD is quite different
from Linux's. Just fix the build for now but the code doesn't
support the complete capability of HCI on FreeBSD yet.
........
r55770 | hyeshik.chang | 2007-06-05 11:58:51 -0700 (Tue, 05 Jun 2007) | 4 lines
Bug #1728403: Fix a bug that CJKCodecs StreamReader hangs when it
reads a file that ends with incomplete sequence and sizehint argument
for .read() is specified.
........
r55775 | hyeshik.chang | 2007-06-05 12:28:15 -0700 (Tue, 05 Jun 2007) | 2 lines
Fix for Windows: close a temporary file before trying to delete it.
........
r55783 | guido.van.rossum | 2007-06-05 14:24:47 -0700 (Tue, 05 Jun 2007) | 2 lines
Patch by Tim Delany (missing DECREF). SF #1731330.
........
r55785 | collin.winter | 2007-06-05 17:17:35 -0700 (Tue, 05 Jun 2007) | 3 lines
Patch #1731049: make threading.py use a proper "raise" when checking internal state, rather than assert statements (which get stripped out by -O).
........
r55786 | facundo.batista | 2007-06-06 08:13:37 -0700 (Wed, 06 Jun 2007) | 4 lines
FTP.ntransfercmd method now uses create_connection when passive,
using the timeout received in connection time.
........
r55792 | facundo.batista | 2007-06-06 10:15:23 -0700 (Wed, 06 Jun 2007) | 7 lines
Added an optional timeout parameter to function urllib2.urlopen,
with tests in test_urllib2net.py (must have network resource
enabled to execute them). Also modified test_urllib2.py because
testing mock classes must take it into acount. Docs are also
updated.
........
r55793 | thomas.heller | 2007-06-06 13:19:19 -0700 (Wed, 06 Jun 2007) | 1 line
Build _ctypes and _ctypes_test in the ReleaseAMD64 configuration.
........
r55802 | georg.brandl | 2007-06-07 06:23:24 -0700 (Thu, 07 Jun 2007) | 3 lines
Disallow function calls like foo(None=1).
Backport from py3k rev. 55708 by Guido.
........
r55804 | georg.brandl | 2007-06-07 06:30:24 -0700 (Thu, 07 Jun 2007) | 2 lines
Make reindent.py executable.
........
r55805 | georg.brandl | 2007-06-07 06:34:10 -0700 (Thu, 07 Jun 2007) | 2 lines
Patch #1667860: Fix UnboundLocalError in urllib2.
........
r55821 | kristjan.jonsson | 2007-06-07 16:53:49 -0700 (Thu, 07 Jun 2007) | 1 line
Fixing changes to getbuildinfo.c that broke linux builds
........
r55828 | thomas.heller | 2007-06-08 09:10:27 -0700 (Fri, 08 Jun 2007) | 1 line
Make this test work with older Python releases where struct has no 't' format character.
........
r55829 | martin.v.loewis | 2007-06-08 10:29:20 -0700 (Fri, 08 Jun 2007) | 3 lines
Bug #1733488: Fix compilation of bufferobject.c on AIX.
Will backport to 2.5.
........
r55831 | thomas.heller | 2007-06-08 11:20:09 -0700 (Fri, 08 Jun 2007) | 2 lines
[ 1715718 ] x64 clean compile patch for _ctypes, by Kristj?n Valur
with small modifications.
........
r55832 | thomas.heller | 2007-06-08 12:01:06 -0700 (Fri, 08 Jun 2007) | 1 line
Fix gcc warnings intruduced by passing Py_ssize_t to PyErr_Format calls.
........
r55833 | thomas.heller | 2007-06-08 12:08:31 -0700 (Fri, 08 Jun 2007) | 2 lines
Fix wrong documentation, and correct the punktuation.
Closes [1700455].
........
r55834 | thomas.heller | 2007-06-08 12:14:23 -0700 (Fri, 08 Jun 2007) | 1 line
Fix warnings by using proper function prototype.
........
r55839 | neal.norwitz | 2007-06-08 20:36:34 -0700 (Fri, 08 Jun 2007) | 7 lines
Prevent expandtabs() on string and unicode objects from causing a segfault when
a large width is passed on 32-bit platforms. Found by Google.
It would be good for people to review this especially carefully and verify
I don't have an off by one error and there is no other way to cause overflow.
........
r55841 | neal.norwitz | 2007-06-08 21:48:22 -0700 (Fri, 08 Jun 2007) | 1 line
Use macro version of GET_SIZE to avoid Coverity warning (#150) about a possible error.
........
r55842 | martin.v.loewis | 2007-06-09 00:42:52 -0700 (Sat, 09 Jun 2007) | 3 lines
Patch #1733960: Allow T_LONGLONG to accept ints.
Will backport to 2.5.
........
r55843 | martin.v.loewis | 2007-06-09 00:58:05 -0700 (Sat, 09 Jun 2007) | 2 lines
Fix Windows build.
........
r55845 | martin.v.loewis | 2007-06-09 03:10:26 -0700 (Sat, 09 Jun 2007) | 2 lines
Provide LLONG_MAX for S390.
........
r55854 | thomas.heller | 2007-06-10 08:59:17 -0700 (Sun, 10 Jun 2007) | 4 lines
First version of build scripts for Windows/AMD64 (no external
components are built yet, and 'kill_python' is disabled).
........
r55855 | thomas.heller | 2007-06-10 10:55:51 -0700 (Sun, 10 Jun 2007) | 3 lines
For now, disable the _bsddb, _sqlite3, _ssl, _testcapi, _tkinter
modules in the ReleaseAMD64 configuration because they do not compile.
........
r55856 | thomas.heller | 2007-06-10 11:27:54 -0700 (Sun, 10 Jun 2007) | 1 line
Need to set the environment variables, otherwise devenv.com is not found.
........
r55860 | thomas.heller | 2007-06-10 14:01:17 -0700 (Sun, 10 Jun 2007) | 1 line
Revert commit 55855.
........
................
r55880 | neal.norwitz | 2007-06-10 22:07:36 -0700 (Sun, 10 Jun 2007) | 5 lines
Fix the refleak counter on test_collections. The ABC metaclass creates
a registry which must be cleared on each run. Otherwise, there *seem*
to be refleaks when there really aren't any. (The class is held within
the registry even though it's no longer needed.)
................
r55884 | neal.norwitz | 2007-06-10 22:46:33 -0700 (Sun, 10 Jun 2007) | 1 line
These tests have been removed, so they are no longer needed here
................
r55886 | georg.brandl | 2007-06-11 00:26:37 -0700 (Mon, 11 Jun 2007) | 3 lines
Optimize access to True and False in the compiler (if True)
and the peepholer (LOAD_NAME True).
................
r55905 | georg.brandl | 2007-06-11 10:02:26 -0700 (Mon, 11 Jun 2007) | 5 lines
Remove __oct__ and __hex__ and use __index__ for converting
non-ints before formatting in a base.
Add a bin() builtin.
................
r55906 | georg.brandl | 2007-06-11 10:04:44 -0700 (Mon, 11 Jun 2007) | 2 lines
int(x, 0) does not "guess".
................
r55907 | georg.brandl | 2007-06-11 10:05:47 -0700 (Mon, 11 Jun 2007) | 2 lines
Add a comment to explain that nb_oct and nb_hex are nonfunctional.
................
r55908 | guido.van.rossum | 2007-06-11 10:49:18 -0700 (Mon, 11 Jun 2007) | 2 lines
Get rid of unused imports and comment.
................
r55910 | guido.van.rossum | 2007-06-11 13:05:17 -0700 (Mon, 11 Jun 2007) | 2 lines
_Abstract.__new__ now requires either no arguments or __init__ overridden.
................
r55911 | guido.van.rossum | 2007-06-11 13:07:49 -0700 (Mon, 11 Jun 2007) | 7 lines
Move the collections ABCs to a separate file, _abcoll.py, in order to avoid
needing to import _collections.so during the bootstrap (this will become
apparent in the next submit of os.py).
Add (plain and mutable) ABCs for Set, Mapping, Sequence.
................
r55912 | guido.van.rossum | 2007-06-11 13:09:31 -0700 (Mon, 11 Jun 2007) | 2 lines
Rewrite the _Environ class to use the new collections ABCs.
................
r55913 | guido.van.rossum | 2007-06-11 13:59:45 -0700 (Mon, 11 Jun 2007) | 72 lines
Merged revisions 55869-55912 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r55869 | neal.norwitz | 2007-06-10 17:42:11 -0700 (Sun, 10 Jun 2007) | 1 line
Add Atul Varma for patch # 1667860
........
r55870 | neal.norwitz | 2007-06-10 18:22:03 -0700 (Sun, 10 Jun 2007) | 1 line
Ignore valgrind problems on Ubuntu from ld
........
r55872 | neal.norwitz | 2007-06-10 18:48:46 -0700 (Sun, 10 Jun 2007) | 2 lines
Ignore config.status.lineno which seems new (new autoconf?)
........
r55873 | neal.norwitz | 2007-06-10 19:14:39 -0700 (Sun, 10 Jun 2007) | 1 line
Prevent these tests from running on Win64 since they don\'t apply there either
........
r55874 | neal.norwitz | 2007-06-10 19:16:10 -0700 (Sun, 10 Jun 2007) | 5 lines
Fix a bug when there was a newline in the string expandtabs was called on.
This also catches another condition that can overflow.
Will backport.
........
r55879 | neal.norwitz | 2007-06-10 21:52:37 -0700 (Sun, 10 Jun 2007) | 1 line
Prevent hang if the port cannot be opened.
........
r55881 | neal.norwitz | 2007-06-10 22:28:45 -0700 (Sun, 10 Jun 2007) | 4 lines
Add all of the distuils modules that don't seem to have explicit tests. :-(
Move an import in mworkscompiler so that this module can be imported on
any platform. Hopefully this works on all platforms.
........
r55882 | neal.norwitz | 2007-06-10 22:35:10 -0700 (Sun, 10 Jun 2007) | 4 lines
SF #1734732, lower case the module names per PEP 8.
Will backport.
........
r55885 | neal.norwitz | 2007-06-10 23:16:48 -0700 (Sun, 10 Jun 2007) | 4 lines
Not sure why this only fails sometimes on Unix machines. Better
to disable it and only import msvccompiler on Windows since that's
the only place it can work anyways.
........
r55887 | neal.norwitz | 2007-06-11 00:29:43 -0700 (Mon, 11 Jun 2007) | 4 lines
Bug #1734723: Fix repr.Repr() so it doesn't ignore the maxtuple attribute.
Will backport
........
r55889 | neal.norwitz | 2007-06-11 00:36:24 -0700 (Mon, 11 Jun 2007) | 1 line
Reflow long line
........
r55896 | thomas.heller | 2007-06-11 08:58:33 -0700 (Mon, 11 Jun 2007) | 3 lines
Use "O&" in calls to PyArg_Parse when we need a 'void*' instead of "k"
or "K" codes.
........
r55901 | facundo.batista | 2007-06-11 09:27:08 -0700 (Mon, 11 Jun 2007) | 5 lines
Added versionchanged flag to all the methods which received
a new optional timeout parameter, and a versionadded flag to
the socket.create_connection function.
........
................
r55914 | guido.van.rossum | 2007-06-11 14:19:50 -0700 (Mon, 11 Jun 2007) | 3 lines
New super() implementation, for PEP 3135 (though the PEP is not yet updated
to this design, and small tweaks may still be made later).
................
r55923 | guido.van.rossum | 2007-06-11 21:15:24 -0700 (Mon, 11 Jun 2007) | 4 lines
I'm guessing this module broke when Neal ripped out the types module --
it used 'list' both as a local variable and as the built-in list type.
Renamed the local variable since that was easier.
................
r55924 | guido.van.rossum | 2007-06-11 21:20:05 -0700 (Mon, 11 Jun 2007) | 5 lines
Change all occurrences of super(<thisclass>, <firstarg>) to super().
Seems to have worked, all the tests still pass.
Exception: test_descr and test_descrtut, which have tons of these
and are there to test the various usages.
................
r55939 | collin.winter | 2007-06-12 13:57:33 -0700 (Tue, 12 Jun 2007) | 1 line
Patch #1735485: remove StandardError from the exception hierarchy.
................
r55954 | neal.norwitz | 2007-06-12 21:56:32 -0700 (Tue, 12 Jun 2007) | 51 lines
Merged revisions 55913-55950 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r55926 | marc-andre.lemburg | 2007-06-12 02:09:58 -0700 (Tue, 12 Jun 2007) | 3 lines
Apply patch #1734945 to support TurboLinux as distribution.
........
r55927 | marc-andre.lemburg | 2007-06-12 02:26:49 -0700 (Tue, 12 Jun 2007) | 3 lines
Add patch #1726668: Windows Vista support.
........
r55929 | thomas.heller | 2007-06-12 08:36:22 -0700 (Tue, 12 Jun 2007) | 1 line
Checkout, but do not yet try to build, exernal sources.
........
r55930 | thomas.heller | 2007-06-12 09:08:27 -0700 (Tue, 12 Jun 2007) | 6 lines
Add bufferoverflowU.lib to the libraries needed by _ssl (is this the
right thing to do?).
Set the /XP64 /RETAIL build enviroment in the makefile when building
ReleaseAMD64.
........
r55931 | thomas.heller | 2007-06-12 09:23:19 -0700 (Tue, 12 Jun 2007) | 5 lines
Revert this change, since it breaks the win32 build:
Add bufferoverflowU.lib to the libraries needed by _ssl (is this the
right thing to do?).
........
r55934 | thomas.heller | 2007-06-12 10:28:31 -0700 (Tue, 12 Jun 2007) | 3 lines
Specify the bufferoverflowU.lib to the makefile on the command line
(for ReleaseAMD64 builds).
........
r55937 | thomas.heller | 2007-06-12 12:02:59 -0700 (Tue, 12 Jun 2007) | 3 lines
Add bufferoverflowU.lib to PCBuild\_bsddb.vcproj.
Build sqlite3.dll and bsddb.
........
r55938 | thomas.heller | 2007-06-12 12:56:12 -0700 (Tue, 12 Jun 2007) | 2 lines
Don't rebuild Berkeley DB if not needed (this was committed by accident).
........
r55948 | martin.v.loewis | 2007-06-12 20:42:19 -0700 (Tue, 12 Jun 2007) | 3 lines
Provide PY_LLONG_MAX on all systems having long long.
Will backport to 2.5.
........
................
r55959 | guido.van.rossum | 2007-06-13 09:22:41 -0700 (Wed, 13 Jun 2007) | 2 lines
Fix a compilation warning.
................
diff --git a/Lib/CGIHTTPServer.py b/Lib/CGIHTTPServer.py
index 5017eec..a2d809c 100644
--- a/Lib/CGIHTTPServer.py
+++ b/Lib/CGIHTTPServer.py
@@ -353,7 +353,7 @@
st = os.stat(path)
except os.error:
return False
- return st.st_mode & 0111 != 0
+ return st.st_mode & 0o111 != 0
def test(HandlerClass = CGIHTTPRequestHandler,
diff --git a/Lib/_abcoll.py b/Lib/_abcoll.py
new file mode 100644
index 0000000..cd1c9ce
--- /dev/null
+++ b/Lib/_abcoll.py
@@ -0,0 +1,535 @@
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Abstract Base Classes (ABCs) for collections, according to PEP 3119.
+
+DON'T USE THIS MODULE DIRECTLY! The classes here should be imported
+via collections; they are defined here only to alleviate ceratin
+bootstrapping issues. Unit tests are in test_collections.
+"""
+
+from abc import ABCMeta, abstractmethod
+
+__all__ = ["Hashable", "Iterable", "Iterator",
+ "Sized", "Container", "Callable",
+ "Set", "MutableSet",
+ "Mapping", "MutableMapping",
+ "MappingView", "KeysView", "ItemsView", "ValuesView",
+ "Sequence", "MutableSequence",
+ ]
+
+### ONE-TRICK PONIES ###
+
+class Hashable(metaclass=ABCMeta):
+
+ @abstractmethod
+ def __hash__(self):
+ return 0
+
+ @classmethod
+ def __subclasshook__(cls, C):
+ if cls is Hashable:
+ for B in C.__mro__:
+ if "__hash__" in B.__dict__:
+ if B.__dict__["__hash__"]:
+ return True
+ break
+ return NotImplemented
+
+
+class Iterable(metaclass=ABCMeta):
+
+ @abstractmethod
+ def __iter__(self):
+ while False:
+ yield None
+
+ @classmethod
+ def __subclasshook__(cls, C):
+ if cls is Iterable:
+ if any("__iter__" in B.__dict__ for B in C.__mro__):
+ return True
+ return NotImplemented
+
+Iterable.register(bytes)
+
+
+class Iterator(metaclass=ABCMeta):
+
+ @abstractmethod
+ def __next__(self):
+ raise StopIteration
+
+ def __iter__(self):
+ return self
+
+ @classmethod
+ def __subclasshook__(cls, C):
+ if cls is Iterator:
+ if any("__next__" in B.__dict__ for B in C.__mro__):
+ return True
+ return NotImplemented
+
+
+class Sized(metaclass=ABCMeta):
+
+ @abstractmethod
+ def __len__(self):
+ return 0
+
+ @classmethod
+ def __subclasshook__(cls, C):
+ if cls is Sized:
+ if any("__len__" in B.__dict__ for B in C.__mro__):
+ return True
+ return NotImplemented
+
+
+class Container(metaclass=ABCMeta):
+
+ @abstractmethod
+ def __contains__(self, x):
+ return False
+
+ @classmethod
+ def __subclasshook__(cls, C):
+ if cls is Container:
+ if any("__contains__" in B.__dict__ for B in C.__mro__):
+ return True
+ return NotImplemented
+
+
+class Callable(metaclass=ABCMeta):
+
+ @abstractmethod
+ def __contains__(self, x):
+ return False
+
+ @classmethod
+ def __subclasshook__(cls, C):
+ if cls is Callable:
+ if any("__call__" in B.__dict__ for B in C.__mro__):
+ return True
+ return NotImplemented
+
+
+### SETS ###
+
+
+class Set(metaclass=ABCMeta):
+
+ """A set is a finite, iterable container.
+
+ This class provides concrete generic implementations of all
+ methods except for __contains__, __iter__ and __len__.
+
+ To override the comparisons (presumably for speed, as the
+ semantics are fixed), all you have to do is redefine __le__ and
+ then the other operations will automatically follow suit.
+ """
+
+ @abstractmethod
+ def __contains__(self, value):
+ return False
+
+ @abstractmethod
+ def __iter__(self):
+ while False:
+ yield None
+
+ @abstractmethod
+ def __len__(self):
+ return 0
+
+ def __le__(self, other):
+ if not isinstance(other, Set):
+ return NotImplemented
+ if len(self) > len(other):
+ return False
+ for elem in self:
+ if elem not in other:
+ return False
+ return True
+
+ def __lt__(self, other):
+ if not isinstance(other, Set):
+ return NotImplemented
+ return len(self) < len(other) and self.__le__(other)
+
+ def __eq__(self, other):
+ if not isinstance(other, Set):
+ return NotImplemented
+ return len(self) == len(other) and self.__le__(other)
+
+ @classmethod
+ def _from_iterable(cls, it):
+ return frozenset(it)
+
+ def __and__(self, other):
+ if not isinstance(other, Iterable):
+ return NotImplemented
+ return self._from_iterable(value for value in other if value in self)
+
+ def __or__(self, other):
+ if not isinstance(other, Iterable):
+ return NotImplemented
+ return self._from_iterable(itertools.chain(self, other))
+
+ def __sub__(self, other):
+ if not isinstance(other, Set):
+ if not isinstance(other, Iterable):
+ return NotImplemented
+ other = self._from_iterable(other)
+ return self._from_iterable(value for value in self
+ if value not in other)
+
+ def __xor__(self, other):
+ if not isinstance(other, Set):
+ if not isinstance(other, Iterable):
+ return NotImplemented
+ other = self._from_iterable(other)
+ return (self - other) | (other - self)
+
+ def _hash(self):
+ """Compute the hash value of a set.
+
+ Note that we don't define __hash__: not all sets are hashable.
+ But if you define a hashable set type, its __hash__ should
+ call this function.
+
+ This must be compatible __eq__.
+
+ All sets ought to compare equal if they contain the same
+ elements, regardless of how they are implemented, and
+ regardless of the order of the elements; so there's not much
+ freedom for __eq__ or __hash__. We match the algorithm used
+ by the built-in frozenset type.
+ """
+ MAX = sys.maxint
+ MASK = 2 * MAX + 1
+ n = len(self)
+ h = 1927868237 * (n + 1)
+ h &= MASK
+ for x in self:
+ hx = hash(x)
+ h ^= (hx ^ (hx << 16) ^ 89869747) * 3644798167
+ h &= MASK
+ h = h * 69069 + 907133923
+ h &= MASK
+ if h > MAX:
+ h -= MASK + 1
+ if h == -1:
+ h = 590923713
+ return h
+
+Set.register(frozenset)
+
+
+class MutableSet(Set):
+
+ @abstractmethod
+ def add(self, value):
+ """Return True if it was added, False if already there."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def discard(self, value):
+ """Return True if it was deleted, False if not there."""
+ raise NotImplementedError
+
+ def pop(self):
+ """Return the popped value. Raise KeyError if empty."""
+ it = iter(self)
+ try:
+ value = it.__next__()
+ except StopIteration:
+ raise KeyError
+ self.discard(value)
+ return value
+
+ def toggle(self, value):
+ """Return True if it was added, False if deleted."""
+ # XXX This implementation is not thread-safe
+ if value in self:
+ self.discard(value)
+ return False
+ else:
+ self.add(value)
+ return True
+
+ def clear(self):
+ """This is slow (creates N new iterators!) but effective."""
+ try:
+ while True:
+ self.pop()
+ except KeyError:
+ pass
+
+ def __ior__(self, it: Iterable):
+ for value in it:
+ self.add(value)
+ return self
+
+ def __iand__(self, c: Container):
+ for value in self:
+ if value not in c:
+ self.discard(value)
+ return self
+
+ def __ixor__(self, it: Iterable):
+ # This calls toggle(), so if that is overridded, we call the override
+ for value in it:
+ self.toggle(it)
+ return self
+
+ def __isub__(self, it: Iterable):
+ for value in it:
+ self.discard(value)
+ return self
+
+MutableSet.register(set)
+
+
+### MAPPINGS ###
+
+
+class Mapping(metaclass=ABCMeta):
+
+ @abstractmethod
+ def __getitem__(self, key):
+ raise KeyError
+
+ def get(self, key, default=None):
+ try:
+ return self[key]
+ except KeyError:
+ return default
+
+ def __contains__(self, key):
+ try:
+ self[key]
+ except KeyError:
+ return False
+ else:
+ return True
+
+ @abstractmethod
+ def __len__(self):
+ return 0
+
+ @abstractmethod
+ def __iter__(self):
+ while False:
+ yield None
+
+ def keys(self):
+ return KeysView(self)
+
+ def items(self):
+ return ItemsView(self)
+
+ def values(self):
+ return ValuesView(self)
+
+
+class MappingView(metaclass=ABCMeta):
+
+ def __init__(self, mapping):
+ self._mapping = mapping
+
+ def __len__(self):
+ return len(self._mapping)
+
+
+class KeysView(MappingView, Set):
+
+ def __contains__(self, key):
+ return key in self._mapping
+
+ def __iter__(self):
+ for key in self._mapping:
+ yield key
+
+KeysView.register(type({}.keys()))
+
+
+class ItemsView(MappingView, Set):
+
+ def __contains__(self, item):
+ key, value = item
+ try:
+ v = self._mapping[key]
+ except KeyError:
+ return False
+ else:
+ return v == value
+
+ def __iter__(self):
+ for key in self._mapping:
+ yield (key, self._mapping[key])
+
+ItemsView.register(type({}.items()))
+
+
+class ValuesView(MappingView):
+
+ def __contains__(self, value):
+ for key in self._mapping:
+ if value == self._mapping[key]:
+ return True
+ return False
+
+ def __iter__(self):
+ for key in self._mapping:
+ yield self._mapping[key]
+
+ValuesView.register(type({}.values()))
+
+
+class MutableMapping(Mapping):
+
+ @abstractmethod
+ def __setitem__(self, key, value):
+ raise KeyError
+
+ @abstractmethod
+ def __delitem__(self, key):
+ raise KeyError
+
+ __marker = object()
+
+ def pop(self, key, default=__marker):
+ try:
+ value = self[key]
+ except KeyError:
+ if default is self.__marker:
+ raise
+ return default
+ else:
+ del self[key]
+ return value
+
+ def popitem(self):
+ try:
+ key = next(iter(self))
+ except StopIteration:
+ raise KeyError
+ value = self[key]
+ del self[key]
+ return key, value
+
+ def clear(self):
+ try:
+ while True:
+ self.popitem()
+ except KeyError:
+ pass
+
+ def update(self, other=(), **kwds):
+ if isinstance(other, Mapping):
+ for key in other:
+ self[key] = other[key]
+ elif hasattr(other, "keys"):
+ for key in other.keys():
+ self[key] = other[key]
+ else:
+ for key, value in other:
+ self[key] = value
+ for key, value in kwds.items():
+ self[key] = value
+
+MutableMapping.register(dict)
+
+
+### SEQUENCES ###
+
+
+class Sequence(metaclass=ABCMeta):
+
+ """All the operations on a read-only sequence.
+
+ Concrete subclasses must override __new__ or __init__,
+ __getitem__, and __len__.
+ """
+
+ @abstractmethod
+ def __getitem__(self, index):
+ raise IndexError
+
+ @abstractmethod
+ def __len__(self):
+ return 0
+
+ def __iter__(self):
+ i = 0
+ while True:
+ try:
+ v = self[i]
+ except IndexError:
+ break
+ yield v
+ i += 1
+
+ def __contains__(self, value):
+ for v in self:
+ if v == value:
+ return True
+ return False
+
+ def __reversed__(self):
+ for i in reversed(range(len(self))):
+ yield self[i]
+
+ def index(self, value):
+ for i, v in enumerate(self):
+ if v == value:
+ return i
+ raise ValueError
+
+ def count(self, value):
+ return sum(1 for v in self if v == value)
+
+Sequence.register(tuple)
+Sequence.register(basestring)
+Sequence.register(buffer)
+
+
+class MutableSequence(Sequence):
+
+ @abstractmethod
+ def __setitem__(self, index, value):
+ raise IndexError
+
+ @abstractmethod
+ def __delitem__(self, index):
+ raise IndexError
+
+ @abstractmethod
+ def insert(self, index, value):
+ raise IndexError
+
+ def append(self, value):
+ self.insert(len(self), value)
+
+ def reverse(self):
+ n = len(self)
+ for i in range(n//2):
+ self[i], self[n-i-1] = self[n-i-1], self[i]
+
+ def extend(self, values):
+ for v in values:
+ self.append(v)
+
+ def pop(self, index=-1):
+ v = self[index]
+ del self[index]
+ return v
+
+ def remove(self, value):
+ del self[self.index(value)]
+
+ def __iadd__(self, values):
+ self.extend(values)
+
+MutableSequence.register(list)
+MutableSequence.register(bytes)
diff --git a/Lib/_strptime.py b/Lib/_strptime.py
index e5d2721..28ccac7 100644
--- a/Lib/_strptime.py
+++ b/Lib/_strptime.py
@@ -107,7 +107,7 @@
# magical; just happened to have used it everywhere else where a
# static date was needed.
am_pm = []
- for hour in (01,22):
+ for hour in (1, 22):
time_tuple = time.struct_time((1999,3,17,hour,44,55,2,76,0))
am_pm.append(time.strftime("%p", time_tuple).lower())
self.am_pm = am_pm
@@ -186,7 +186,7 @@
self.locale_time = locale_time
else:
self.locale_time = LocaleTime()
- base = super(TimeRE, self)
+ base = super()
base.__init__({
# The " \d" part of the regex is to make %c from ANSI C work
'd': r"(?P<d>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])",
@@ -250,7 +250,7 @@
regex_chars = re_compile(r"([\\.^$*+?\(\){}\[\]|])")
format = regex_chars.sub(r"\\\1", format)
whitespace_replacement = re_compile('\s+')
- format = whitespace_replacement.sub('\s*', format)
+ format = whitespace_replacement.sub('\s+', format)
while '%' in format:
directive_index = format.index('%')+1
processed_format = "%s%s%s" % (processed_format,
diff --git a/Lib/anydbm.py b/Lib/anydbm.py
index 8b01ef3..8938184 100644
--- a/Lib/anydbm.py
+++ b/Lib/anydbm.py
@@ -3,7 +3,7 @@
Instead of
import dbm
- d = dbm.open(file, 'w', 0666)
+ d = dbm.open(file, 'w', 0o666)
use
@@ -63,7 +63,7 @@
error = tuple(_errors)
-def open(file, flag = 'r', mode = 0666):
+def open(file, flag = 'r', mode = 0o666):
# guess the type of an existing database
from whichdb import whichdb
result=whichdb(file)
diff --git a/Lib/bsddb/__init__.py b/Lib/bsddb/__init__.py
index 3099bb3..02df499 100644
--- a/Lib/bsddb/__init__.py
+++ b/Lib/bsddb/__init__.py
@@ -294,7 +294,7 @@
#----------------------------------------------------------------------
# Compatibility object factory functions
-def hashopen(file, flag='c', mode=0666, pgsize=None, ffactor=None, nelem=None,
+def hashopen(file, flag='c', mode=0o666, pgsize=None, ffactor=None, nelem=None,
cachesize=None, lorder=None, hflags=0):
flags = _checkflag(flag, file)
@@ -310,7 +310,7 @@
#----------------------------------------------------------------------
-def btopen(file, flag='c', mode=0666,
+def btopen(file, flag='c', mode=0o666,
btflags=0, cachesize=None, maxkeypage=None, minkeypage=None,
pgsize=None, lorder=None):
@@ -328,7 +328,7 @@
#----------------------------------------------------------------------
-def rnopen(file, flag='c', mode=0666,
+def rnopen(file, flag='c', mode=0o666,
rnflags=0, cachesize=None, pgsize=None, lorder=None,
rlen=None, delim=None, source=None, pad=None):
diff --git a/Lib/bsddb/dbshelve.py b/Lib/bsddb/dbshelve.py
index 8530c9a..8eb7ed2 100644
--- a/Lib/bsddb/dbshelve.py
+++ b/Lib/bsddb/dbshelve.py
@@ -40,7 +40,7 @@
#------------------------------------------------------------------------
-def open(filename, flags=db.DB_CREATE, mode=0660, filetype=db.DB_HASH,
+def open(filename, flags=db.DB_CREATE, mode=0o660, filetype=db.DB_HASH,
dbenv=None, dbname=None):
"""
A simple factory function for compatibility with the standard
diff --git a/Lib/bsddb/dbtables.py b/Lib/bsddb/dbtables.py
index efc6062..97ea6a7 100644
--- a/Lib/bsddb/dbtables.py
+++ b/Lib/bsddb/dbtables.py
@@ -38,7 +38,7 @@
class DBIncompleteError(Exception):
pass
-class TableDBError(StandardError):
+class TableDBError(Exception):
pass
class TableAlreadyExists(TableDBError):
pass
@@ -134,9 +134,9 @@
class bsdTableDB :
- def __init__(self, filename, dbhome, create=0, truncate=0, mode=0600,
+ def __init__(self, filename, dbhome, create=0, truncate=0, mode=0o600,
recover=0, dbflags=0):
- """bsdTableDB(filename, dbhome, create=0, truncate=0, mode=0600)
+ """bsdTableDB(filename, dbhome, create=0, truncate=0, mode=0o600)
Open database name in the dbhome BerkeleyDB directory.
Use keyword arguments when calling this constructor.
diff --git a/Lib/bsddb/test/test_1413192.py b/Lib/bsddb/test/test_1413192.py
index 436f407..0a411dd 100644
--- a/Lib/bsddb/test/test_1413192.py
+++ b/Lib/bsddb/test/test_1413192.py
@@ -18,4 +18,4 @@
the_txn = env.txn_begin()
map = db.DB(env)
-map.open('xxx.db', "p", db.DB_HASH, db.DB_CREATE, 0666, txn=the_txn)
+map.open('xxx.db', "p", db.DB_HASH, db.DB_CREATE, 0o666, txn=the_txn)
diff --git a/Lib/bsddb/test/test_basics.py b/Lib/bsddb/test/test_basics.py
index 381e2ff..13f8ded 100644
--- a/Lib/bsddb/test/test_basics.py
+++ b/Lib/bsddb/test/test_basics.py
@@ -44,7 +44,7 @@
dbtype = db.DB_UNKNOWN # must be set in derived class
dbopenflags = 0
dbsetflags = 0
- dbmode = 0660
+ dbmode = 0o660
dbname = None
useEnv = 0
envflags = 0
diff --git a/Lib/bsddb/test/test_env_close.py b/Lib/bsddb/test/test_env_close.py
index 12e1037..1a6a804 100644
--- a/Lib/bsddb/test/test_env_close.py
+++ b/Lib/bsddb/test/test_env_close.py
@@ -50,10 +50,10 @@
dbenv = db.DBEnv()
dbenv.open(self.homeDir,
db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL,
- 0666)
+ 0o666)
d = db.DB(dbenv)
- d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
+ d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0o666)
try:
dbenv.close()
@@ -75,10 +75,10 @@
dbenv = db.DBEnv()
dbenv.open(self.homeDir,
db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL,
- 0666)
+ 0o666)
d = db.DB(dbenv)
- d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666)
+ d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0o666)
try:
dbenv.close()
diff --git a/Lib/bsddb/test/test_sequence.py b/Lib/bsddb/test/test_sequence.py
index 48631a3..350d926 100644
--- a/Lib/bsddb/test/test_sequence.py
+++ b/Lib/bsddb/test/test_sequence.py
@@ -26,9 +26,9 @@
tempfile.tempdir = None
self.dbenv = db.DBEnv()
- self.dbenv.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL, 0666)
+ self.dbenv.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL, 0o666)
self.d = db.DB(self.dbenv)
- self.d.open(self.filename, db.DB_BTREE, db.DB_CREATE, 0666)
+ self.d.open(self.filename, db.DB_BTREE, db.DB_CREATE, 0o666)
def tearDown(self):
if hasattr(self, 'seq'):
diff --git a/Lib/collections.py b/Lib/collections.py
index 2cf9fe8..b2d40d6 100644
--- a/Lib/collections.py
+++ b/Lib/collections.py
@@ -4,6 +4,13 @@
from operator import itemgetter as _itemgetter
import sys as _sys
+# For bootstrapping reasons, the collection ABCs are defined in _abcoll.py.
+# They should however be considered an integral part of collections.py.
+from _abcoll import *
+import _abcoll
+__all__ += _abcoll.__all__
+
+
def NamedTuple(typename, s):
"""Returns a new subclass of tuple with named fields.
diff --git a/Lib/ctypes/__init__.py b/Lib/ctypes/__init__.py
index b753a6b..8c9fe1a 100644
--- a/Lib/ctypes/__init__.py
+++ b/Lib/ctypes/__init__.py
@@ -149,7 +149,7 @@
_type_ = "O"
def __repr__(self):
try:
- return super(py_object, self).__repr__()
+ return super().__repr__()
except ValueError:
return "%s(<NULL>)" % type(self).__name__
_check_size(py_object, "P")
diff --git a/Lib/ctypes/_endian.py b/Lib/ctypes/_endian.py
index 61ac334..138b248 100644
--- a/Lib/ctypes/_endian.py
+++ b/Lib/ctypes/_endian.py
@@ -29,7 +29,7 @@
rest = desc[2:]
fields.append((name, _other_endian(typ)) + rest)
value = fields
- super(_swapped_meta, self).__setattr__(attrname, value)
+ super().__setattr__(attrname, value)
################################################################
diff --git a/Lib/ctypes/test/test_init.py b/Lib/ctypes/test/test_init.py
index 3d9dc92..e4dfe36 100644
--- a/Lib/ctypes/test/test_init.py
+++ b/Lib/ctypes/test/test_init.py
@@ -7,7 +7,7 @@
new_was_called = False
def __new__(cls):
- result = super(X, cls).__new__(cls)
+ result = super().__new__(cls)
result.new_was_called = True
return result
diff --git a/Lib/ctypes/test/test_numbers.py b/Lib/ctypes/test/test_numbers.py
index eaabc7c..2430ac8 100644
--- a/Lib/ctypes/test/test_numbers.py
+++ b/Lib/ctypes/test/test_numbers.py
@@ -117,7 +117,10 @@
def test_sizes(self):
for t in signed_types + unsigned_types + float_types + bool_types:
- size = struct.calcsize(t._type_)
+ try:
+ size = struct.calcsize(t._type_)
+ except struct.error:
+ continue
# sizeof of the type...
self.failUnlessEqual(sizeof(t), size)
# and sizeof of an instance
diff --git a/Lib/dbhash.py b/Lib/dbhash.py
index 9f8a9c3..3c60812 100644
--- a/Lib/dbhash.py
+++ b/Lib/dbhash.py
@@ -12,5 +12,5 @@
error = bsddb.error # Exported for anydbm
-def open(file, flag = 'r', mode=0666):
+def open(file, flag = 'r', mode=0o666):
return bsddb.hashopen(file, flag, mode)
diff --git a/Lib/distutils/ccompiler.py b/Lib/distutils/ccompiler.py
index 50905c1..d4f4ade 100644
--- a/Lib/distutils/ccompiler.py
+++ b/Lib/distutils/ccompiler.py
@@ -1040,7 +1040,7 @@
def move_file (self, src, dst):
return move_file (src, dst, dry_run=self.dry_run)
- def mkpath (self, name, mode=0777):
+ def mkpath (self, name, mode=0o777):
mkpath (name, mode, self.dry_run)
diff --git a/Lib/distutils/cmd.py b/Lib/distutils/cmd.py
index 8d77e7f..b2c952c 100644
--- a/Lib/distutils/cmd.py
+++ b/Lib/distutils/cmd.py
@@ -356,7 +356,7 @@
util.execute(func, args, msg, dry_run=self.dry_run)
- def mkpath (self, name, mode=0777):
+ def mkpath (self, name, mode=0o777):
dir_util.mkpath(name, mode, dry_run=self.dry_run)
diff --git a/Lib/distutils/command/build_py.py b/Lib/distutils/command/build_py.py
index 52534bd..8f56090 100644
--- a/Lib/distutils/command/build_py.py
+++ b/Lib/distutils/command/build_py.py
@@ -114,7 +114,9 @@
build_dir = os.path.join(*([self.build_lib] + package.split('.')))
# Length of path to strip from found files
- plen = len(src_dir)+1
+ plen = 0
+ if src_dir:
+ plen = len(src_dir)+1
# Strip directory from globbed filenames
filenames = [
diff --git a/Lib/distutils/command/build_scripts.py b/Lib/distutils/command/build_scripts.py
index bda4480..511b82f 100644
--- a/Lib/distutils/command/build_scripts.py
+++ b/Lib/distutils/command/build_scripts.py
@@ -119,8 +119,8 @@
if self.dry_run:
log.info("changing mode of %s", file)
else:
- oldmode = os.stat(file)[ST_MODE] & 07777
- newmode = (oldmode | 0555) & 07777
+ oldmode = os.stat(file)[ST_MODE] & 0o7777
+ newmode = (oldmode | 0o555) & 0o7777
if newmode != oldmode:
log.info("changing mode of %s from %o to %o",
file, oldmode, newmode)
diff --git a/Lib/distutils/command/install_scripts.py b/Lib/distutils/command/install_scripts.py
index fe93ef5..da2da35 100644
--- a/Lib/distutils/command/install_scripts.py
+++ b/Lib/distutils/command/install_scripts.py
@@ -53,7 +53,7 @@
if self.dry_run:
log.info("changing mode of %s", file)
else:
- mode = ((os.stat(file)[ST_MODE]) | 0555) & 07777
+ mode = ((os.stat(file)[ST_MODE]) | 0o555) & 0o7777
log.info("changing mode of %s to %o", file, mode)
os.chmod(file, mode)
diff --git a/Lib/distutils/command/register.py b/Lib/distutils/command/register.py
index 2ddabad..53f4293 100644
--- a/Lib/distutils/command/register.py
+++ b/Lib/distutils/command/register.py
@@ -183,7 +183,7 @@
username, password))
f.close()
try:
- os.chmod(rc, 0600)
+ os.chmod(rc, 0o600)
except:
pass
elif choice == '2':
diff --git a/Lib/distutils/dir_util.py b/Lib/distutils/dir_util.py
index c6f014b..0cfca2e 100644
--- a/Lib/distutils/dir_util.py
+++ b/Lib/distutils/dir_util.py
@@ -18,7 +18,7 @@
# I don't use os.makedirs because a) it's new to Python 1.5.2, and
# b) it blows up if the directory already exists (I want to silently
# succeed in that case).
-def mkpath (name, mode=0777, verbose=0, dry_run=0):
+def mkpath (name, mode=0o777, verbose=0, dry_run=0):
"""Create a directory and any missing ancestor directories. If the
directory already exists (or if 'name' is the empty string, which
means the current directory, which of course exists), then do
@@ -85,7 +85,7 @@
# mkpath ()
-def create_tree (base_dir, files, mode=0777, verbose=0, dry_run=0):
+def create_tree (base_dir, files, mode=0o777, verbose=0, dry_run=0):
"""Create all the empty directories under 'base_dir' needed to
put 'files' there. 'base_dir' is just the a name of a directory
diff --git a/Lib/distutils/mwerkscompiler.py b/Lib/distutils/mwerkscompiler.py
index 028ea82..662046a 100644
--- a/Lib/distutils/mwerkscompiler.py
+++ b/Lib/distutils/mwerkscompiler.py
@@ -18,7 +18,6 @@
import distutils.util
import distutils.dir_util
from distutils import log
-import mkcwproject
class MWerksCompiler (CCompiler) :
"""Concrete class that implements an interface to MetroWerks CodeWarrior,
@@ -188,6 +187,7 @@
# doesn't have a clue about our working directory.
xmlfilename = os.path.join(os.getcwd(), os.path.join(build_temp, xmlname))
log.debug("\tCreate XML file %s", xmlfilename)
+ import mkcwproject
xmlbuilder = mkcwproject.cwxmlgen.ProjectBuilder(settings)
xmlbuilder.generate()
xmldata = settings['tmp_projectxmldata']
diff --git a/Lib/distutils/tests/support.py b/Lib/distutils/tests/support.py
index 475ceee..91e704c 100644
--- a/Lib/distutils/tests/support.py
+++ b/Lib/distutils/tests/support.py
@@ -9,12 +9,12 @@
class LoggingSilencer(object):
def setUp(self):
- super(LoggingSilencer, self).setUp()
+ super().setUp()
self.threshold = log.set_threshold(log.FATAL)
def tearDown(self):
log.set_threshold(self.threshold)
- super(LoggingSilencer, self).tearDown()
+ super().tearDown()
class TempdirManager(object):
@@ -24,11 +24,11 @@
"""
def setUp(self):
- super(TempdirManager, self).setUp()
+ super().setUp()
self.tempdirs = []
def tearDown(self):
- super(TempdirManager, self).tearDown()
+ super().tearDown()
while self.tempdirs:
d = self.tempdirs.pop()
shutil.rmtree(d)
diff --git a/Lib/distutils/tests/test_build_py.py b/Lib/distutils/tests/test_build_py.py
index 78e4c55..54a4ed8 100644
--- a/Lib/distutils/tests/test_build_py.py
+++ b/Lib/distutils/tests/test_build_py.py
@@ -1,10 +1,13 @@
"""Tests for distutils.command.build_py."""
import os
+import sys
+import StringIO
import unittest
from distutils.command.build_py import build_py
from distutils.core import Distribution
+from distutils.errors import DistutilsFileError
from distutils.tests import support
@@ -53,6 +56,38 @@
self.assert_("__init__.pyc" in files)
self.assert_("README.txt" in files)
+ def test_empty_package_dir (self):
+ # See SF 1668596/1720897.
+ cwd = os.getcwd()
+
+ # create the distribution files.
+ sources = self.mkdtemp()
+ open(os.path.join(sources, "__init__.py"), "w").close()
+
+ testdir = os.path.join(sources, "doc")
+ os.mkdir(testdir)
+ open(os.path.join(testdir, "testfile"), "w").close()
+
+ os.chdir(sources)
+ sys.stdout = StringIO.StringIO()
+
+ try:
+ dist = Distribution({"packages": ["pkg"],
+ "package_dir": {"pkg": ""},
+ "package_data": {"pkg": ["doc/*"]}})
+ # script_name need not exist, it just need to be initialized
+ dist.script_name = os.path.join(sources, "setup.py")
+ dist.script_args = ["build"]
+ dist.parse_command_line()
+
+ try:
+ dist.run_commands()
+ except DistutilsFileError:
+ self.fail("failed package_data test when package_dir is ''")
+ finally:
+ # Restore state.
+ os.chdir(cwd)
+ sys.stdout = sys.__stdout__
def test_suite():
return unittest.makeSuite(BuildPyTestCase)
diff --git a/Lib/dumbdbm.py b/Lib/dumbdbm.py
index eb1c613..aaa1680 100644
--- a/Lib/dumbdbm.py
+++ b/Lib/dumbdbm.py
@@ -220,7 +220,7 @@
self._os.chmod(file, self._mode)
-def open(file, flag=None, mode=0666):
+def open(file, flag=None, mode=0o666):
"""Open the database file, filename, and return corresponding object.
The flag argument, used to control how the database is opened in the
@@ -229,7 +229,7 @@
not exist.
The optional mode argument is the UNIX mode of the file, used only when
- the database has to be created. It defaults to octal code 0666 (and
+ the database has to be created. It defaults to octal code 0o666 (and
will be modified by the prevailing umask).
"""
diff --git a/Lib/ftplib.py b/Lib/ftplib.py
index cdc893b..4838c15 100644
--- a/Lib/ftplib.py
+++ b/Lib/ftplib.py
@@ -319,9 +319,7 @@
size = None
if self.passiveserver:
host, port = self.makepasv()
- af, socktype, proto, canon, sa = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM)[0]
- conn = socket.socket(af, socktype, proto)
- conn.connect(sa)
+ conn = socket.create_connection((host, port), self.timeout)
if rest is not None:
self.sendcmd("REST %s" % rest)
resp = self.sendcmd(cmd)
diff --git a/Lib/imputil.py b/Lib/imputil.py
index 6d99ec1..a0099a8 100644
--- a/Lib/imputil.py
+++ b/Lib/imputil.py
@@ -476,7 +476,7 @@
s = _os_stat(pathname)
except OSError:
return None
- return (s.st_mode & 0170000) == 0040000
+ return (s.st_mode & 0o170000) == 0o040000
def _timestamp(pathname):
"Return the file modification time as a Long."
diff --git a/Lib/mailbox.py b/Lib/mailbox.py
index a3daf01..b9f4497 100755
--- a/Lib/mailbox.py
+++ b/Lib/mailbox.py
@@ -227,10 +227,10 @@
Mailbox.__init__(self, dirname, factory, create)
if not os.path.exists(self._path):
if create:
- os.mkdir(self._path, 0700)
- os.mkdir(os.path.join(self._path, 'tmp'), 0700)
- os.mkdir(os.path.join(self._path, 'new'), 0700)
- os.mkdir(os.path.join(self._path, 'cur'), 0700)
+ os.mkdir(self._path, 0o700)
+ os.mkdir(os.path.join(self._path, 'tmp'), 0o700)
+ os.mkdir(os.path.join(self._path, 'new'), 0o700)
+ os.mkdir(os.path.join(self._path, 'cur'), 0o700)
else:
raise NoSuchMailboxError(self._path)
self._toc = {}
@@ -802,9 +802,9 @@
Mailbox.__init__(self, path, factory, create)
if not os.path.exists(self._path):
if create:
- os.mkdir(self._path, 0700)
+ os.mkdir(self._path, 0o700)
os.close(os.open(os.path.join(self._path, '.mh_sequences'),
- os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0600))
+ os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600))
else:
raise NoSuchMailboxError(self._path)
self._locked = False
diff --git a/Lib/mhlib.py b/Lib/mhlib.py
index eecb447..4b32020 100644
--- a/Lib/mhlib.py
+++ b/Lib/mhlib.py
@@ -67,7 +67,7 @@
MH_PROFILE = '~/.mh_profile'
PATH = '~/Mail'
MH_SEQUENCES = '.mh_sequences'
-FOLDER_PROTECT = 0700
+FOLDER_PROTECT = 0o700
# Imported modules
diff --git a/Lib/os.py b/Lib/os.py
index d2a305e..e47ec99 100644
--- a/Lib/os.py
+++ b/Lib/os.py
@@ -147,8 +147,8 @@
# Super directory utilities.
# (Inspired by Eric Raymond; the doc strings are mostly his)
-def makedirs(name, mode=0777):
- """makedirs(path [, mode=0777])
+def makedirs(name, mode=0o777):
+ """makedirs(path [, mode=0o777])
Super-mkdir; create a leaf directory and all intermediate ones.
Works like mkdir, except that any intermediate path segment (not
@@ -405,108 +405,63 @@
raise error, saved_exc, saved_tb
raise error, last_exc, tb
-# Change environ to automatically call putenv() if it exists
-try:
- # This will fail if there's no putenv
- putenv
-except NameError:
- pass
+
+if name == "riscos":
+ # On RISC OS, all env access goes through getenv and putenv
+ from riscosenviron import _Environ
else:
- import UserDict
+ # Change environ to automatically call putenv(), unsetenv if they exist.
+ from _abcoll import MutableMapping # Can't use collections (bootstrap)
- # Fake unsetenv() for Windows
- # not sure about os2 here but
- # I'm guessing they are the same.
+ class _Environ(MutableMapping):
+ def __init__(self, environ, keymap, putenv, unsetenv):
+ self.keymap = keymap
+ self.putenv = putenv
+ self.unsetenv = unsetenv
+ self.data = data = {}
+ for key, value in environ.items():
+ data[keymap(key)] = value
+ def __getitem__(self, key):
+ return self.data[self.keymap(key)]
+ def __setitem__(self, key, item):
+ self.putenv(key, item)
+ self.data[self.keymap(key)] = item
+ def __delitem__(self, key):
+ self.unsetenv(key)
+ del self.data[self.keymap(key)]
+ def __iter__(self):
+ for key in self.data:
+ yield key
+ def __len__(self):
+ return len(self.data)
+ def copy(self):
+ return dict(self)
+ def setdefault(self, key, value):
+ if key not in self:
+ self[key] = value
+ return self[key]
- if name in ('os2', 'nt'):
- def unsetenv(key):
- putenv(key, "")
+ try:
+ _putenv = putenv
+ except NameError:
+ _putenv = lambda key, value: None
+ else:
+ __all__.append("putenv")
- if name == "riscos":
- # On RISC OS, all env access goes through getenv and putenv
- from riscosenviron import _Environ
- elif name in ('os2', 'nt'): # Where Env Var Names Must Be UPPERCASE
- # But we store them as upper case
- class _Environ(UserDict.IterableUserDict):
- def __init__(self, environ):
- UserDict.UserDict.__init__(self)
- data = self.data
- for k, v in environ.items():
- data[k.upper()] = v
- def __setitem__(self, key, item):
- putenv(key, item)
- self.data[key.upper()] = item
- def __getitem__(self, key):
- return self.data[key.upper()]
- try:
- unsetenv
- except NameError:
- def __delitem__(self, key):
- del self.data[key.upper()]
- else:
- def __delitem__(self, key):
- unsetenv(key)
- del self.data[key.upper()]
- def __contains__(self, key):
- return key.upper() in self.data
- def get(self, key, failobj=None):
- return self.data.get(key.upper(), failobj)
- def update(self, dict=None, **kwargs):
- if dict:
- try:
- keys = dict.keys()
- except AttributeError:
- # List of (key, value)
- for k, v in dict:
- self[k] = v
- else:
- # got keys
- # cannot use items(), since mappings
- # may not have them.
- for k in keys:
- self[k] = dict[k]
- if kwargs:
- self.update(kwargs)
- def copy(self):
- return dict(self)
+ try:
+ _unsetenv = unsetenv
+ except NameError:
+ _unsetenv = lambda key: _putenv(key, "")
+ else:
+ __all__.append("unsetenv")
+ if name in ('os2', 'nt'): # Where Env Var Names Must Be UPPERCASE
+ _keymap = lambda key: key.upper()
else: # Where Env Var Names Can Be Mixed Case
- class _Environ(UserDict.IterableUserDict):
- def __init__(self, environ):
- UserDict.UserDict.__init__(self)
- self.data = environ
- def __setitem__(self, key, item):
- putenv(key, item)
- self.data[key] = item
- def update(self, dict=None, **kwargs):
- if dict:
- try:
- keys = dict.keys()
- except AttributeError:
- # List of (key, value)
- for k, v in dict:
- self[k] = v
- else:
- # got keys
- # cannot use items(), since mappings
- # may not have them.
- for k in keys:
- self[k] = dict[k]
- if kwargs:
- self.update(kwargs)
- try:
- unsetenv
- except NameError:
- pass
- else:
- def __delitem__(self, key):
- unsetenv(key)
- del self.data[key]
- def copy(self):
- return dict(self)
+ _keymap = lambda key: key
+ environ = _Environ(environ, _keymap, _putenv, _unsetenv)
- environ = _Environ(environ)
def getenv(key, default=None):
"""Get an environment variable, return None if it doesn't exist.
diff --git a/Lib/plat-atheos/IN.py b/Lib/plat-atheos/IN.py
index 4894495..9e77efc 100644
--- a/Lib/plat-atheos/IN.py
+++ b/Lib/plat-atheos/IN.py
@@ -557,7 +557,7 @@
# Included from bits/dirent.h
def _D_ALLOC_NAMLEN(d): return (_D_EXACT_NAMLEN (d) + 1)
-def IFTODT(mode): return (((mode) & 0170000) >> 12)
+def IFTODT(mode): return (((mode) & 0o170000) >> 12)
def DTTOIF(dirtype): return ((dirtype) << 12)
@@ -567,17 +567,17 @@
MAXNAMLEN = 255
# Included from posix/stat.h
-S_IFMT = 00170000
-S_IFSOCK = 0140000
-S_IFLNK = 0120000
-S_IFREG = 0100000
-S_IFBLK = 0060000
-S_IFDIR = 0040000
-S_IFCHR = 0020000
-S_IFIFO = 0010000
-S_ISUID = 0004000
-S_ISGID = 0002000
-S_ISVTX = 0001000
+S_IFMT = 0o0170000
+S_IFSOCK = 0o140000
+S_IFLNK = 0o120000
+S_IFREG = 0o100000
+S_IFBLK = 0o060000
+S_IFDIR = 0o040000
+S_IFCHR = 0o020000
+S_IFIFO = 0o010000
+S_ISUID = 0o004000
+S_ISGID = 0o002000
+S_ISVTX = 0o001000
def S_ISLNK(m): return (((m) & S_IFMT) == S_IFLNK)
def S_ISREG(m): return (((m) & S_IFMT) == S_IFREG)
@@ -592,18 +592,18 @@
def S_ISSOCK(m): return (((m) & S_IFMT) == S_IFSOCK)
-S_IRWXU = 00700
-S_IRUSR = 00400
-S_IWUSR = 00200
-S_IXUSR = 00100
-S_IRWXG = 00070
-S_IRGRP = 00040
-S_IWGRP = 00020
-S_IXGRP = 00010
-S_IRWXO = 00007
-S_IROTH = 00004
-S_IWOTH = 00002
-S_IXOTH = 00001
+S_IRWXU = 0o0700
+S_IRUSR = 0o0400
+S_IWUSR = 0o0200
+S_IXUSR = 0o0100
+S_IRWXG = 0o0070
+S_IRGRP = 0o0040
+S_IWGRP = 0o0020
+S_IXGRP = 0o0010
+S_IRWXO = 0o0007
+S_IROTH = 0o0004
+S_IWOTH = 0o0002
+S_IXOTH = 0o0001
S_IRWXUGO = (S_IRWXU|S_IRWXG|S_IRWXO)
S_IALLUGO = (S_ISUID|S_ISGID|S_ISVTX|S_IRWXUGO)
S_IRUGO = (S_IRUSR|S_IRGRP|S_IROTH)
@@ -612,24 +612,24 @@
_STAT_VER_KERNEL = 0
# Included from posix/fcntl.h
-O_ACCMODE = 0003
+O_ACCMODE = 0o003
O_RWMASK = O_ACCMODE
O_RDONLY = 00
-O_WRONLY = 01
-O_RDWR = 02
-O_CREAT = 0100
-O_EXCL = 0200
-O_NOCTTY = 0400
-O_TRUNC = 01000
-O_APPEND = 02000
-O_NONBLOCK = 04000
+O_WRONLY = 0o1
+O_RDWR = 0o2
+O_CREAT = 0o100
+O_EXCL = 0o200
+O_NOCTTY = 0o400
+O_TRUNC = 0o1000
+O_APPEND = 0o2000
+O_NONBLOCK = 0o4000
O_NDELAY = O_NONBLOCK
-O_SYNC = 010000
+O_SYNC = 0o10000
O_FSYNC = O_SYNC
-O_ASYNC = 020000
+O_ASYNC = 0o20000
FASYNC = O_ASYNC
-O_DIRECTORY = 040000
-O_NOTRAVERSE = 0100000
+O_DIRECTORY = 0o40000
+O_NOTRAVERSE = 0o100000
O_NOFOLLOW = O_NOTRAVERSE
F_DUPFD = 0
F_GETFD = 1
diff --git a/Lib/plat-mac/aepack.py b/Lib/plat-mac/aepack.py
index 7ce8548..d7cbbce 100644
--- a/Lib/plat-mac/aepack.py
+++ b/Lib/plat-mac/aepack.py
@@ -100,10 +100,10 @@
data = data[2:]
return AE.AECreateDesc('utxt', data)
if isinstance(x, list):
- list = AE.AECreateList('', 0)
+ lst = AE.AECreateList('', 0)
for item in x:
- list.AEPutDesc(0, pack(item))
- return list
+ lst.AEPutDesc(0, pack(item))
+ return lst
if isinstance(x, dict):
record = AE.AECreateList('', 1)
for key, value in x.items():
diff --git a/Lib/plat-mac/bundlebuilder.py b/Lib/plat-mac/bundlebuilder.py
index bf11ed9..e833add 100755
--- a/Lib/plat-mac/bundlebuilder.py
+++ b/Lib/plat-mac/bundlebuilder.py
@@ -504,7 +504,7 @@
standalone = self.standalone
semi_standalone = self.semi_standalone
open(bootstrappath, "w").write(BOOTSTRAP_SCRIPT % locals())
- os.chmod(bootstrappath, 0775)
+ os.chmod(bootstrappath, 0o775)
if self.iconfile is not None:
iconbase = os.path.basename(self.iconfile)
@@ -603,7 +603,7 @@
walk(path)
else:
mod = os.stat(path)[stat.ST_MODE]
- if not (mod & 0100):
+ if not (mod & 0o100):
continue
relpath = path[len(self.bundlepath):]
self.message("Stripping %s" % relpath, 2)
diff --git a/Lib/plat-mac/macostools.py b/Lib/plat-mac/macostools.py
index 27d2f83..67d32e7 100644
--- a/Lib/plat-mac/macostools.py
+++ b/Lib/plat-mac/macostools.py
@@ -61,7 +61,7 @@
if os.sep == ':' and not ':' in head:
head = head + ':'
mkdirs(head)
- os.mkdir(dst, 0777)
+ os.mkdir(dst, 0o777)
def touched(dst):
"""Tell the finder a file has changed. No-op on MacOSX."""
diff --git a/Lib/plat-mac/plistlib.py b/Lib/plat-mac/plistlib.py
index 049b50b..709e8e1 100644
--- a/Lib/plat-mac/plistlib.py
+++ b/Lib/plat-mac/plistlib.py
@@ -320,7 +320,7 @@
from warnings import warn
warn("The plistlib.Dict class is deprecated, use builtin dict instead",
PendingDeprecationWarning)
- super(Dict, self).__init__(**kwargs)
+ super().__init__(**kwargs)
class Plist(_InternalDict):
@@ -333,7 +333,7 @@
from warnings import warn
warn("The Plist class is deprecated, use the readPlist() and "
"writePlist() functions instead", PendingDeprecationWarning)
- super(Plist, self).__init__(**kwargs)
+ super().__init__(**kwargs)
def fromFile(cls, pathOrFile):
"""Deprecated. Use the readPlist() function instead."""
diff --git a/Lib/plat-sunos5/IN.py b/Lib/plat-sunos5/IN.py
index 3a4971d..9572ead 100755
--- a/Lib/plat-sunos5/IN.py
+++ b/Lib/plat-sunos5/IN.py
@@ -97,7 +97,7 @@
NZERO = 20
NULL = 0
NULL = 0
-CMASK = 022
+CMASK = 0o22
CDLIMIT = (1<<11)
NBPS = 0x20000
NBPSCTR = 512
@@ -733,13 +733,13 @@
_XRS_ID = 0x78727300
GETCONTEXT = 0
SETCONTEXT = 1
-UC_SIGMASK = 001
-UC_STACK = 002
-UC_CPU = 004
-UC_MAU = 010
+UC_SIGMASK = 0o01
+UC_STACK = 0o02
+UC_CPU = 0o04
+UC_MAU = 0o10
UC_FPU = UC_MAU
-UC_INTR = 020
-UC_ASR = 040
+UC_INTR = 0o20
+UC_ASR = 0o40
UC_MCONTEXT = (UC_CPU|UC_FPU|UC_ASR)
UC_ALL = (UC_SIGMASK|UC_STACK|UC_MCONTEXT)
_SIGQUEUE_MAX = 32
@@ -1021,14 +1021,14 @@
AT_TIMES = (AT_ATIME|AT_MTIME|AT_CTIME)
AT_NOSET = (AT_NLINK|AT_RDEV|AT_FSID|AT_NODEID|AT_TYPE|\
AT_BLKSIZE|AT_NBLOCKS|AT_VCODE)
-VSUID = 04000
-VSGID = 02000
-VSVTX = 01000
-VREAD = 00400
-VWRITE = 00200
-VEXEC = 00100
-MODEMASK = 07777
-PERMMASK = 00777
+VSUID = 0o4000
+VSGID = 0o2000
+VSVTX = 0o1000
+VREAD = 0o0400
+VWRITE = 0o0200
+VEXEC = 0o0100
+MODEMASK = 0o7777
+PERMMASK = 0o0777
def MANDMODE(mode): return (((mode) & (VSGID|(VEXEC>>3))) == VSGID)
VSA_ACL = 0x0001
diff --git a/Lib/plat-sunos5/STROPTS.py b/Lib/plat-sunos5/STROPTS.py
index b72f4e6..8f735c4 100644
--- a/Lib/plat-sunos5/STROPTS.py
+++ b/Lib/plat-sunos5/STROPTS.py
@@ -94,7 +94,7 @@
NZERO = 20
NULL = 0
NULL = 0
-CMASK = 022
+CMASK = 0o22
CDLIMIT = (1<<11)
NBPS = 0x20000
NBPSCTR = 512
@@ -730,13 +730,13 @@
_XRS_ID = 0x78727300
GETCONTEXT = 0
SETCONTEXT = 1
-UC_SIGMASK = 001
-UC_STACK = 002
-UC_CPU = 004
-UC_MAU = 010
+UC_SIGMASK = 0o01
+UC_STACK = 0o02
+UC_CPU = 0o04
+UC_MAU = 0o10
UC_FPU = UC_MAU
-UC_INTR = 020
-UC_ASR = 040
+UC_INTR = 0o20
+UC_ASR = 0o40
UC_MCONTEXT = (UC_CPU|UC_FPU|UC_ASR)
UC_ALL = (UC_SIGMASK|UC_STACK|UC_MCONTEXT)
_SIGQUEUE_MAX = 32
@@ -1400,14 +1400,14 @@
AT_TIMES = (AT_ATIME|AT_MTIME|AT_CTIME)
AT_NOSET = (AT_NLINK|AT_RDEV|AT_FSID|AT_NODEID|AT_TYPE|\
AT_BLKSIZE|AT_NBLOCKS|AT_VCODE)
-VSUID = 04000
-VSGID = 02000
-VSVTX = 01000
-VREAD = 00400
-VWRITE = 00200
-VEXEC = 00100
-MODEMASK = 07777
-PERMMASK = 00777
+VSUID = 0o4000
+VSGID = 0o2000
+VSVTX = 0o1000
+VREAD = 0o0400
+VWRITE = 0o0200
+VEXEC = 0o0100
+MODEMASK = 0o7777
+PERMMASK = 0o0777
def MANDMODE(mode): return (((mode) & (VSGID|(VEXEC>>3))) == VSGID)
VSA_ACL = 0x0001
diff --git a/Lib/plat-unixware7/IN.py b/Lib/plat-unixware7/IN.py
index 514456e..af023b4 100644
--- a/Lib/plat-unixware7/IN.py
+++ b/Lib/plat-unixware7/IN.py
@@ -187,8 +187,8 @@
NC_TPI_COTS_ORD = 3
NC_TPI_RAW = 4
NC_NOFLAG = 00
-NC_VISIBLE = 01
-NC_BROADCAST = 02
+NC_VISIBLE = 0o1
+NC_BROADCAST = 0o2
NC_NOPROTOFMLY = "-"
NC_LOOPBACK = "loopback"
NC_INET = "inet"
diff --git a/Lib/plat-unixware7/STROPTS.py b/Lib/plat-unixware7/STROPTS.py
index 9850eb4..ef50a9c 100644
--- a/Lib/plat-unixware7/STROPTS.py
+++ b/Lib/plat-unixware7/STROPTS.py
@@ -65,41 +65,41 @@
ES_MACADTLID = 7
ES_PRVID = 8
ES_TPGETMAJOR = 9
-SA_EXEC = 001
-SA_WRITE = 002
-SA_READ = 004
-SA_SUBSIZE = 010
+SA_EXEC = 0o01
+SA_WRITE = 0o02
+SA_READ = 0o04
+SA_SUBSIZE = 0o10
# Included from sys/stropts_f.h
X_STR = (ord('S')<<8)
-X_I_BASE = (X_STR|0200)
-X_I_NREAD = (X_STR|0201)
-X_I_PUSH = (X_STR|0202)
-X_I_POP = (X_STR|0203)
-X_I_LOOK = (X_STR|0204)
-X_I_FLUSH = (X_STR|0205)
-X_I_SRDOPT = (X_STR|0206)
-X_I_GRDOPT = (X_STR|0207)
-X_I_STR = (X_STR|0210)
-X_I_SETSIG = (X_STR|0211)
-X_I_GETSIG = (X_STR|0212)
-X_I_FIND = (X_STR|0213)
-X_I_LINK = (X_STR|0214)
-X_I_UNLINK = (X_STR|0215)
-X_I_PEEK = (X_STR|0217)
-X_I_FDINSERT = (X_STR|0220)
-X_I_SENDFD = (X_STR|0221)
-X_I_RECVFD = (X_STR|0222)
+X_I_BASE = (X_STR|0o200)
+X_I_NREAD = (X_STR|0o201)
+X_I_PUSH = (X_STR|0o202)
+X_I_POP = (X_STR|0o203)
+X_I_LOOK = (X_STR|0o204)
+X_I_FLUSH = (X_STR|0o205)
+X_I_SRDOPT = (X_STR|0o206)
+X_I_GRDOPT = (X_STR|0o207)
+X_I_STR = (X_STR|0o210)
+X_I_SETSIG = (X_STR|0o211)
+X_I_GETSIG = (X_STR|0o212)
+X_I_FIND = (X_STR|0o213)
+X_I_LINK = (X_STR|0o214)
+X_I_UNLINK = (X_STR|0o215)
+X_I_PEEK = (X_STR|0o217)
+X_I_FDINSERT = (X_STR|0o220)
+X_I_SENDFD = (X_STR|0o221)
+X_I_RECVFD = (X_STR|0o222)
# Included from unistd.h
# Included from sys/unistd.h
-R_OK = 004
-W_OK = 002
-X_OK = 001
+R_OK = 0o04
+W_OK = 0o02
+X_OK = 0o01
F_OK = 000
-EFF_ONLY_OK = 010
-EX_OK = 020
+EFF_ONLY_OK = 0o10
+EX_OK = 0o20
SEEK_SET = 0
SEEK_CUR = 1
SEEK_END = 2
@@ -289,40 +289,40 @@
ANYMARK = 0x01
LASTMARK = 0x02
STR = (ord('S')<<8)
-I_NREAD = (STR|01)
-I_PUSH = (STR|02)
-I_POP = (STR|03)
-I_LOOK = (STR|04)
-I_FLUSH = (STR|05)
-I_SRDOPT = (STR|06)
-I_GRDOPT = (STR|07)
-I_STR = (STR|010)
-I_SETSIG = (STR|011)
-I_GETSIG = (STR|012)
-I_FIND = (STR|013)
-I_LINK = (STR|014)
-I_UNLINK = (STR|015)
-I_PEEK = (STR|017)
-I_FDINSERT = (STR|020)
-I_SENDFD = (STR|021)
-I_RECVFD = (STR|022)
-I_E_RECVFD = (STR|016)
-I_RECVFD = (STR|016)
-I_RECVFD = (STR|022)
-I_SWROPT = (STR|023)
-I_GWROPT = (STR|024)
-I_LIST = (STR|025)
-I_PLINK = (STR|026)
-I_PUNLINK = (STR|027)
-I_FLUSHBAND = (STR|034)
-I_CKBAND = (STR|035)
-I_GETBAND = (STR|036)
-I_ATMARK = (STR|037)
-I_SETCLTIME = (STR|040)
-I_GETCLTIME = (STR|041)
-I_CANPUT = (STR|042)
-I_S_RECVFD = (STR|043)
-I_STATS = (STR|044)
-I_BIGPIPE = (STR|045)
-I_GETTP = (STR|046)
+I_NREAD = (STR|0o1)
+I_PUSH = (STR|0o2)
+I_POP = (STR|0o3)
+I_LOOK = (STR|0o4)
+I_FLUSH = (STR|0o5)
+I_SRDOPT = (STR|0o6)
+I_GRDOPT = (STR|0o7)
+I_STR = (STR|0o10)
+I_SETSIG = (STR|0o11)
+I_GETSIG = (STR|0o12)
+I_FIND = (STR|0o13)
+I_LINK = (STR|0o14)
+I_UNLINK = (STR|0o15)
+I_PEEK = (STR|0o17)
+I_FDINSERT = (STR|0o20)
+I_SENDFD = (STR|0o21)
+I_RECVFD = (STR|0o22)
+I_E_RECVFD = (STR|0o16)
+I_RECVFD = (STR|0o16)
+I_RECVFD = (STR|0o22)
+I_SWROPT = (STR|0o23)
+I_GWROPT = (STR|0o24)
+I_LIST = (STR|0o25)
+I_PLINK = (STR|0o26)
+I_PUNLINK = (STR|0o27)
+I_FLUSHBAND = (STR|0o34)
+I_CKBAND = (STR|0o35)
+I_GETBAND = (STR|0o36)
+I_ATMARK = (STR|0o37)
+I_SETCLTIME = (STR|0o40)
+I_GETCLTIME = (STR|0o41)
+I_CANPUT = (STR|0o42)
+I_S_RECVFD = (STR|0o43)
+I_STATS = (STR|0o44)
+I_BIGPIPE = (STR|0o45)
+I_GETTP = (STR|0o46)
INFTIM = -1
diff --git a/Lib/platform.py b/Lib/platform.py
index bd9efe6..25daadd 100755
--- a/Lib/platform.py
+++ b/Lib/platform.py
@@ -242,7 +242,7 @@
_supported_dists = ('SuSE', 'debian', 'fedora', 'redhat', 'centos',
'mandrake', 'rocks', 'slackware', 'yellowdog',
- 'gentoo', 'UnitedLinux')
+ 'gentoo', 'UnitedLinux', 'turbolinux')
def _parse_release_file(firstline):
@@ -600,6 +600,16 @@
release = '2003Server'
else:
release = 'post2003'
+ elif maj == 6:
+ if min == 0:
+ # Per http://msdn2.microsoft.com/en-us/library/ms724429.aspx
+ productType = GetVersionEx(1)[8]
+ if productType == 1: # VER_NT_WORKSTATION
+ release = 'Vista'
+ else:
+ release = '2008Server'
+ else:
+ release = 'post2008Server'
else:
if not release:
# E.g. Win3.1 with win32s
@@ -1064,6 +1074,16 @@
# (_syscmd_ver() tends to return the vendor name as well)
if system == 'Microsoft Windows':
system = 'Windows'
+ elif system == 'Microsoft' and release == 'Windows':
+ # Under Windows Vista and Windows Server 2008,
+ # Microsoft changed the output of the ver command. The
+ # release is no longer printed. This causes the
+ # system and release to be misidentified.
+ system = 'Windows'
+ if '6.0' == version[:3]:
+ release = 'Vista'
+ else:
+ release = ''
# In case we still don't know anything useful, we'll try to
# help ourselves
diff --git a/Lib/pty.py b/Lib/pty.py
index 9122624..5d588e4 100644
--- a/Lib/pty.py
+++ b/Lib/pty.py
@@ -55,7 +55,7 @@
pass
else:
try:
- tty_name, master_fd = sgi._getpty(os.O_RDWR, 0666, 0)
+ tty_name, master_fd = sgi._getpty(os.O_RDWR, 0o666, 0)
except IOError as msg:
raise os.error, msg
return master_fd, tty_name
diff --git a/Lib/random.py b/Lib/random.py
index 075c3b7..8a47178 100644
--- a/Lib/random.py
+++ b/Lib/random.py
@@ -110,19 +110,19 @@
import time
a = int(time.time() * 256) # use fractional seconds
- super(Random, self).seed(a)
+ super().seed(a)
self.gauss_next = None
def getstate(self):
"""Return internal state; can be passed to setstate() later."""
- return self.VERSION, super(Random, self).getstate(), self.gauss_next
+ return self.VERSION, super().getstate(), self.gauss_next
def setstate(self, state):
"""Restore internal state from object returned by getstate()."""
version = state[0]
if version == 2:
version, internalstate, self.gauss_next = state
- super(Random, self).setstate(internalstate)
+ super().setstate(internalstate)
else:
raise ValueError("state with version %s passed to "
"Random.setstate() of version %s" %
diff --git a/Lib/repr.py b/Lib/repr.py
index c580168..84d963d 100644
--- a/Lib/repr.py
+++ b/Lib/repr.py
@@ -47,7 +47,7 @@
return '%s%s%s' % (left, s, right)
def repr_tuple(self, x, level):
- return self._repr_iterable(x, level, '(', ')', self.maxlist, ',')
+ return self._repr_iterable(x, level, '(', ')', self.maxtuple, ',')
def repr_list(self, x, level):
return self._repr_iterable(x, level, '[', ']', self.maxlist)
diff --git a/Lib/sqlite3/test/dbapi.py b/Lib/sqlite3/test/dbapi.py
index 99ed02b..faf31b1 100644
--- a/Lib/sqlite3/test/dbapi.py
+++ b/Lib/sqlite3/test/dbapi.py
@@ -40,12 +40,12 @@
sqlite.paramstyle)
def CheckWarning(self):
- self.assert_(issubclass(sqlite.Warning, StandardError),
- "Warning is not a subclass of StandardError")
+ self.assert_(issubclass(sqlite.Warning, Exception),
+ "Warning is not a subclass of Exception")
def CheckError(self):
- self.failUnless(issubclass(sqlite.Error, StandardError),
- "Error is not a subclass of StandardError")
+ self.failUnless(issubclass(sqlite.Error, Exception),
+ "Error is not a subclass of Exception")
def CheckInterfaceError(self):
self.failUnless(issubclass(sqlite.InterfaceError, sqlite.Error),
diff --git a/Lib/stat.py b/Lib/stat.py
index 5f41687..c054fb8 100644
--- a/Lib/stat.py
+++ b/Lib/stat.py
@@ -24,21 +24,21 @@
# Extract bits from the mode
def S_IMODE(mode):
- return mode & 07777
+ return mode & 0o7777
def S_IFMT(mode):
- return mode & 0170000
+ return mode & 0o170000
# Constants used as S_IFMT() for various file types
# (not all are implemented on all systems)
-S_IFDIR = 0040000
-S_IFCHR = 0020000
-S_IFBLK = 0060000
-S_IFREG = 0100000
-S_IFIFO = 0010000
-S_IFLNK = 0120000
-S_IFSOCK = 0140000
+S_IFDIR = 0o040000
+S_IFCHR = 0o020000
+S_IFBLK = 0o060000
+S_IFREG = 0o100000
+S_IFIFO = 0o010000
+S_IFLNK = 0o120000
+S_IFSOCK = 0o140000
# Functions to test for each file type
@@ -65,25 +65,25 @@
# Names for permission bits
-S_ISUID = 04000
-S_ISGID = 02000
+S_ISUID = 0o4000
+S_ISGID = 0o2000
S_ENFMT = S_ISGID
-S_ISVTX = 01000
-S_IREAD = 00400
-S_IWRITE = 00200
-S_IEXEC = 00100
-S_IRWXU = 00700
-S_IRUSR = 00400
-S_IWUSR = 00200
-S_IXUSR = 00100
-S_IRWXG = 00070
-S_IRGRP = 00040
-S_IWGRP = 00020
-S_IXGRP = 00010
-S_IRWXO = 00007
-S_IROTH = 00004
-S_IWOTH = 00002
-S_IXOTH = 00001
+S_ISVTX = 0o1000
+S_IREAD = 0o0400
+S_IWRITE = 0o0200
+S_IEXEC = 0o0100
+S_IRWXU = 0o0700
+S_IRUSR = 0o0400
+S_IWUSR = 0o0200
+S_IXUSR = 0o0100
+S_IRWXG = 0o0070
+S_IRGRP = 0o0040
+S_IWGRP = 0o0020
+S_IXGRP = 0o0010
+S_IRWXO = 0o0007
+S_IROTH = 0o0004
+S_IWOTH = 0o0002
+S_IXOTH = 0o0001
# Names for file flags
diff --git a/Lib/tarfile.py b/Lib/tarfile.py
index 97973fd..94dac98 100644
--- a/Lib/tarfile.py
+++ b/Lib/tarfile.py
@@ -141,26 +141,26 @@
#---------------------------------------------------------
# Bits used in the mode field, values in octal.
#---------------------------------------------------------
-S_IFLNK = 0120000 # symbolic link
-S_IFREG = 0100000 # regular file
-S_IFBLK = 0060000 # block device
-S_IFDIR = 0040000 # directory
-S_IFCHR = 0020000 # character device
-S_IFIFO = 0010000 # fifo
+S_IFLNK = 0o120000 # symbolic link
+S_IFREG = 0o100000 # regular file
+S_IFBLK = 0o060000 # block device
+S_IFDIR = 0o040000 # directory
+S_IFCHR = 0o020000 # character device
+S_IFIFO = 0o010000 # fifo
-TSUID = 04000 # set UID on execution
-TSGID = 02000 # set GID on execution
-TSVTX = 01000 # reserved
+TSUID = 0o4000 # set UID on execution
+TSGID = 0o2000 # set GID on execution
+TSVTX = 0o1000 # reserved
-TUREAD = 0400 # read by owner
-TUWRITE = 0200 # write by owner
-TUEXEC = 0100 # execute/search by owner
-TGREAD = 0040 # read by group
-TGWRITE = 0020 # write by group
-TGEXEC = 0010 # execute/search by group
-TOREAD = 0004 # read by other
-TOWRITE = 0002 # write by other
-TOEXEC = 0001 # execute/search by other
+TUREAD = 0o400 # read by owner
+TUWRITE = 0o200 # write by owner
+TUEXEC = 0o100 # execute/search by owner
+TGREAD = 0o040 # read by group
+TGWRITE = 0o020 # write by group
+TGEXEC = 0o010 # execute/search by group
+TOREAD = 0o004 # read by other
+TOWRITE = 0o002 # write by other
+TOEXEC = 0o001 # execute/search by other
#---------------------------------------------------------
# initialization
@@ -192,7 +192,7 @@
"""
# There are two possible encodings for a number field, see
# itn() below.
- if s[0] != chr(0200):
+ if s[0] != chr(0o200):
try:
n = int(nts(s) or "0", 8)
except ValueError:
@@ -210,7 +210,7 @@
# POSIX 1003.1-1988 requires numbers to be encoded as a string of
# octal digits followed by a null-byte, this allows values up to
# (8**(digits-1))-1. GNU tar allows storing numbers greater than
- # that if necessary. A leading 0200 byte indicates this particular
+ # that if necessary. A leading 0o200 byte indicates this particular
# encoding, the following digits-1 bytes are a big-endian
# representation. This allows values up to (256**(digits-1))-1.
if 0 <= n < 8 ** (digits - 1):
@@ -226,9 +226,9 @@
s = ""
for i in range(digits - 1):
- s = chr(n & 0377) + s
+ s = chr(n & 0o377) + s
n >>= 8
- s = chr(0200) + s
+ s = chr(0o200) + s
return s
def uts(s, encoding, errors):
@@ -920,7 +920,7 @@
of the member.
"""
self.name = name # member name
- self.mode = 0644 # file permissions
+ self.mode = 0o644 # file permissions
self.uid = 0 # user id
self.gid = 0 # group id
self.size = 0 # file size
@@ -960,7 +960,7 @@
"""
info = {
"name": normpath(self.name),
- "mode": self.mode & 07777,
+ "mode": self.mode & 0o7777,
"uid": self.uid,
"gid": self.gid,
"size": self.size,
@@ -1103,7 +1103,7 @@
"""
parts = [
stn(info.get("name", ""), 100),
- itn(info.get("mode", 0) & 07777, 8, format),
+ itn(info.get("mode", 0) & 0o7777, 8, format),
itn(info.get("uid", 0), 8, format),
itn(info.get("gid", 0), 8, format),
itn(info.get("size", 0), 12, format),
@@ -2019,7 +2019,7 @@
# Extract directory with a safe mode, so that
# all files below can be extracted as well.
try:
- os.makedirs(os.path.join(path, tarinfo.name), 0700)
+ os.makedirs(os.path.join(path, tarinfo.name), 0o700)
except EnvironmentError:
pass
directories.append(tarinfo)
diff --git a/Lib/tempfile.py b/Lib/tempfile.py
index 0dd32f3..109dc59 100644
--- a/Lib/tempfile.py
+++ b/Lib/tempfile.py
@@ -197,7 +197,7 @@
name = next(namer)
filename = _os.path.join(dir, name)
try:
- fd = _os.open(filename, flags, 0600)
+ fd = _os.open(filename, flags, 0o600)
fp = _os.fdopen(fd, 'w')
fp.write('blat')
fp.close()
@@ -236,7 +236,7 @@
name = next(names)
file = _os.path.join(dir, pre + name + suf)
try:
- fd = _os.open(file, flags, 0600)
+ fd = _os.open(file, flags, 0o600)
_set_cloexec(fd)
return (fd, _os.path.abspath(file))
except OSError as e:
@@ -328,7 +328,7 @@
name = next(names)
file = _os.path.join(dir, prefix + name + suffix)
try:
- _os.mkdir(file, 0700)
+ _os.mkdir(file, 0o700)
return file
except OSError as e:
if e.errno == _errno.EEXIST:
diff --git a/Lib/test/exception_hierarchy.txt b/Lib/test/exception_hierarchy.txt
index a03f7bb..079ce29 100644
--- a/Lib/test/exception_hierarchy.txt
+++ b/Lib/test/exception_hierarchy.txt
@@ -4,39 +4,38 @@
+-- Exception
+-- GeneratorExit
+-- StopIteration
- +-- StandardError
- | +-- ArithmeticError
- | | +-- FloatingPointError
- | | +-- OverflowError
- | | +-- ZeroDivisionError
- | +-- AssertionError
- | +-- AttributeError
- | +-- EnvironmentError
- | | +-- IOError
- | | +-- OSError
- | | +-- WindowsError (Windows)
- | | +-- VMSError (VMS)
- | +-- EOFError
- | +-- ImportError
- | +-- LookupError
- | | +-- IndexError
- | | +-- KeyError
- | +-- MemoryError
- | +-- NameError
- | | +-- UnboundLocalError
- | +-- ReferenceError
- | +-- RuntimeError
- | | +-- NotImplementedError
- | +-- SyntaxError
- | | +-- IndentationError
- | | +-- TabError
- | +-- SystemError
- | +-- TypeError
- | +-- ValueError
- | | +-- UnicodeError
- | | +-- UnicodeDecodeError
- | | +-- UnicodeEncodeError
- | | +-- UnicodeTranslateError
+ +-- ArithmeticError
+ | +-- FloatingPointError
+ | +-- OverflowError
+ | +-- ZeroDivisionError
+ +-- AssertionError
+ +-- AttributeError
+ +-- EnvironmentError
+ | +-- IOError
+ | +-- OSError
+ | +-- WindowsError (Windows)
+ | +-- VMSError (VMS)
+ +-- EOFError
+ +-- ImportError
+ +-- LookupError
+ | +-- IndexError
+ | +-- KeyError
+ +-- MemoryError
+ +-- NameError
+ | +-- UnboundLocalError
+ +-- ReferenceError
+ +-- RuntimeError
+ | +-- NotImplementedError
+ +-- SyntaxError
+ | +-- IndentationError
+ | +-- TabError
+ +-- SystemError
+ +-- TypeError
+ +-- ValueError
+ | +-- UnicodeError
+ | +-- UnicodeDecodeError
+ | +-- UnicodeEncodeError
+ | +-- UnicodeTranslateError
+-- Warning
+-- DeprecationWarning
+-- PendingDeprecationWarning
diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py
index 468a1bc..0d893f2 100644
--- a/Lib/test/list_tests.py
+++ b/Lib/test/list_tests.py
@@ -451,7 +451,7 @@
self.assertEqual(u, list("ham"))
def test_iadd(self):
- super(CommonTest, self).test_iadd()
+ super().test_iadd()
u = self.type2test([0, 1])
u2 = u
u += [2, 3]
diff --git a/Lib/test/output/test_class b/Lib/test/output/test_class
index f6ba475..d0fed75 100644
--- a/Lib/test/output/test_class
+++ b/Lib/test/output/test_class
@@ -46,8 +46,7 @@
__int__: ()
__int__: ()
__float__: ()
-__oct__: ()
-__hex__: ()
+__index__: ()
__hash__: ()
__repr__: ()
__str__: ()
diff --git a/Lib/test/output/test_tokenize b/Lib/test/output/test_tokenize
index a46824d..c3bb8b0 100644
--- a/Lib/test/output/test_tokenize
+++ b/Lib/test/output/test_tokenize
@@ -124,66 +124,80 @@
39,5-39,7: OP '!='
39,8-39,11: NUMBER '255'
39,11-39,12: NEWLINE '\n'
-40,0-40,4: NUMBER '0377'
-40,5-40,7: OP '!='
-40,8-40,11: NUMBER '255'
-40,11-40,12: NEWLINE '\n'
+40,0-40,5: NUMBER '0o377'
+40,6-40,8: OP '!='
+40,9-40,12: NUMBER '255'
+40,12-40,13: NEWLINE '\n'
41,0-41,10: NUMBER '2147483647'
41,13-41,15: OP '!='
-41,16-41,28: NUMBER '017777777777'
-41,28-41,29: NEWLINE '\n'
+41,16-41,29: NUMBER '0o17777777777'
+41,29-41,30: NEWLINE '\n'
42,0-42,1: OP '-'
42,1-42,11: NUMBER '2147483647'
42,11-42,12: OP '-'
42,12-42,13: NUMBER '1'
42,14-42,16: OP '!='
-42,17-42,29: NUMBER '020000000000'
-42,29-42,30: NEWLINE '\n'
-43,0-43,12: NUMBER '037777777777'
-43,13-43,15: OP '!='
-43,16-43,17: OP '-'
-43,17-43,18: NUMBER '1'
-43,18-43,19: NEWLINE '\n'
+42,17-42,30: NUMBER '0o20000000000'
+42,30-42,31: NEWLINE '\n'
+43,0-43,13: NUMBER '0o37777777777'
+43,14-43,16: OP '!='
+43,17-43,18: OP '-'
+43,18-43,19: NUMBER '1'
+43,19-43,20: NEWLINE '\n'
44,0-44,10: NUMBER '0xffffffff'
44,11-44,13: OP '!='
44,14-44,15: OP '-'
44,15-44,16: NUMBER '1'
-44,16-44,17: NEWLINE '\n'
+44,16-44,17: OP ';'
+44,18-44,31: NUMBER '0o37777777777'
+44,32-44,34: OP '!='
+44,35-44,36: OP '-'
+44,36-44,37: NUMBER '1'
+44,37-44,38: OP ';'
+44,39-44,40: OP '-'
+44,40-44,49: NUMBER '0o1234567'
+44,50-44,52: OP '=='
+44,53-44,64: NUMBER '0O001234567'
+44,64-44,65: OP ';'
+44,66-44,73: NUMBER '0b10101'
+44,74-44,76: OP '=='
+44,77-44,87: NUMBER '0B00010101'
+44,87-44,88: NEWLINE '\n'
45,0-45,1: NL '\n'
46,0-46,15: COMMENT '# Long integers'
46,15-46,16: NL '\n'
47,0-47,1: NAME 'x'
47,2-47,3: OP '='
-47,4-47,6: NUMBER '0L'
-47,6-47,7: NEWLINE '\n'
+47,4-47,5: NUMBER '0'
+47,5-47,6: NEWLINE '\n'
48,0-48,1: NAME 'x'
48,2-48,3: OP '='
-48,4-48,6: NUMBER '0l'
-48,6-48,7: NEWLINE '\n'
+48,4-48,5: NUMBER '0'
+48,5-48,6: NEWLINE '\n'
49,0-49,1: NAME 'x'
49,2-49,3: OP '='
-49,4-49,23: NUMBER '0xffffffffffffffffL'
-49,23-49,24: NEWLINE '\n'
+49,4-49,22: NUMBER '0xffffffffffffffff'
+49,22-49,23: NEWLINE '\n'
50,0-50,1: NAME 'x'
50,2-50,3: OP '='
-50,4-50,23: NUMBER '0xffffffffffffffffl'
-50,23-50,24: NEWLINE '\n'
+50,4-50,22: NUMBER '0xffffffffffffffff'
+50,22-50,23: NEWLINE '\n'
51,0-51,1: NAME 'x'
51,2-51,3: OP '='
-51,4-51,23: NUMBER '077777777777777777L'
+51,4-51,23: NUMBER '0o77777777777777777'
51,23-51,24: NEWLINE '\n'
52,0-52,1: NAME 'x'
52,2-52,3: OP '='
-52,4-52,23: NUMBER '077777777777777777l'
+52,4-52,23: NUMBER '0B11101010111111111'
52,23-52,24: NEWLINE '\n'
53,0-53,1: NAME 'x'
53,2-53,3: OP '='
-53,4-53,35: NUMBER '123456789012345678901234567890L'
-53,35-53,36: NEWLINE '\n'
+53,4-53,34: NUMBER '123456789012345678901234567890'
+53,34-53,35: NEWLINE '\n'
54,0-54,1: NAME 'x'
54,2-54,3: OP '='
-54,4-54,35: NUMBER '123456789012345678901234567890l'
-54,35-54,36: NEWLINE '\n'
+54,4-54,34: NUMBER '123456789012345678901234567890'
+54,34-54,35: NEWLINE '\n'
55,0-55,1: NL '\n'
56,0-56,24: COMMENT '# Floating-point numbers'
56,24-56,25: NL '\n'
diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py
index de0b9f0..5dfc9d4 100755
--- a/Lib/test/regrtest.py
+++ b/Lib/test/regrtest.py
@@ -697,7 +697,7 @@
import gc, copy_reg
import _strptime, linecache, dircache
import urlparse, urllib, urllib2, mimetypes, doctest
- import struct, filecmp
+ import struct, filecmp, collections
from distutils.dir_util import _path_created
# Restore some original values.
@@ -707,6 +707,10 @@
sys.path_importer_cache.clear()
sys.path_importer_cache.update(pic)
+ # Clear ABC registries.
+ for obj in [collections.Hashable, collections.Iterable]:
+ obj._ABCMeta__registry.clear()
+
# Clear assorted module caches.
_path_created.clear()
re.purge()
diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py
index 4dfbb1b..0ce212c 100644
--- a/Lib/test/string_tests.py
+++ b/Lib/test/string_tests.py
@@ -211,6 +211,32 @@
self.checkraises(TypeError, 'hello', 'rindex')
self.checkraises(TypeError, 'hello', 'rindex', 42)
+ def test_lower(self):
+ self.checkequal('hello', 'HeLLo', 'lower')
+ self.checkequal('hello', 'hello', 'lower')
+ self.checkraises(TypeError, 'hello', 'lower', 42)
+
+ def test_upper(self):
+ self.checkequal('HELLO', 'HeLLo', 'upper')
+ self.checkequal('HELLO', 'HELLO', 'upper')
+ self.checkraises(TypeError, 'hello', 'upper', 42)
+
+ def test_expandtabs(self):
+ self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs')
+ self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 8)
+ self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 4)
+ self.checkequal('abc\r\nab def\ng hi', 'abc\r\nab\tdef\ng\thi', 'expandtabs', 4)
+ self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs')
+ self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 8)
+ self.checkequal('abc\r\nab\r\ndef\ng\r\nhi', 'abc\r\nab\r\ndef\ng\r\nhi', 'expandtabs', 4)
+ self.checkequal(' a\n b', ' \ta\n\tb', 'expandtabs', 1)
+
+ self.checkraises(TypeError, 'hello', 'expandtabs', 42, 42)
+ # This test is only valid when sizeof(int) == sizeof(void*) == 4.
+ if sys.maxint < (1 << 32) and struct.calcsize('P') == 4:
+ self.checkraises(OverflowError,
+ '\ta\n\tb', 'expandtabs', sys.maxint)
+
def test_split(self):
# by a char
self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|')
diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
new file mode 100644
index 0000000..aecb800
--- /dev/null
+++ b/Lib/test/test_abc.py
@@ -0,0 +1,123 @@
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Unit tests for abc.py."""
+
+import sys
+import unittest
+from test import test_support
+
+import abc
+
+
+class TestABC(unittest.TestCase):
+
+ def test_abstractmethod_basics(self):
+ @abc.abstractmethod
+ def foo(self): pass
+ self.assertEqual(foo.__isabstractmethod__, True)
+ def bar(self): pass
+ self.assertEqual(hasattr(bar, "__isabstractmethod__"), False)
+
+ def test_abstractmethod_integration(self):
+ class C(metaclass=abc.ABCMeta):
+ @abc.abstractmethod
+ def foo(self): pass # abstract
+ def bar(self): pass # concrete
+ self.assertEqual(C.__abstractmethods__, {"foo"})
+ self.assertRaises(TypeError, C) # because foo is abstract
+ class D(C):
+ def bar(self): pass # concrete override of concrete
+ self.assertEqual(D.__abstractmethods__, {"foo"})
+ self.assertRaises(TypeError, D) # because foo is still abstract
+ class E(D):
+ def foo(self): pass
+ self.assertEqual(E.__abstractmethods__, set())
+ E() # now foo is concrete, too
+ class F(E):
+ @abc.abstractmethod
+ def bar(self): pass # abstract override of concrete
+ self.assertEqual(F.__abstractmethods__, {"bar"})
+ self.assertRaises(TypeError, F) # because bar is abstract now
+
+ def test_registration_basics(self):
+ class A(metaclass=abc.ABCMeta):
+ pass
+ class B:
+ pass
+ b = B()
+ self.assertEqual(issubclass(B, A), False)
+ self.assertEqual(isinstance(b, A), False)
+ A.register(B)
+ self.assertEqual(issubclass(B, A), True)
+ self.assertEqual(isinstance(b, A), True)
+ class C(B):
+ pass
+ c = C()
+ self.assertEqual(issubclass(C, A), True)
+ self.assertEqual(isinstance(c, A), True)
+
+ def test_registration_builtins(self):
+ class A(metaclass=abc.ABCMeta):
+ pass
+ A.register(int)
+ self.assertEqual(isinstance(42, A), True)
+ self.assertEqual(issubclass(int, A), True)
+ class B(A):
+ pass
+ B.register(basestring)
+ self.assertEqual(isinstance("", A), True)
+ self.assertEqual(issubclass(str, A), True)
+
+ def test_registration_edge_cases(self):
+ class A(metaclass=abc.ABCMeta):
+ pass
+ A.register(A) # should pass silently
+ class A1(A):
+ pass
+ self.assertRaises(RuntimeError, A1.register, A) # cycles not allowed
+ class B:
+ pass
+ A1.register(B) # ok
+ A1.register(B) # should pass silently
+ class C(A):
+ pass
+ A.register(C) # should pass silently
+ self.assertRaises(RuntimeError, C.register, A) # cycles not allowed
+ C.register(B) # ok
+
+ def test_registration_transitiveness(self):
+ class A(metaclass=abc.ABCMeta):
+ pass
+ self.failUnless(issubclass(A, A))
+ class B(metaclass=abc.ABCMeta):
+ pass
+ self.failIf(issubclass(A, B))
+ self.failIf(issubclass(B, A))
+ class C(metaclass=abc.ABCMeta):
+ pass
+ A.register(B)
+ class B1(B):
+ pass
+ self.failUnless(issubclass(B1, A))
+ class C1(C):
+ pass
+ B1.register(C1)
+ self.failIf(issubclass(C, B))
+ self.failIf(issubclass(C, B1))
+ self.failUnless(issubclass(C1, A))
+ self.failUnless(issubclass(C1, B))
+ self.failUnless(issubclass(C1, B1))
+ C1.register(int)
+ class MyInt(int):
+ pass
+ self.failUnless(issubclass(MyInt, A))
+ self.failUnless(isinstance(42, A))
+
+
+def test_main():
+ test_support.run_unittest(TestABC)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py
index 2eb64f3..0d4c219 100755
--- a/Lib/test/test_array.py
+++ b/Lib/test/test_array.py
@@ -704,7 +704,7 @@
class StringTest(BaseTest):
def test_setitem(self):
- super(StringTest, self).test_setitem()
+ super().test_setitem()
a = array.array(self.typecode, self.example)
self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2])
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 1c1998d..a2fde02 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -728,8 +728,27 @@
self.assertRaises(TypeError, int, 1, 12)
- self.assertEqual(int('0123', 0), 83)
+ # tests with base 0
+ self.assertRaises(ValueError, int, ' 0123 ', 0) # old octal syntax
+ self.assertEqual(int('000', 0), 0)
+ self.assertEqual(int('0o123', 0), 83)
+ self.assertEqual(int('0x123', 0), 291)
+ self.assertEqual(int('0b100', 0), 4)
+ self.assertEqual(int(' 0O123 ', 0), 83)
+ self.assertEqual(int(' 0X123 ', 0), 291)
+ self.assertEqual(int(' 0B100 ', 0), 4)
+
+ # without base still base 10
+ self.assertEqual(int('0123'), 123)
+ self.assertEqual(int('0123', 10), 123)
+
+ # tests with prefix and base != 0
self.assertEqual(int('0x123', 16), 291)
+ self.assertEqual(int('0o123', 8), 83)
+ self.assertEqual(int('0b100', 2), 4)
+ self.assertEqual(int('0X123', 16), 291)
+ self.assertEqual(int('0O123', 8), 83)
+ self.assertEqual(int('0B100', 2), 4)
# SF bug 1334662: int(string, base) wrong answers
# Various representations of 2**32 evaluated to 0
@@ -1269,10 +1288,10 @@
self.assertEquals(next(it, 42), 42)
def test_oct(self):
- self.assertEqual(oct(100), '0144')
- self.assertEqual(oct(100), '0144')
- self.assertEqual(oct(-100), '-0144')
- self.assertEqual(oct(-100), '-0144')
+ self.assertEqual(oct(100), '0o144')
+ self.assertEqual(oct(100), '0o144')
+ self.assertEqual(oct(-100), '-0o144')
+ self.assertEqual(oct(-100), '-0o144')
self.assertRaises(TypeError, oct, ())
def write_testfile(self):
diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
index efb4c98..1083321 100644
--- a/Lib/test/test_bytes.py
+++ b/Lib/test/test_bytes.py
@@ -716,6 +716,12 @@
pass
def test_find(self):
pass
+ def test_expandtabs(self):
+ pass
+ def test_upper(self):
+ pass
+ def test_lower(self):
+ pass
def test_main():
diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py
index 260d9b2..0bf18a1 100644
--- a/Lib/test/test_cgi.py
+++ b/Lib/test/test_cgi.py
@@ -50,7 +50,7 @@
raise ValueError, "unknown method: %s" % method
try:
return cgi.parse(fp, env, strict_parsing=1)
- except StandardError as err:
+ except Exception as err:
return ComparableException(err)
# A list of test cases. Each test case is a a two-tuple that contains
diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index ded3f1a..003b4a5 100644
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -80,18 +80,14 @@
print("__int__:", args)
return 1
+ def __index__(self, *args):
+ print("__index__:", args)
+ return 1
+
def __float__(self, *args):
print("__float__:", args)
return 1.0
- def __oct__(self, *args):
- print("__oct__:", args)
- return '01'
-
- def __hex__(self, *args):
- print("__hex__:", args)
- return '0x1'
-
def __cmp__(self, *args):
print("__cmp__:", args)
return 0
@@ -237,7 +233,6 @@
int(testme)
float(testme)
oct(testme)
-hex(testme)
# And the rest...
@@ -287,8 +282,6 @@
__float__ = __int__
__str__ = __int__
__repr__ = __int__
- __oct__ = __int__
- __hex__ = __int__
def check_exc(stmt, exception):
"""Raise TestFailed if executing 'stmt' does not raise 'exception'
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
index f5dad7d..13401e9 100644
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -1,6 +1,14 @@
+"""Unit tests for collections.py."""
+
import unittest
from test import test_support
from collections import NamedTuple
+from collections import Hashable, Iterable, Iterator
+from collections import Sized, Container, Callable
+from collections import Set, MutableSet
+from collections import Mapping, MutableMapping
+from collections import Sequence, MutableSequence
+
class TestNamedTuple(unittest.TestCase):
@@ -51,11 +59,187 @@
self.assertRaises(AttributeError, eval, 'p.z', locals())
+class TestOneTrickPonyABCs(unittest.TestCase):
+
+ def test_Hashable(self):
+ # Check some non-hashables
+ non_samples = [bytes(), list(), set(), dict()]
+ for x in non_samples:
+ self.failIf(isinstance(x, Hashable), repr(x))
+ self.failIf(issubclass(type(x), Hashable), repr(type(x)))
+ # Check some hashables
+ samples = [None,
+ int(), float(), complex(),
+ str(), unicode(),
+ tuple(), frozenset(),
+ int, list, object, type,
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Hashable), repr(x))
+ self.failUnless(issubclass(type(x), Hashable), repr(type(x)))
+ self.assertRaises(TypeError, Hashable)
+ # Check direct subclassing
+ class H(Hashable):
+ def __hash__(self):
+ return super().__hash__()
+ self.assertEqual(hash(H()), 0)
+ self.failIf(issubclass(int, H))
+
+ def test_Iterable(self):
+ # Check some non-iterables
+ non_samples = [None, 42, 3.14, 1j]
+ for x in non_samples:
+ self.failIf(isinstance(x, Iterable), repr(x))
+ self.failIf(issubclass(type(x), Iterable), repr(type(x)))
+ # Check some iterables
+ samples = [bytes(), str(), unicode(),
+ tuple(), list(), set(), frozenset(), dict(),
+ dict().keys(), dict().items(), dict().values(),
+ (lambda: (yield))(),
+ (x for x in []),
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Iterable), repr(x))
+ self.failUnless(issubclass(type(x), Iterable), repr(type(x)))
+ # Check direct subclassing
+ class I(Iterable):
+ def __iter__(self):
+ return super().__iter__()
+ self.assertEqual(list(I()), [])
+ self.failIf(issubclass(str, I))
+
+ def test_Iterator(self):
+ non_samples = [None, 42, 3.14, 1j, b"", "", u"", (), [], {}, set()]
+ for x in non_samples:
+ self.failIf(isinstance(x, Iterator), repr(x))
+ self.failIf(issubclass(type(x), Iterator), repr(type(x)))
+ samples = [iter(bytes()), iter(str()), iter(unicode()),
+ iter(tuple()), iter(list()), iter(dict()),
+ iter(set()), iter(frozenset()),
+ iter(dict().keys()), iter(dict().items()),
+ iter(dict().values()),
+ (lambda: (yield))(),
+ (x for x in []),
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Iterator), repr(x))
+ self.failUnless(issubclass(type(x), Iterator), repr(type(x)))
+
+ def test_Sized(self):
+ non_samples = [None, 42, 3.14, 1j,
+ (lambda: (yield))(),
+ (x for x in []),
+ ]
+ for x in non_samples:
+ self.failIf(isinstance(x, Sized), repr(x))
+ self.failIf(issubclass(type(x), Sized), repr(type(x)))
+ samples = [bytes(), str(), unicode(),
+ tuple(), list(), set(), frozenset(), dict(),
+ dict().keys(), dict().items(), dict().values(),
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Sized), repr(x))
+ self.failUnless(issubclass(type(x), Sized), repr(type(x)))
+
+ def test_Container(self):
+ non_samples = [None, 42, 3.14, 1j,
+ (lambda: (yield))(),
+ (x for x in []),
+ ]
+ for x in non_samples:
+ self.failIf(isinstance(x, Container), repr(x))
+ self.failIf(issubclass(type(x), Container), repr(type(x)))
+ samples = [bytes(), str(), unicode(),
+ tuple(), list(), set(), frozenset(), dict(),
+ dict().keys(), dict().items(),
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Container), repr(x))
+ self.failUnless(issubclass(type(x), Container), repr(type(x)))
+
+ def test_Callable(self):
+ non_samples = [None, 42, 3.14, 1j,
+ "", b"", (), [], {}, set(),
+ (lambda: (yield))(),
+ (x for x in []),
+ ]
+ for x in non_samples:
+ self.failIf(isinstance(x, Callable), repr(x))
+ self.failIf(issubclass(type(x), Callable), repr(type(x)))
+ samples = [lambda: None,
+ type, int, object,
+ len,
+ list.append, [].append,
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Callable), repr(x))
+ self.failUnless(issubclass(type(x), Callable), repr(type(x)))
+
+ def test_direct_subclassing(self):
+ for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
+ class C(B):
+ pass
+ self.failUnless(issubclass(C, B))
+ self.failIf(issubclass(int, C))
+
+ def test_registration(self):
+ for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
+ class C:
+ __hash__ = None # Make sure it isn't hashable by default
+ self.failIf(issubclass(C, B), B.__name__)
+ B.register(C)
+ self.failUnless(issubclass(C, B))
+
+
+class TestCollectionABCs(unittest.TestCase):
+
+ # XXX For now, we only test some virtual inheritance properties.
+ # We should also test the proper behavior of the collection ABCs
+ # as real base classes or mix-in classes.
+
+ def test_Set(self):
+ for sample in [set, frozenset]:
+ self.failUnless(isinstance(sample(), Set))
+ self.failUnless(issubclass(sample, Set))
+
+ def test_MutableSet(self):
+ self.failUnless(isinstance(set(), MutableSet))
+ self.failUnless(issubclass(set, MutableSet))
+ self.failIf(isinstance(frozenset(), MutableSet))
+ self.failIf(issubclass(frozenset, MutableSet))
+
+ def test_Mapping(self):
+ for sample in [dict]:
+ self.failUnless(isinstance(sample(), Mapping))
+ self.failUnless(issubclass(sample, Mapping))
+
+ def test_MutableMapping(self):
+ for sample in [dict]:
+ self.failUnless(isinstance(sample(), MutableMapping))
+ self.failUnless(issubclass(sample, MutableMapping))
+
+ def test_Sequence(self):
+ for sample in [tuple, list, bytes, str]:
+ self.failUnless(isinstance(sample(), Sequence))
+ self.failUnless(issubclass(sample, Sequence))
+ self.failUnless(issubclass(basestring, Sequence))
+
+ def test_MutableSequence(self):
+ for sample in [tuple, str]:
+ self.failIf(isinstance(sample(), MutableSequence))
+ self.failIf(issubclass(sample, MutableSequence))
+ for sample in [list, bytes]:
+ self.failUnless(isinstance(sample(), MutableSequence))
+ self.failUnless(issubclass(sample, MutableSequence))
+ self.failIf(issubclass(basestring, MutableSequence))
+
+
def test_main(verbose=None):
import collections as CollectionsModule
- test_classes = [TestNamedTuple]
+ test_classes = [TestNamedTuple, TestOneTrickPonyABCs, TestCollectionABCs]
test_support.run_unittest(*test_classes)
test_support.run_doctest(CollectionsModule, verbose)
+
if __name__ == "__main__":
test_main(verbose=True)
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 4e29eab..b5949fd 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -36,6 +36,9 @@
def test_syntax_error(self):
self.assertRaises(SyntaxError, compile, "1+*3", "filename", "exec")
+ def test_none_keyword_arg(self):
+ self.assertRaises(SyntaxError, compile, "f(None=1)", "<string>", "exec")
+
def test_duplicate_global_local(self):
try:
exec('def f(a): global a; a = 1')
@@ -158,21 +161,22 @@
def test_literals_with_leading_zeroes(self):
for arg in ["077787", "0xj", "0x.", "0e", "090000000000000",
- "080000000000000", "000000000000009", "000000000000008"]:
+ "080000000000000", "000000000000009", "000000000000008",
+ "0b42", "0BADCAFE", "0o123456789", "0b1.1", "0o4.2",
+ "0b101j2", "0o153j2", "0b100e1", "0o777e1", "0777",
+ "000777", "000000000000007"]:
self.assertRaises(SyntaxError, eval, arg)
- self.assertEqual(eval("0777"), 511)
- self.assertEqual(eval("000777"), 511)
self.assertEqual(eval("0xff"), 255)
- self.assertEqual(eval("0XfF"), 255)
self.assertEqual(eval("0777."), 777)
self.assertEqual(eval("0777.0"), 777)
self.assertEqual(eval("000000000000000000000000000000000000000000000000000777e0"), 777)
self.assertEqual(eval("0777e1"), 7770)
self.assertEqual(eval("0e0"), 0)
- self.assertEqual(eval("0000E-012"), 0)
+ self.assertEqual(eval("0000e-012"), 0)
self.assertEqual(eval("09.5"), 9.5)
self.assertEqual(eval("0777j"), 777j)
+ self.assertEqual(eval("000"), 0)
self.assertEqual(eval("00j"), 0j)
self.assertEqual(eval("00.0"), 0)
self.assertEqual(eval("0e3"), 0)
@@ -181,9 +185,12 @@
self.assertEqual(eval("090000000000000e0"), 90000000000000.)
self.assertEqual(eval("090000000000000e-0"), 90000000000000.)
self.assertEqual(eval("090000000000000j"), 90000000000000j)
- self.assertEqual(eval("000000000000007"), 7)
self.assertEqual(eval("000000000000008."), 8.)
self.assertEqual(eval("000000000000009."), 9.)
+ self.assertEqual(eval("0b101010"), 42)
+ self.assertEqual(eval("-0b000000000010"), -2)
+ self.assertEqual(eval("0o777"), 511)
+ self.assertEqual(eval("-0o0000010"), -8)
def test_unary_minus(self):
# Verify treatment of unary minus on negative numbers SF bug #660455
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index bcbd096..7dc8442 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -2126,17 +2126,14 @@
class octlong(int):
__slots__ = []
def __str__(self):
- s = oct(self)
- if s[-1] == 'L':
- s = s[:-1]
- return s
+ return oct(self)
def __add__(self, other):
return self.__class__(super(octlong, self).__add__(other))
__radd__ = __add__
- vereq(str(octlong(3) + 5), "010")
+ vereq(str(octlong(3) + 5), "0o10")
# (Note that overriding __radd__ here only seems to work
# because the example uses a short int left argument.)
- vereq(str(5 + octlong(3000)), "05675")
+ vereq(str(5 + octlong(3000)), "0o5675")
a = octlong(12345)
vereq(a, 12345)
vereq(int(a), 12345)
diff --git a/Lib/test/test_dumbdbm.py b/Lib/test/test_dumbdbm.py
index c7d29ec..d03d861 100644
--- a/Lib/test/test_dumbdbm.py
+++ b/Lib/test/test_dumbdbm.py
@@ -45,17 +45,17 @@
return
try:
- old_umask = os.umask(0002)
- f = dumbdbm.open(_fname, 'c', 0637)
+ old_umask = os.umask(0o002)
+ f = dumbdbm.open(_fname, 'c', 0o637)
f.close()
finally:
os.umask(old_umask)
- expected_mode = 0635
+ expected_mode = 0o635
if os.name != 'posix':
# Windows only supports setting the read-only attribute.
# This shouldn't fail, but doesn't work like Unix either.
- expected_mode = 0666
+ expected_mode = 0o666
import stat
st = os.stat(_fname + '.dat')
diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py
index ace1f1f..085768d 100644
--- a/Lib/test/test_format.py
+++ b/Lib/test/test_format.py
@@ -121,7 +121,7 @@
# same, except no 0 flag
testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345")
-big = 012345670123456701234567012345670 # 32 octal digits
+big = 0o12345670123456701234567012345670 # 32 octal digits
testboth("%o", big, "12345670123456701234567012345670")
testboth("%o", -big, "-12345670123456701234567012345670")
testboth("%5o", -big, "-12345670123456701234567012345670")
@@ -141,33 +141,36 @@
testboth("%34.33o", big, " 012345670123456701234567012345670")
testboth("%-34.33o", big, "012345670123456701234567012345670 ")
testboth("%o", big, "12345670123456701234567012345670")
-testboth("%#o", big, "012345670123456701234567012345670")
-testboth("%#o", -big, "-012345670123456701234567012345670")
-testboth("%#.34o", -big, "-0012345670123456701234567012345670")
-testboth("%#+.34o", big, "+0012345670123456701234567012345670")
-testboth("%# .34o", big, " 0012345670123456701234567012345670")
-testboth("%#+.34o", big, "+0012345670123456701234567012345670")
-testboth("%#-+.34o", big, "+0012345670123456701234567012345670")
-testboth("%#-+37.34o", big, "+0012345670123456701234567012345670 ")
-testboth("%#+37.34o", big, " +0012345670123456701234567012345670")
+testboth("%#o", big, "0o12345670123456701234567012345670")
+testboth("%#o", -big, "-0o12345670123456701234567012345670")
+testboth("%#.34o", -big, "-0o0012345670123456701234567012345670")
+testboth("%#+.34o", big, "+0o0012345670123456701234567012345670")
+testboth("%# .34o", big, " 0o0012345670123456701234567012345670")
+testboth("%#-+.34o", big, "+0o0012345670123456701234567012345670")
+testboth("%#-+39.34o", big, "+0o0012345670123456701234567012345670 ")
+testboth("%#+39.34o", big, " +0o0012345670123456701234567012345670")
# next one gets one leading zero from precision
testboth("%.33o", big, "012345670123456701234567012345670")
-# base marker shouldn't change that, since "0" is redundant
-testboth("%#.33o", big, "012345670123456701234567012345670")
-# but reduce precision, and base marker should add a zero
-testboth("%#.32o", big, "012345670123456701234567012345670")
-# one leading zero from precision, and another from "0" flag & width
+# one leading zero from precision
+testboth("%#.33o", big, "0o012345670123456701234567012345670")
+# leading zero vanishes
+testboth("%#.32o", big, "0o12345670123456701234567012345670")
+# one leading zero from precision, and another from '0' flag & width
testboth("%034.33o", big, "0012345670123456701234567012345670")
-# base marker shouldn't change that
-testboth("%0#34.33o", big, "0012345670123456701234567012345670")
+# max width includes base marker; padding zeroes come after marker
+testboth("%0#38.33o", big, "0o000012345670123456701234567012345670")
+# padding spaces come before marker
+testboth("%#36.33o", big, " 0o012345670123456701234567012345670")
# Some small ints, in both Python int and long flavors).
testboth("%d", 42, "42")
testboth("%d", -42, "-42")
testboth("%#x", 1, "0x1")
testboth("%#X", 1, "0X1")
-testboth("%#o", 1, "01")
-testboth("%#o", 0, "0")
+testboth("%#o", 1, "0o1")
+testboth("%#o", 1, "0o1")
+testboth("%#o", 0, "0o0")
+testboth("%#o", 0, "0o0")
testboth("%o", 0, "0")
testboth("%d", 0, "0")
testboth("%#x", 0, "0x0")
@@ -176,8 +179,10 @@
testboth("%x", 0x42, "42")
testboth("%x", -0x42, "-42")
-testboth("%o", 042, "42")
-testboth("%o", -042, "-42")
+testboth("%o", 0o42, "42")
+testboth("%o", -0o42, "-42")
+testboth("%o", 0o42, "42")
+testboth("%o", -0o42, "-42")
# Test exception for unknown format characters
if verbose:
@@ -216,14 +221,6 @@
test_exc('no format', '1', TypeError,
"not all arguments converted during string formatting")
-class Foobar(int):
- def __oct__(self):
- # Returning a non-string should not blow up.
- return self + 1
-
-test_exc('%o', Foobar(), TypeError,
- "expected string, int found")
-
if maxsize == 2**31-1:
# crashes 2.2.1 and earlier:
try:
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index 711d636..8f45382 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -27,26 +27,32 @@
self.assertEquals(x, 0, 'backslash ending comment')
def testPlainIntegers(self):
+ self.assertEquals(type(000), type(0))
self.assertEquals(0xff, 255)
- self.assertEquals(0377, 255)
- self.assertEquals(2147483647, 017777777777)
+ self.assertEquals(0o377, 255)
+ self.assertEquals(2147483647, 0o17777777777)
+ self.assertEquals(0b1001, 9)
from sys import maxint
if maxint == 2147483647:
- self.assertEquals(-2147483647-1, -020000000000)
+ self.assertEquals(-2147483647-1, -0o20000000000)
# XXX -2147483648
- self.assert_(037777777777 > 0)
+ self.assert_(0o37777777777 > 0)
self.assert_(0xffffffff > 0)
- for s in '2147483648', '040000000000', '0x100000000':
+ self.assert_(0b1111111111111111111111111111111 > 0)
+ for s in ('2147483648', '0o40000000000', '0x100000000',
+ '0b10000000000000000000000000000000'):
try:
x = eval(s)
except OverflowError:
self.fail("OverflowError on huge integer literal %r" % s)
elif maxint == 9223372036854775807:
- self.assertEquals(-9223372036854775807-1, -01000000000000000000000)
- self.assert_(01777777777777777777777 > 0)
+ self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000)
+ self.assert_(0o1777777777777777777777 > 0)
self.assert_(0xffffffffffffffff > 0)
- for s in '9223372036854775808', '02000000000000000000000', \
- '0x10000000000000000':
+ self.assert_(0b11111111111111111111111111111111111111111111111111111111111111 > 0)
+ for s in '9223372036854775808', '0o2000000000000000000000', \
+ '0x10000000000000000', \
+ '0b100000000000000000000000000000000000000000000000000000000000000':
try:
x = eval(s)
except OverflowError:
@@ -56,13 +62,13 @@
def testLongIntegers(self):
x = 0
- x = 0
x = 0xffffffffffffffff
- x = 0xffffffffffffffff
- x = 077777777777777777
- x = 077777777777777777
+ x = 0Xffffffffffffffff
+ x = 0o77777777777777777
+ x = 0O77777777777777777
x = 123456789012345678901234567890
- x = 123456789012345678901234567890
+ x = 0b100000000000000000000000000000000000000000000000000000000000000000000
+ x = 0B111111111111111111111111111111111111111111111111111111111111111111111
def testFloats(self):
x = 3.14
diff --git a/Lib/test/test_hexoct.py b/Lib/test/test_hexoct.py
index 5e86bea..afd696a 100644
--- a/Lib/test/test_hexoct.py
+++ b/Lib/test/test_hexoct.py
@@ -65,49 +65,49 @@
def test_oct_baseline(self):
# Baseline tests
self.assertEqual(00, 0)
- self.assertEqual(020, 16)
+ self.assertEqual(0o20, 16)
if platform_long_is_32_bits:
- self.assertEqual(017777777777, 2147483647)
+ self.assertEqual(0o17777777777, 2147483647)
else:
- self.assertEqual(0777777777777777777777, 9223372036854775807)
+ self.assertEqual(0o777777777777777777777, 9223372036854775807)
# Ditto with a minus sign and parentheses
self.assertEqual(-(00), 0)
- self.assertEqual(-(020), -16)
+ self.assertEqual(-(0o20), -16)
if platform_long_is_32_bits:
- self.assertEqual(-(017777777777), -2147483647)
+ self.assertEqual(-(0o17777777777), -2147483647)
else:
- self.assertEqual(-(0777777777777777777777), -9223372036854775807)
+ self.assertEqual(-(0o777777777777777777777), -9223372036854775807)
# Ditto with a minus sign and NO parentheses
self.assertEqual(-00, 0)
- self.assertEqual(-020, -16)
+ self.assertEqual(-0o20, -16)
if platform_long_is_32_bits:
- self.assertEqual(-017777777777, -2147483647)
+ self.assertEqual(-0o17777777777, -2147483647)
else:
- self.assertEqual(-0777777777777777777777, -9223372036854775807)
+ self.assertEqual(-0o777777777777777777777, -9223372036854775807)
def test_oct_unsigned(self):
if platform_long_is_32_bits:
# Positive constants
- self.assertEqual(020000000000, 2147483648)
- self.assertEqual(037777777777, 4294967295)
+ self.assertEqual(0o20000000000, 2147483648)
+ self.assertEqual(0o37777777777, 4294967295)
# Ditto with a minus sign and parentheses
- self.assertEqual(-(020000000000), -2147483648)
- self.assertEqual(-(037777777777), -4294967295)
+ self.assertEqual(-(0o20000000000), -2147483648)
+ self.assertEqual(-(0o37777777777), -4294967295)
# Ditto with a minus sign and NO parentheses
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
- self.assertEqual(-020000000000, -2147483648)
- self.assertEqual(-037777777777, -4294967295)
+ self.assertEqual(-0o20000000000, -2147483648)
+ self.assertEqual(-0o37777777777, -4294967295)
else:
# Positive constants
- self.assertEqual(01000000000000000000000, 9223372036854775808)
- self.assertEqual(01777777777777777777777, 18446744073709551615)
+ self.assertEqual(0o1000000000000000000000, 9223372036854775808)
+ self.assertEqual(0o1777777777777777777777, 18446744073709551615)
# Ditto with a minus sign and parentheses
- self.assertEqual(-(01000000000000000000000), -9223372036854775808)
- self.assertEqual(-(01777777777777777777777), -18446744073709551615)
+ self.assertEqual(-(0o1000000000000000000000), -9223372036854775808)
+ self.assertEqual(-(0o1777777777777777777777), -18446744073709551615)
# Ditto with a minus sign and NO parentheses
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
- self.assertEqual(-01000000000000000000000, -9223372036854775808)
- self.assertEqual(-01777777777777777777777, -18446744073709551615)
+ self.assertEqual(-0o1000000000000000000000, -9223372036854775808)
+ self.assertEqual(-0o1777777777777777777777, -18446744073709551615)
def test_main():
test_support.run_unittest(TextHexOct)
diff --git a/Lib/test/test_list.py b/Lib/test/test_list.py
index ea78773..f7f561a 100644
--- a/Lib/test/test_list.py
+++ b/Lib/test/test_list.py
@@ -5,7 +5,7 @@
type2test = list
def test_truth(self):
- super(ListTest, self).test_truth()
+ super().test_truth()
self.assert_(not [])
self.assert_([42])
@@ -13,7 +13,7 @@
self.assert_([] is not [])
def test_len(self):
- super(ListTest, self).test_len()
+ super().test_len()
self.assertEqual(len([]), 0)
self.assertEqual(len([0]), 1)
self.assertEqual(len([0, 1, 2]), 3)
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
index c38056d..9e56d31 100644
--- a/Lib/test/test_long.py
+++ b/Lib/test/test_long.py
@@ -195,9 +195,6 @@
self.check_bitop_identities_3(x, y, self.getran((lenx + leny)//2))
def slow_format(self, x, base):
- if (x, base) == (0, 8):
- # this is an oddball!
- return "0"
digits = []
sign = 0
if x < 0:
@@ -208,7 +205,7 @@
digits.reverse()
digits = digits or [0]
return '-'[:sign] + \
- {8: '0', 10: '', 16: '0x'}[base] + \
+ {2: '0b', 8: '0o', 10: '', 16: '0x'}[base] + \
"".join(map(lambda i: "0123456789abcdef"[i], digits))
def check_format_1(self, x):
diff --git a/Lib/test/test_multibytecodec.py b/Lib/test/test_multibytecodec.py
index f41ad34..472f620 100644
--- a/Lib/test/test_multibytecodec.py
+++ b/Lib/test/test_multibytecodec.py
@@ -136,6 +136,16 @@
self.assertRaises(UnicodeDecodeError, decoder.decode, '', True)
self.assertEqual(decoder.decode('B@$'), '\u4e16')
+class Test_StreamReader(unittest.TestCase):
+ def test_bug1728403(self):
+ try:
+ open(TESTFN, 'w').write('\xa1')
+ f = codecs.open(TESTFN, encoding='cp949')
+ self.assertRaises(UnicodeDecodeError, f.read, 2)
+ finally:
+ try: f.close()
+ except: pass
+ os.unlink(TESTFN)
class Test_StreamWriter(unittest.TestCase):
if len('\U00012345') == 2: # UCS2
diff --git a/Lib/test/test_peepholer.py b/Lib/test/test_peepholer.py
index b290198..28ad055 100644
--- a/Lib/test/test_peepholer.py
+++ b/Lib/test/test_peepholer.py
@@ -39,16 +39,24 @@
asm = dis_single(line)
self.assert_(elem in asm)
- def test_none_as_constant(self):
- # LOAD_GLOBAL None --> LOAD_CONST None
+ def test_global_as_constant(self):
+ # LOAD_GLOBAL None/True/False --> LOAD_CONST None/True/False
def f(x):
None
+ None
return x
- asm = disassemble(f)
- for elem in ('LOAD_GLOBAL',):
- self.assert_(elem not in asm)
- for elem in ('LOAD_CONST', '(None)'):
- self.assert_(elem in asm)
+ def g(x):
+ True
+ return x
+ def h(x):
+ False
+ return x
+ for func, name in ((f, 'None'), (g, 'True'), (h, 'False')):
+ asm = disassemble(func)
+ for elem in ('LOAD_GLOBAL',):
+ self.assert_(elem not in asm)
+ for elem in ('LOAD_CONST', '('+name+')'):
+ self.assert_(elem in asm)
def f():
'Adding a docstring made this test fail in Py2.5.0'
return None
diff --git a/Lib/test/test_pep352.py b/Lib/test/test_pep352.py
index 90766ba..dc47737 100644
--- a/Lib/test/test_pep352.py
+++ b/Lib/test/test_pep352.py
@@ -131,22 +131,22 @@
"""Catching 'object_' should raise a TypeError."""
try:
try:
- raise StandardError
+ raise Exception
except object_:
pass
except TypeError:
pass
- except StandardError:
+ except Exception:
self.fail("TypeError expected when catching %s" % type(object_))
try:
try:
- raise StandardError
+ raise Exception
except (object_,):
pass
except TypeError:
return
- except StandardError:
+ except Exception:
self.fail("TypeError expected when catching %s as specified in a "
"tuple" % type(object_))
diff --git a/Lib/test/test_repr.py b/Lib/test/test_repr.py
index 5059c08..d4db894 100644
--- a/Lib/test/test_repr.py
+++ b/Lib/test/test_repr.py
@@ -10,6 +10,7 @@
from test.test_support import run_unittest
from repr import repr as r # Don't shadow builtin repr
+from repr import Repr
def nestedTuple(nesting):
@@ -34,6 +35,18 @@
expected = repr(s)[:13] + "..." + repr(s)[-14:]
eq(r(s), expected)
+ def test_tuple(self):
+ eq = self.assertEquals
+ eq(r((1,)), "(1,)")
+
+ t3 = (1, 2, 3)
+ eq(r(t3), "(1, 2, 3)")
+
+ r2 = Repr()
+ r2.maxtuple = 2
+ expected = repr(t3)[:-2] + "...)"
+ eq(r2.repr(t3), expected)
+
def test_container(self):
from array import array
from collections import deque
diff --git a/Lib/test/test_str.py b/Lib/test/test_str.py
index 6fa3779..2ef01f0 100644
--- a/Lib/test/test_str.py
+++ b/Lib/test/test_str.py
@@ -1,4 +1,7 @@
+
import unittest
+import struct
+import sys
from test import test_support, string_tests
@@ -88,6 +91,15 @@
self.assertEqual(str8(Foo9("foo")), "string")
self.assertEqual(str(Foo9("foo")), "not unicode")
+ def test_expandtabs_overflows_gracefully(self):
+ # This test only affects 32-bit platforms because expandtabs can only take
+ # an int as the max value, not a 64-bit C long. If expandtabs is changed
+ # to take a 64-bit long, this test should apply to all platforms.
+ if sys.maxint > (1 << 32) or struct.calcsize('P') != 4:
+ return
+ self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxint)
+
+
def test_main():
test_support.run_unittest(StrTest)
diff --git a/Lib/test/test_strptime.py b/Lib/test/test_strptime.py
index 0e1909e..81f8392 100644
--- a/Lib/test/test_strptime.py
+++ b/Lib/test/test_strptime.py
@@ -190,6 +190,15 @@
"locale data that contains regex metacharacters is not"
" properly escaped")
+ def test_whitespace_substitution(self):
+ # When pattern contains whitespace, make sure it is taken into account
+ # so as to not allow to subpatterns to end up next to each other and
+ # "steal" characters from each other.
+ pattern = self.time_re.pattern('%j %H')
+ self.failUnless(not re.match(pattern, "180"))
+ self.failUnless(re.match(pattern, "18 0"))
+
+
class StrptimeTests(unittest.TestCase):
"""Tests for _strptime.strptime."""
@@ -463,8 +472,8 @@
"of the year")
test_helper((1917, 12, 31), "Dec 31 on Monday with year starting and "
"ending on Monday")
- test_helper((2007, 01, 07), "First Sunday of 2007")
- test_helper((2007, 01, 14), "Second Sunday of 2007")
+ test_helper((2007, 1, 7), "First Sunday of 2007")
+ test_helper((2007, 1, 14), "Second Sunday of 2007")
test_helper((2006, 12, 31), "Last Sunday of 2006")
test_helper((2006, 12, 24), "Second to last Sunday of 2006")
diff --git a/Lib/test/test_structmembers.py b/Lib/test/test_structmembers.py
index 599c6fb..c3d01c8 100644
--- a/Lib/test/test_structmembers.py
+++ b/Lib/test/test_structmembers.py
@@ -2,7 +2,8 @@
CHAR_MAX, CHAR_MIN, UCHAR_MAX, \
SHRT_MAX, SHRT_MIN, USHRT_MAX, \
INT_MAX, INT_MIN, UINT_MAX, \
- LONG_MAX, LONG_MIN, ULONG_MAX
+ LONG_MAX, LONG_MIN, ULONG_MAX, \
+ LLONG_MAX, LLONG_MIN, ULLONG_MAX
import warnings, unittest
from test import test_support
@@ -39,6 +40,23 @@
ts.T_ULONG=ULONG_MAX
self.assertEquals(ts.T_ULONG, ULONG_MAX)
+ ## T_LONGLONG and T_ULONGLONG may not be present on some platforms
+ if hasattr(ts, 'T_LONGLONG'):
+ ts.T_LONGLONG=LLONG_MAX
+ self.assertEquals(ts.T_LONGLONG, LLONG_MAX)
+ ts.T_LONGLONG=LLONG_MIN
+ self.assertEquals(ts.T_LONGLONG, LLONG_MIN)
+
+ ts.T_ULONGLONG=ULLONG_MAX
+ self.assertEquals(ts.T_ULONGLONG, ULLONG_MAX)
+
+ ## make sure these will accept a plain int as well as a long
+ ts.T_LONGLONG=3
+ self.assertEquals(ts.T_LONGLONG, 3)
+ ts.T_ULONGLONG=4
+ self.assertEquals(ts.T_ULONGLONG, 4)
+
+
class TestWarnings(unittest.TestCase):
def has_warned(self, w):
self.assert_(w.category is RuntimeWarning)
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index b44e83a..2421a6b 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -528,7 +528,7 @@
os.write(f, "exec %s -c 'import sys; sys.exit(47)'\n" %
sys.executable)
os.close(f)
- os.chmod(fname, 0700)
+ os.chmod(fname, 0o700)
p = subprocess.Popen(fname)
p.wait()
os.remove(fname)
@@ -570,7 +570,7 @@
os.write(f, "exec %s -c 'import sys; sys.exit(47)'\n" %
sys.executable)
os.close(f)
- os.chmod(fname, 0700)
+ os.chmod(fname, 0o700)
rc = subprocess.call(fname)
os.remove(fname)
self.assertEqual(rc, 47)
diff --git a/Lib/test/test_sundry.py b/Lib/test/test_sundry.py
index 3c0346d..28a08c5 100644
--- a/Lib/test/test_sundry.py
+++ b/Lib/test/test_sundry.py
@@ -1,6 +1,7 @@
"""Do a minimal test of all the modules that aren't otherwise tested."""
from test.test_support import guard_warnings_filter
+import sys
import warnings
with guard_warnings_filter():
@@ -18,6 +19,53 @@
import cmd
import code
import compileall
+
+ import distutils.archive_util
+ import distutils.bcppcompiler
+ import distutils.ccompiler
+ import distutils.cmd
+ import distutils.core
+ import distutils.cygwinccompiler
+ import distutils.dep_util
+ import distutils.dir_util
+ import distutils.emxccompiler
+ import distutils.errors
+ import distutils.extension
+ import distutils.file_util
+ import distutils.filelist
+ import distutils.log
+ if sys.platform.startswith('win'):
+ import distutils.msvccompiler
+ import distutils.mwerkscompiler
+ import distutils.sysconfig
+ import distutils.text_file
+ import distutils.unixccompiler
+ import distutils.util
+ import distutils.version
+
+ import distutils.command.bdist_dumb
+ if sys.platform.startswith('win'):
+ import distutils.command.bdist_msi
+ import distutils.command.bdist
+ import distutils.command.bdist_rpm
+ import distutils.command.bdist_wininst
+ import distutils.command.build_clib
+ import distutils.command.build_ext
+ import distutils.command.build
+ import distutils.command.build_py
+ import distutils.command.build_scripts
+ import distutils.command.clean
+ import distutils.command.config
+ import distutils.command.install_data
+ import distutils.command.install_egg_info
+ import distutils.command.install_headers
+ import distutils.command.install_lib
+ import distutils.command.install
+ import distutils.command.install_scripts
+ import distutils.command.register
+ import distutils.command.sdist
+ import distutils.command.upload
+
import encodings
import formatter
import ftplib
@@ -37,7 +85,6 @@
import os2emxpath
import pdb
import pipes
- #import poplib
import pstats
import py_compile
import pydoc
diff --git a/Lib/test/test_super.py b/Lib/test/test_super.py
new file mode 100644
index 0000000..fc303ea
--- /dev/null
+++ b/Lib/test/test_super.py
@@ -0,0 +1,79 @@
+"""Unit tests for new super() implementation."""
+
+import sys
+import unittest
+from test import test_support
+
+
+class A:
+ def f(self):
+ return 'A'
+ @classmethod
+ def cm(cls):
+ return (cls, 'A')
+
+class B(A):
+ def f(self):
+ return super().f() + 'B'
+ @classmethod
+ def cm(cls):
+ return (cls, super().cm(), 'B')
+
+class C(A):
+ def f(self):
+ return super().f() + 'C'
+ @classmethod
+ def cm(cls):
+ return (cls, super().cm(), 'C')
+
+class D(C, B):
+ def f(self):
+ return super().f() + 'D'
+ def cm(cls):
+ return (cls, super().cm(), 'D')
+
+class E(D):
+ pass
+
+class F(E):
+ f = E.f
+
+class G(A):
+ pass
+
+
+class TestSuper(unittest.TestCase):
+
+ def testBasicsWorking(self):
+ self.assertEqual(D().f(), 'ABCD')
+
+ def testClassGetattrWorking(self):
+ self.assertEqual(D.f(D()), 'ABCD')
+
+ def testSubclassNoOverrideWorking(self):
+ self.assertEqual(E().f(), 'ABCD')
+ self.assertEqual(E.f(E()), 'ABCD')
+
+ def testUnboundMethodTransferWorking(self):
+ self.assertEqual(F().f(), 'ABCD')
+ self.assertEqual(F.f(F()), 'ABCD')
+
+ def testClassMethodsStillWorking(self):
+ self.assertEqual(A.cm(), (A, 'A'))
+ self.assertEqual(A().cm(), (A, 'A'))
+ self.assertEqual(G.cm(), (G, 'A'))
+ self.assertEqual(G().cm(), (G, 'A'))
+
+ def testSuperInClassMethodsWorking(self):
+ d = D()
+ self.assertEqual(d.cm(), (d, (D, (D, (D, 'A'), 'B'), 'C'), 'D'))
+ e = E()
+ self.assertEqual(e.cm(), (e, (E, (E, (E, 'A'), 'B'), 'C'), 'D'))
+
+
+def test_main():
+ test_support.run_unittest(TestSuper)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/Lib/test/test_tarfile.py b/Lib/test/test_tarfile.py
index 39504e1..50c5bbe 100644
--- a/Lib/test/test_tarfile.py
+++ b/Lib/test/test_tarfile.py
@@ -164,7 +164,7 @@
def test_check_members(self):
for tarinfo in self.tar:
- self.assert_(int(tarinfo.mtime) == 07606136617,
+ self.assert_(int(tarinfo.mtime) == 0o7606136617,
"wrong mtime for %s" % tarinfo.name)
if not tarinfo.name.startswith("ustar/"):
continue
@@ -299,7 +299,7 @@
self.assert_(md5sum(self.tar.extractfile(tarinfo).read()) == chksum,
"wrong md5sum for %s" % tarinfo.name)
- kwargs["mtime"] = 07606136617
+ kwargs["mtime"] = 0o7606136617
kwargs["uid"] = 1000
kwargs["gid"] = 100
if "old-v7" not in tarinfo.name:
@@ -978,7 +978,7 @@
# uid > 8 digits
tarinfo = tarfile.TarInfo("name")
- tarinfo.uid = 010000000
+ tarinfo.uid = 0o10000000
self.assertRaises(ValueError, tarinfo.tobuf, tarfile.USTAR_FORMAT)
def test_gnu_limits(self):
@@ -991,7 +991,7 @@
# uid >= 256 ** 7
tarinfo = tarfile.TarInfo("name")
- tarinfo.uid = 04000000000000000000
+ tarinfo.uid = 0o4000000000000000000
self.assertRaises(ValueError, tarinfo.tobuf, tarfile.GNU_FORMAT)
def test_pax_limits(self):
@@ -1003,7 +1003,7 @@
tarinfo.tobuf(tarfile.PAX_FORMAT)
tarinfo = tarfile.TarInfo("name")
- tarinfo.uid = 04000000000000000000
+ tarinfo.uid = 0o4000000000000000000
tarinfo.tobuf(tarfile.PAX_FORMAT)
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index 8c2eb23..caa8f4e 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -264,7 +264,7 @@
file = self.do_create()
mode = stat.S_IMODE(os.stat(file.name).st_mode)
- expected = 0600
+ expected = 0o600
if sys.platform in ('win32', 'os2emx', 'mac'):
# There's no distinction among 'user', 'group' and 'world';
# replicate the 'user' bits.
@@ -482,8 +482,8 @@
dir = self.do_create()
try:
mode = stat.S_IMODE(os.stat(dir).st_mode)
- mode &= 0777 # Mask off sticky bits inherited from /tmp
- expected = 0700
+ mode &= 0o777 # Mask off sticky bits inherited from /tmp
+ expected = 0o700
if sys.platform in ('win32', 'os2emx', 'mac'):
# There's no distinction among 'user', 'group' and 'world';
# replicate the 'user' bits.
@@ -517,7 +517,7 @@
self.name = tempfile.mktemp(dir=dir, prefix=pre, suffix=suf)
# Create the file. This will raise an exception if it's
# mysteriously appeared in the meanwhile.
- os.close(os.open(self.name, self._bflags, 0600))
+ os.close(os.open(self.name, self._bflags, 0o600))
def __del__(self):
self._unlink(self.name)
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 95557c0..b76cea1 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -3,6 +3,7 @@
import test.test_support
from test.test_support import verbose
import random
+import sys
import threading
import thread
import time
@@ -201,8 +202,47 @@
t.join()
# else the thread is still running, and we have no way to kill it
+class ThreadingExceptionTests(unittest.TestCase):
+ # A RuntimeError should be raised if Thread.start() is called
+ # multiple times.
+ def test_start_thread_again(self):
+ thread = threading.Thread()
+ thread.start()
+ self.assertRaises(RuntimeError, thread.start)
+
+ def test_releasing_unacquired_rlock(self):
+ rlock = threading.RLock()
+ self.assertRaises(RuntimeError, rlock.release)
+
+ def test_waiting_on_unacquired_condition(self):
+ cond = threading.Condition()
+ self.assertRaises(RuntimeError, cond.wait)
+
+ def test_notify_on_unacquired_condition(self):
+ cond = threading.Condition()
+ self.assertRaises(RuntimeError, cond.notify)
+
+ def test_semaphore_with_negative_value(self):
+ self.assertRaises(ValueError, threading.Semaphore, value = -1)
+ self.assertRaises(ValueError, threading.Semaphore, value = -sys.maxint)
+
+ def test_joining_current_thread(self):
+ currentThread = threading.currentThread()
+ self.assertRaises(RuntimeError, currentThread.join);
+
+ def test_joining_inactive_thread(self):
+ thread = threading.Thread()
+ self.assertRaises(RuntimeError, thread.join)
+
+ def test_daemonize_active_thread(self):
+ thread = threading.Thread()
+ thread.start()
+ self.assertRaises(RuntimeError, thread.setDaemon, True)
+
+
def test_main():
- test.test_support.run_unittest(ThreadTests)
+ test.test_support.run_unittest(ThreadTests,
+ ThreadingExceptionTests)
if __name__ == "__main__":
test_main()
diff --git a/Lib/test/test_tuple.py b/Lib/test/test_tuple.py
index 00dcd39..1da0ef3 100644
--- a/Lib/test/test_tuple.py
+++ b/Lib/test/test_tuple.py
@@ -5,30 +5,30 @@
type2test = tuple
def test_constructors(self):
- super(TupleTest, self).test_len()
+ super().test_len()
# calling built-in types without argument must return empty
self.assertEqual(tuple(), ())
def test_truth(self):
- super(TupleTest, self).test_truth()
+ super().test_truth()
self.assert_(not ())
self.assert_((42, ))
def test_len(self):
- super(TupleTest, self).test_len()
+ super().test_len()
self.assertEqual(len(()), 0)
self.assertEqual(len((0,)), 1)
self.assertEqual(len((0, 1, 2)), 3)
def test_iadd(self):
- super(TupleTest, self).test_iadd()
+ super().test_iadd()
u = (0, 1)
u2 = u
u += (2, 3)
self.assert_(u is not u2)
def test_imul(self):
- super(TupleTest, self).test_imul()
+ super().test_imul()
u = (0, 1)
u2 = u
u *= 3
diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py
index 76674d5..fbad984 100644
--- a/Lib/test/test_unicode.py
+++ b/Lib/test/test_unicode.py
@@ -6,7 +6,7 @@
(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
"""#"
-import unittest, sys, codecs, new
+import unittest, sys, struct, codecs, new
from test import test_support, string_tests
# Error handling (bad decoder return)
@@ -785,8 +785,13 @@
self.assertEqual(repr(s1()), '\\n')
self.assertEqual(repr(s2()), '\\n')
-
-
+ def test_expandtabs_overflows_gracefully(self):
+ # This test only affects 32-bit platforms because expandtabs can only take
+ # an int as the max value, not a 64-bit C long. If expandtabs is changed
+ # to take a 64-bit long, this test should apply to all platforms.
+ if sys.maxint > (1 << 32) or struct.calcsize('P') != 4:
+ return
+ self.assertRaises(OverflowError, u't\tt\t'.expandtabs, sys.maxint)
def test_main():
diff --git a/Lib/test/test_unicode_file.py b/Lib/test/test_unicode_file.py
index 2fc64cd..9cf48df 100644
--- a/Lib/test/test_unicode_file.py
+++ b/Lib/test/test_unicode_file.py
@@ -48,7 +48,7 @@
self.failUnless(os.path.exists(os.path.abspath(filename)))
self.failUnless(os.path.isfile(os.path.abspath(filename)))
self.failUnless(os.access(os.path.abspath(filename), os.R_OK))
- os.chmod(filename, 0777)
+ os.chmod(filename, 0o777)
os.utime(filename, None)
os.utime(filename, (time.time(), time.time()))
# Copy/rename etc tests using the same filename
diff --git a/Lib/test/test_unittest.py b/Lib/test/test_unittest.py
index 327d65f..98066e4 100644
--- a/Lib/test/test_unittest.py
+++ b/Lib/test/test_unittest.py
@@ -16,23 +16,23 @@
class LoggingResult(unittest.TestResult):
def __init__(self, log):
self._events = log
- super(LoggingResult, self).__init__()
+ super().__init__()
def startTest(self, test):
self._events.append('startTest')
- super(LoggingResult, self).startTest(test)
+ super().startTest(test)
def stopTest(self, test):
self._events.append('stopTest')
- super(LoggingResult, self).stopTest(test)
+ super().stopTest(test)
def addFailure(self, *args):
self._events.append('addFailure')
- super(LoggingResult, self).addFailure(*args)
+ super().addFailure(*args)
def addError(self, *args):
self._events.append('addError')
- super(LoggingResult, self).addError(*args)
+ super().addError(*args)
class TestEquality(object):
# Check for a valid __eq__ implementation
diff --git a/Lib/test/test_urllib2.py b/Lib/test/test_urllib2.py
index 10d8c46..dbcfe26 100644
--- a/Lib/test/test_urllib2.py
+++ b/Lib/test/test_urllib2.py
@@ -544,7 +544,7 @@
class NullFTPHandler(urllib2.FTPHandler):
def __init__(self, data): self.data = data
- def connect_ftp(self, user, passwd, host, port, dirs):
+ def connect_ftp(self, user, passwd, host, port, dirs, timeout=None):
self.user, self.passwd = user, passwd
self.host, self.port = host, port
self.dirs = dirs
@@ -567,7 +567,9 @@
"localhost", ftplib.FTP_PORT, "A",
[], "baz.gif", None), # XXX really this should guess image/gif
]:
- r = h.ftp_open(Request(url))
+ req = Request(url)
+ req.timeout = None
+ r = h.ftp_open(req)
# ftp authentication not yet implemented by FTPHandler
self.assert_(h.user == h.passwd == "")
self.assertEqual(h.host, socket.gethostbyname(host))
@@ -682,8 +684,9 @@
self.req_headers = []
self.data = None
self.raise_on_endheaders = False
- def __call__(self, host):
+ def __call__(self, host, timeout=None):
self.host = host
+ self.timeout = timeout
return self
def set_debuglevel(self, level):
self.level = level
@@ -706,6 +709,7 @@
url = "http://example.com/"
for method, data in [("GET", None), ("POST", "blah")]:
req = Request(url, data, {"Foo": "bar"})
+ req.timeout = None
req.add_unredirected_header("Spam", "eggs")
http = MockHTTPClass()
r = h.do_open(http, req)
diff --git a/Lib/test/test_urllib2_localnet.py b/Lib/test/test_urllib2_localnet.py
new file mode 100644
index 0000000..737ecbd
--- /dev/null
+++ b/Lib/test/test_urllib2_localnet.py
@@ -0,0 +1,310 @@
+#!/usr/bin/env python
+
+import sys
+import threading
+import urlparse
+import urllib2
+import BaseHTTPServer
+import unittest
+import hashlib
+from test import test_support
+
+# Loopback http server infrastructure
+
+class LoopbackHttpServer(BaseHTTPServer.HTTPServer):
+ """HTTP server w/ a few modifications that make it useful for
+ loopback testing purposes.
+ """
+
+ def __init__(self, server_address, RequestHandlerClass):
+ BaseHTTPServer.HTTPServer.__init__(self,
+ server_address,
+ RequestHandlerClass)
+
+ # Set the timeout of our listening socket really low so
+ # that we can stop the server easily.
+ self.socket.settimeout(1.0)
+
+ def get_request(self):
+ """BaseHTTPServer method, overridden."""
+
+ request, client_address = self.socket.accept()
+
+ # It's a loopback connection, so setting the timeout
+ # really low shouldn't affect anything, but should make
+ # deadlocks less likely to occur.
+ request.settimeout(10.0)
+
+ return (request, client_address)
+
+class LoopbackHttpServerThread(threading.Thread):
+ """Stoppable thread that runs a loopback http server."""
+
+ def __init__(self, port, RequestHandlerClass):
+ threading.Thread.__init__(self)
+ self._RequestHandlerClass = RequestHandlerClass
+ self._stop = False
+ self._port = port
+ self._server_address = ('127.0.0.1', self._port)
+ self.ready = threading.Event()
+ self.error = None
+
+ def stop(self):
+ """Stops the webserver if it's currently running."""
+
+ # Set the stop flag.
+ self._stop = True
+
+ self.join()
+
+ def run(self):
+ protocol = "HTTP/1.0"
+
+ try:
+ self._RequestHandlerClass.protocol_version = protocol
+ httpd = LoopbackHttpServer(self._server_address,
+ self._RequestHandlerClass)
+
+ sa = httpd.socket.getsockname()
+ #print "Serving HTTP on", sa[0], "port", sa[1], "..."
+ except:
+ # Fail "gracefully" if we are unable to start.
+ self.ready.set()
+ self.error = sys.exc_info()[1]
+ raise
+
+ self.ready.set()
+ while not self._stop:
+ httpd.handle_request()
+
+# Authentication infrastructure
+
+class DigestAuthHandler:
+ """Handler for performing digest authentication."""
+
+ def __init__(self):
+ self._request_num = 0
+ self._nonces = []
+ self._users = {}
+ self._realm_name = "Test Realm"
+ self._qop = "auth"
+
+ def set_qop(self, qop):
+ self._qop = qop
+
+ def set_users(self, users):
+ assert isinstance(users, dict)
+ self._users = users
+
+ def set_realm(self, realm):
+ self._realm_name = realm
+
+ def _generate_nonce(self):
+ self._request_num += 1
+ nonce = hashlib.md5(str(self._request_num)).hexdigest()
+ self._nonces.append(nonce)
+ return nonce
+
+ def _create_auth_dict(self, auth_str):
+ first_space_index = auth_str.find(" ")
+ auth_str = auth_str[first_space_index+1:]
+
+ parts = auth_str.split(",")
+
+ auth_dict = {}
+ for part in parts:
+ name, value = part.split("=")
+ name = name.strip()
+ if value[0] == '"' and value[-1] == '"':
+ value = value[1:-1]
+ else:
+ value = value.strip()
+ auth_dict[name] = value
+ return auth_dict
+
+ def _validate_auth(self, auth_dict, password, method, uri):
+ final_dict = {}
+ final_dict.update(auth_dict)
+ final_dict["password"] = password
+ final_dict["method"] = method
+ final_dict["uri"] = uri
+ HA1_str = "%(username)s:%(realm)s:%(password)s" % final_dict
+ HA1 = hashlib.md5(HA1_str).hexdigest()
+ HA2_str = "%(method)s:%(uri)s" % final_dict
+ HA2 = hashlib.md5(HA2_str).hexdigest()
+ final_dict["HA1"] = HA1
+ final_dict["HA2"] = HA2
+ response_str = "%(HA1)s:%(nonce)s:%(nc)s:" \
+ "%(cnonce)s:%(qop)s:%(HA2)s" % final_dict
+ response = hashlib.md5(response_str).hexdigest()
+
+ return response == auth_dict["response"]
+
+ def _return_auth_challenge(self, request_handler):
+ request_handler.send_response(407, "Proxy Authentication Required")
+ request_handler.send_header("Content-Type", "text/html")
+ request_handler.send_header(
+ 'Proxy-Authenticate', 'Digest realm="%s", '
+ 'qop="%s",'
+ 'nonce="%s", ' % \
+ (self._realm_name, self._qop, self._generate_nonce()))
+ # XXX: Not sure if we're supposed to add this next header or
+ # not.
+ #request_handler.send_header('Connection', 'close')
+ request_handler.end_headers()
+ request_handler.wfile.write("Proxy Authentication Required.")
+ return False
+
+ def handle_request(self, request_handler):
+ """Performs digest authentication on the given HTTP request
+ handler. Returns True if authentication was successful, False
+ otherwise.
+
+ If no users have been set, then digest auth is effectively
+ disabled and this method will always return True.
+ """
+
+ if len(self._users) == 0:
+ return True
+
+ if 'Proxy-Authorization' not in request_handler.headers:
+ return self._return_auth_challenge(request_handler)
+ else:
+ auth_dict = self._create_auth_dict(
+ request_handler.headers['Proxy-Authorization']
+ )
+ if auth_dict["username"] in self._users:
+ password = self._users[ auth_dict["username"] ]
+ else:
+ return self._return_auth_challenge(request_handler)
+ if not auth_dict.get("nonce") in self._nonces:
+ return self._return_auth_challenge(request_handler)
+ else:
+ self._nonces.remove(auth_dict["nonce"])
+
+ auth_validated = False
+
+ # MSIE uses short_path in its validation, but Python's
+ # urllib2 uses the full path, so we're going to see if
+ # either of them works here.
+
+ for path in [request_handler.path, request_handler.short_path]:
+ if self._validate_auth(auth_dict,
+ password,
+ request_handler.command,
+ path):
+ auth_validated = True
+
+ if not auth_validated:
+ return self._return_auth_challenge(request_handler)
+ return True
+
+# Proxy test infrastructure
+
+class FakeProxyHandler(BaseHTTPServer.BaseHTTPRequestHandler):
+ """This is a 'fake proxy' that makes it look like the entire
+ internet has gone down due to a sudden zombie invasion. It main
+ utility is in providing us with authentication support for
+ testing.
+ """
+
+ digest_auth_handler = DigestAuthHandler()
+
+ def log_message(self, format, *args):
+ # Uncomment the next line for debugging.
+ #sys.stderr.write(format % args)
+ pass
+
+ def do_GET(self):
+ (scm, netloc, path, params, query, fragment) = urlparse.urlparse(
+ self.path, 'http')
+ self.short_path = path
+ if self.digest_auth_handler.handle_request(self):
+ self.send_response(200, "OK")
+ self.send_header("Content-Type", "text/html")
+ self.end_headers()
+ self.wfile.write("You've reached %s!<BR>" % self.path)
+ self.wfile.write("Our apologies, but our server is down due to "
+ "a sudden zombie invasion.")
+
+# Test cases
+
+class ProxyAuthTests(unittest.TestCase):
+ URL = "http://www.foo.com"
+
+ PORT = 8080
+ USER = "tester"
+ PASSWD = "test123"
+ REALM = "TestRealm"
+
+ PROXY_URL = "http://127.0.0.1:%d" % PORT
+
+ def setUp(self):
+ FakeProxyHandler.digest_auth_handler.set_users({
+ self.USER : self.PASSWD
+ })
+ FakeProxyHandler.digest_auth_handler.set_realm(self.REALM)
+
+ self.server = LoopbackHttpServerThread(self.PORT, FakeProxyHandler)
+ self.server.start()
+ self.server.ready.wait()
+ if self.server.error:
+ raise self.server.error
+
+ handler = urllib2.ProxyHandler({"http" : self.PROXY_URL})
+ self._digest_auth_handler = urllib2.ProxyDigestAuthHandler()
+ self.opener = urllib2.build_opener(handler, self._digest_auth_handler)
+
+ def tearDown(self):
+ self.server.stop()
+
+ def test_proxy_with_bad_password_raises_httperror(self):
+ self._digest_auth_handler.add_password(self.REALM, self.URL,
+ self.USER, self.PASSWD+"bad")
+ FakeProxyHandler.digest_auth_handler.set_qop("auth")
+ self.assertRaises(urllib2.HTTPError,
+ self.opener.open,
+ self.URL)
+
+ def test_proxy_with_no_password_raises_httperror(self):
+ FakeProxyHandler.digest_auth_handler.set_qop("auth")
+ self.assertRaises(urllib2.HTTPError,
+ self.opener.open,
+ self.URL)
+
+ def test_proxy_qop_auth_works(self):
+ self._digest_auth_handler.add_password(self.REALM, self.URL,
+ self.USER, self.PASSWD)
+ FakeProxyHandler.digest_auth_handler.set_qop("auth")
+ result = self.opener.open(self.URL)
+ while result.read():
+ pass
+ result.close()
+
+ def test_proxy_qop_auth_int_works_or_throws_urlerror(self):
+ self._digest_auth_handler.add_password(self.REALM, self.URL,
+ self.USER, self.PASSWD)
+ FakeProxyHandler.digest_auth_handler.set_qop("auth-int")
+ try:
+ result = self.opener.open(self.URL)
+ except urllib2.URLError:
+ # It's okay if we don't support auth-int, but we certainly
+ # shouldn't receive any kind of exception here other than
+ # a URLError.
+ result = None
+ if result:
+ while result.read():
+ pass
+ result.close()
+
+def test_main():
+ # We will NOT depend on the network resource flag
+ # (Lib/test/regrtest.py -u network) since all tests here are only
+ # localhost. However, if this is a bad rationale, then uncomment
+ # the next line.
+ #test_support.requires("network")
+
+ test_support.run_unittest(ProxyAuthTests)
+
+if __name__ == "__main__":
+ test_main()
diff --git a/Lib/test/test_urllib2net.py b/Lib/test/test_urllib2net.py
index 537b738..89ddaa4 100644
--- a/Lib/test/test_urllib2net.py
+++ b/Lib/test/test_urllib2net.py
@@ -267,6 +267,49 @@
return handlers
+class TimeoutTest(unittest.TestCase):
+ def test_http_basic(self):
+ u = urllib2.urlopen("http://www.python.org")
+ self.assertTrue(u.fp._sock.fp._sock.gettimeout() is None)
+
+ def test_http_NoneWithdefault(self):
+ prev = socket.getdefaulttimeout()
+ socket.setdefaulttimeout(60)
+ try:
+ u = urllib2.urlopen("http://www.python.org", timeout=None)
+ self.assertEqual(u.fp._sock.fp._sock.gettimeout(), 60)
+ finally:
+ socket.setdefaulttimeout(prev)
+
+ def test_http_Value(self):
+ u = urllib2.urlopen("http://www.python.org", timeout=120)
+ self.assertEqual(u.fp._sock.fp._sock.gettimeout(), 120)
+
+ def test_http_NoneNodefault(self):
+ u = urllib2.urlopen("http://www.python.org", timeout=None)
+ self.assertTrue(u.fp._sock.fp._sock.gettimeout() is None)
+
+ def test_ftp_basic(self):
+ u = urllib2.urlopen("ftp://ftp.mirror.nl/pub/mirror/gnu/")
+ self.assertTrue(u.fp.fp._sock.gettimeout() is None)
+
+ def test_ftp_NoneWithdefault(self):
+ prev = socket.getdefaulttimeout()
+ socket.setdefaulttimeout(60)
+ try:
+ u = urllib2.urlopen("ftp://ftp.mirror.nl/pub/mirror/gnu/", timeout=None)
+ self.assertEqual(u.fp.fp._sock.gettimeout(), 60)
+ finally:
+ socket.setdefaulttimeout(prev)
+
+ def test_ftp_NoneNodefault(self):
+ u = urllib2.urlopen("ftp://ftp.mirror.nl/pub/mirror/gnu/", timeout=None)
+ self.assertTrue(u.fp.fp._sock.gettimeout() is None)
+
+ def test_ftp_Value(self):
+ u = urllib2.urlopen("ftp://ftp.mirror.nl/pub/mirror/gnu/", timeout=60)
+ self.assertEqual(u.fp.fp._sock.gettimeout(), 60)
+
def test_main():
test_support.requires("network")
@@ -275,6 +318,7 @@
AuthTests,
OtherNetworkTests,
CloseSocketTest,
+ TimeoutTest,
)
if __name__ == "__main__":
diff --git a/Lib/test/test_userlist.py b/Lib/test/test_userlist.py
index fc9508f..32c7733 100644
--- a/Lib/test/test_userlist.py
+++ b/Lib/test/test_userlist.py
@@ -8,7 +8,7 @@
type2test = UserList
def test_getslice(self):
- super(UserListTest, self).test_getslice()
+ super().test_getslice()
l = [0, 1, 2, 3, 4]
u = self.type2test(l)
for i in range(-3, 6):
@@ -30,7 +30,7 @@
self.assertEqual(u2, list("spameggs"))
def test_iadd(self):
- super(UserListTest, self).test_iadd()
+ super().test_iadd()
u = [0, 1]
u += UserList([0, 1])
self.assertEqual(u, [0, 1, 0, 1])
diff --git a/Lib/test/test_uu.py b/Lib/test/test_uu.py
index 548cafb..181e361 100644
--- a/Lib/test/test_uu.py
+++ b/Lib/test/test_uu.py
@@ -24,21 +24,21 @@
inp = cStringIO.StringIO(plaintext)
out = cStringIO.StringIO()
uu.encode(inp, out, "t1")
- self.assertEqual(out.getvalue(), encodedtextwrapped % (0666, "t1"))
+ self.assertEqual(out.getvalue(), encodedtextwrapped % (0o666, "t1"))
inp = cStringIO.StringIO(plaintext)
out = cStringIO.StringIO()
- uu.encode(inp, out, "t1", 0644)
- self.assertEqual(out.getvalue(), encodedtextwrapped % (0644, "t1"))
+ uu.encode(inp, out, "t1", 0o644)
+ self.assertEqual(out.getvalue(), encodedtextwrapped % (0o644, "t1"))
def test_decode(self):
- inp = cStringIO.StringIO(encodedtextwrapped % (0666, "t1"))
+ inp = cStringIO.StringIO(encodedtextwrapped % (0o666, "t1"))
out = cStringIO.StringIO()
uu.decode(inp, out)
self.assertEqual(out.getvalue(), plaintext)
inp = cStringIO.StringIO(
"UUencoded files may contain many lines,\n" +
"even some that have 'begin' in them.\n" +
- encodedtextwrapped % (0666, "t1")
+ encodedtextwrapped % (0o666, "t1")
)
out = cStringIO.StringIO()
uu.decode(inp, out)
@@ -75,14 +75,14 @@
def test_encode(self):
sys.stdin = cStringIO.StringIO(plaintext)
sys.stdout = cStringIO.StringIO()
- uu.encode("-", "-", "t1", 0666)
+ uu.encode("-", "-", "t1", 0o666)
self.assertEqual(
sys.stdout.getvalue(),
- encodedtextwrapped % (0666, "t1")
+ encodedtextwrapped % (0o666, "t1")
)
def test_decode(self):
- sys.stdin = cStringIO.StringIO(encodedtextwrapped % (0666, "t1"))
+ sys.stdin = cStringIO.StringIO(encodedtextwrapped % (0o666, "t1"))
sys.stdout = cStringIO.StringIO()
uu.decode("-", "-")
self.assertEqual(sys.stdout.getvalue(), plaintext)
@@ -120,21 +120,21 @@
fin = open(self.tmpin, 'rb')
fout = open(self.tmpout, 'w')
- uu.encode(fin, fout, self.tmpin, mode=0644)
+ uu.encode(fin, fout, self.tmpin, mode=0o644)
fin.close()
fout.close()
fout = open(self.tmpout, 'r')
s = fout.read()
fout.close()
- self.assertEqual(s, encodedtextwrapped % (0644, self.tmpin))
+ self.assertEqual(s, encodedtextwrapped % (0o644, self.tmpin))
# in_file and out_file as filenames
- uu.encode(self.tmpin, self.tmpout, self.tmpin, mode=0644)
+ uu.encode(self.tmpin, self.tmpout, self.tmpin, mode=0o644)
fout = open(self.tmpout, 'r')
s = fout.read()
fout.close()
- self.assertEqual(s, encodedtextwrapped % (0644, self.tmpin))
+ self.assertEqual(s, encodedtextwrapped % (0o644, self.tmpin))
finally:
self._kill(fin)
@@ -143,7 +143,7 @@
def test_decode(self):
try:
f = open(self.tmpin, 'w')
- f.write(encodedtextwrapped % (0644, self.tmpout))
+ f.write(encodedtextwrapped % (0o644, self.tmpout))
f.close()
f = open(self.tmpin, 'r')
@@ -161,7 +161,7 @@
def test_decodetwice(self):
# Verify that decode() will refuse to overwrite an existing file
try:
- f = cStringIO.StringIO(encodedtextwrapped % (0644, self.tmpout))
+ f = cStringIO.StringIO(encodedtextwrapped % (0o644, self.tmpout))
f = open(self.tmpin, 'r')
uu.decode(f)
diff --git a/Lib/test/test_weakref.py b/Lib/test/test_weakref.py
index 99a5178a..92d8031 100644
--- a/Lib/test/test_weakref.py
+++ b/Lib/test/test_weakref.py
@@ -651,10 +651,10 @@
class MyRef(weakref.ref):
def __init__(self, ob, callback=None, value=42):
self.value = value
- super(MyRef, self).__init__(ob, callback)
+ super().__init__(ob, callback)
def __call__(self):
self.called = True
- return super(MyRef, self).__call__()
+ return super().__call__()
o = Object("foo")
mr = MyRef(o, value=24)
self.assert_(mr() is o)
@@ -1091,7 +1091,7 @@
>>> import weakref
>>> class ExtendedRef(weakref.ref):
... def __init__(self, ob, callback=None, **annotations):
-... super(ExtendedRef, self).__init__(ob, callback)
+... super().__init__(ob, callback)
... self.__counter = 0
... for k, v in annotations.items():
... setattr(self, k, v)
@@ -1099,7 +1099,7 @@
... '''Return a pair containing the referent and the number of
... times the reference has been called.
... '''
-... ob = super(ExtendedRef, self).__call__()
+... ob = super().__call__()
... if ob is not None:
... self.__counter += 1
... ob = (ob, self.__counter)
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
index bc8a7cf..791cca7 100644
--- a/Lib/test/test_xmlrpc.py
+++ b/Lib/test/test_xmlrpc.py
@@ -15,9 +15,9 @@
'ukey\u4000': 'regular value',
'datetime1': xmlrpclib.DateTime('20050210T11:41:23'),
'datetime2': xmlrpclib.DateTime(
- (2005, 02, 10, 11, 41, 23, 0, 1, -1)),
+ (2005, 2, 10, 11, 41, 23, 0, 1, -1)),
'datetime3': xmlrpclib.DateTime(
- datetime.datetime(2005, 02, 10, 11, 41, 23)),
+ datetime.datetime(2005, 2, 10, 11, 41, 23)),
}]
class XMLRPCTestCase(unittest.TestCase):
@@ -31,7 +31,7 @@
# by the marshalling code. This can't be done via test_dump_load()
# since with use_datetime set to 1 the unmarshaller would create
# datetime objects for the 'datetime[123]' keys as well
- dt = datetime.datetime(2005, 02, 10, 11, 41, 23)
+ dt = datetime.datetime(2005, 2, 10, 11, 41, 23)
s = xmlrpclib.dumps((dt,))
(newdt,), m = xmlrpclib.loads(s, use_datetime=1)
self.assertEquals(newdt, dt)
@@ -44,7 +44,7 @@
# This checks that an unwrapped datetime.date object can be handled
# by the marshalling code. This can't be done via test_dump_load()
# since the unmarshaller produces a datetime object
- d = datetime.datetime(2005, 02, 10, 11, 41, 23).date()
+ d = datetime.datetime(2005, 2, 10, 11, 41, 23).date()
s = xmlrpclib.dumps((d,))
(newd,), m = xmlrpclib.loads(s, use_datetime=1)
self.assertEquals(newd.date(), d)
@@ -58,7 +58,7 @@
# This checks that an unwrapped datetime.time object can be handled
# by the marshalling code. This can't be done via test_dump_load()
# since the unmarshaller produces a datetime object
- t = datetime.datetime(2005, 02, 10, 11, 41, 23).time()
+ t = datetime.datetime(2005, 2, 10, 11, 41, 23).time()
s = xmlrpclib.dumps((t,))
(newt,), m = xmlrpclib.loads(s, use_datetime=1)
today = datetime.datetime.now().date().strftime("%Y%m%d")
diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py
index 53c5504..8daac4b 100644
--- a/Lib/test/test_zipimport.py
+++ b/Lib/test/test_zipimport.py
@@ -364,7 +364,7 @@
finally:
# If we leave "the read-only bit" set on Windows, nothing can
# delete TESTMOD, and later tests suffer bogus failures.
- os.chmod(TESTMOD, 0666)
+ os.chmod(TESTMOD, 0o666)
test_support.unlink(TESTMOD)
def testNotZipFile(self):
diff --git a/Lib/test/tf_inherit_check.py b/Lib/test/tf_inherit_check.py
index a8b80d2..0fd1089 100644
--- a/Lib/test/tf_inherit_check.py
+++ b/Lib/test/tf_inherit_check.py
@@ -19,7 +19,7 @@
sys.stderr.write("fd %d is open in child" % fd)
sys.exit(1)
-except StandardError:
+except Exception:
if verbose:
raise
sys.exit(1)
diff --git a/Lib/test/tokenize_tests.txt b/Lib/test/tokenize_tests.txt
index b1aa020..30e7a8d 100644
--- a/Lib/test/tokenize_tests.txt
+++ b/Lib/test/tokenize_tests.txt
@@ -37,21 +37,21 @@
# Ordinary integers
0xff != 255
-0377 != 255
-2147483647 != 017777777777
--2147483647-1 != 020000000000
-037777777777 != -1
-0xffffffff != -1
+0o377 != 255
+2147483647 != 0o17777777777
+-2147483647-1 != 0o20000000000
+0o37777777777 != -1
+0xffffffff != -1; 0o37777777777 != -1; -0o1234567 == 0O001234567; 0b10101 == 0B00010101
# Long integers
-x = 0L
-x = 0l
-x = 0xffffffffffffffffL
-x = 0xffffffffffffffffl
-x = 077777777777777777L
-x = 077777777777777777l
-x = 123456789012345678901234567890L
-x = 123456789012345678901234567890l
+x = 0
+x = 0
+x = 0xffffffffffffffff
+x = 0xffffffffffffffff
+x = 0o77777777777777777
+x = 0B11101010111111111
+x = 123456789012345678901234567890
+x = 123456789012345678901234567890
# Floating-point numbers
x = 3.14
diff --git a/Lib/threading.py b/Lib/threading.py
index e87a653..489713c 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -111,8 +111,8 @@
__enter__ = acquire
def release(self):
- me = currentThread()
- assert self.__owner is me, "release() of un-acquire()d lock"
+ if self.__owner is not currentThread():
+ raise RuntimeError("cannot release un-aquired lock")
self.__count = count = self.__count - 1
if not count:
self.__owner = None
@@ -203,7 +203,8 @@
return True
def wait(self, timeout=None):
- assert self._is_owned(), "wait() of un-acquire()d lock"
+ if not self._is_owned():
+ raise RuntimeError("cannot wait on un-aquired lock")
waiter = _allocate_lock()
waiter.acquire()
self.__waiters.append(waiter)
@@ -244,7 +245,8 @@
self._acquire_restore(saved_state)
def notify(self, n=1):
- assert self._is_owned(), "notify() of un-acquire()d lock"
+ if not self._is_owned():
+ raise RuntimeError("cannot notify on un-aquired lock")
__waiters = self.__waiters
waiters = __waiters[:n]
if not waiters:
@@ -272,7 +274,8 @@
# After Tim Peters' semaphore class, but not quite the same (no maximum)
def __init__(self, value=1, verbose=None):
- assert value >= 0, "Semaphore initial value must be >= 0"
+ if value < 0:
+ raise ValueError("semaphore initial value must be >= 0")
_Verbose.__init__(self, verbose)
self.__cond = Condition(Lock())
self.__value = value
@@ -423,8 +426,10 @@
return "<%s(%s, %s)>" % (self.__class__.__name__, self.__name, status)
def start(self):
- assert self.__initialized, "Thread.__init__() not called"
- assert not self.__started, "thread already started"
+ if not self.__initialized:
+ raise RuntimeError("thread.__init__() not called")
+ if self.__started:
+ raise RuntimeError("thread already started")
if __debug__:
self._note("%s.start(): starting thread", self)
_active_limbo_lock.acquire()
@@ -544,9 +549,13 @@
_active_limbo_lock.release()
def join(self, timeout=None):
- assert self.__initialized, "Thread.__init__() not called"
- assert self.__started, "cannot join thread before it is started"
- assert self is not currentThread(), "cannot join current thread"
+ if not self.__initialized:
+ raise RuntimeError("Thread.__init__() not called")
+ if not self.__started:
+ raise RuntimeError("cannot join thread before it is started")
+ if self is currentThread():
+ raise RuntimeError("cannot join current thread")
+
if __debug__:
if not self.__stopped:
self._note("%s.join(): waiting until thread stops", self)
@@ -589,8 +598,10 @@
return self.__daemonic
def setDaemon(self, daemonic):
- assert self.__initialized, "Thread.__init__() not called"
- assert not self.__started, "cannot set daemon status of active thread"
+ if not self.__initialized:
+ raise RuntimeError("Thread.__init__() not called")
+ if self.__started:
+ raise RuntimeError("cannot set daemon status of active thread");
self.__daemonic = daemonic
# The timer class was contributed by Itamar Shtull-Trauring
diff --git a/Lib/tokenize.py b/Lib/tokenize.py
index e94d7b9..9ea57b6 100644
--- a/Lib/tokenize.py
+++ b/Lib/tokenize.py
@@ -49,10 +49,11 @@
Ignore = Whitespace + any(r'\\\r?\n' + Whitespace) + maybe(Comment)
Name = r'[a-zA-Z_]\w*'
-Hexnumber = r'0[xX][\da-fA-F]*[lL]?'
-Octnumber = r'0[0-7]*[lL]?'
-Decnumber = r'[1-9]\d*[lL]?'
-Intnumber = group(Hexnumber, Octnumber, Decnumber)
+Hexnumber = r'0[xX][\da-fA-F]*'
+Binnumber = r'0[bB][01]*'
+Octnumber = r'0[oO][0-7]*'
+Decnumber = r'(?:0+|[1-9]\d*)'
+Intnumber = group(Hexnumber, Binnumber, Octnumber, Decnumber)
Exponent = r'[eE][-+]?\d+'
Pointfloat = group(r'\d+\.\d*', r'\.\d+') + maybe(Exponent)
Expfloat = r'\d+' + Exponent
diff --git a/Lib/urllib2.py b/Lib/urllib2.py
index 4321c36..4ae7df4 100644
--- a/Lib/urllib2.py
+++ b/Lib/urllib2.py
@@ -114,11 +114,11 @@
__version__ = sys.version[:3]
_opener = None
-def urlopen(url, data=None):
+def urlopen(url, data=None, timeout=None):
global _opener
if _opener is None:
_opener = build_opener()
- return _opener.open(url, data)
+ return _opener.open(url, data, timeout)
def install_opener(opener):
global _opener
@@ -352,7 +352,7 @@
if result is not None:
return result
- def open(self, fullurl, data=None):
+ def open(self, fullurl, data=None, timeout=None):
# accept a URL or a Request object
if isinstance(fullurl, basestring):
req = Request(fullurl, data)
@@ -361,6 +361,7 @@
if data is not None:
req.add_data(data)
+ req.timeout = timeout
protocol = req.get_type()
# pre-process request
@@ -944,7 +945,7 @@
respdig = KD(H(A1), "%s:%s" % (nonce, H(A2)))
else:
# XXX handle auth-int.
- pass
+ raise URLError("qop '%s' is not supported." % qop)
# XXX should the partial digests be encoded too?
@@ -1053,7 +1054,7 @@
if not host:
raise URLError('no host given')
- h = http_class(host) # will parse host:port
+ h = http_class(host, timeout=req.timeout) # will parse host:port
h.set_debuglevel(self._debuglevel)
headers = dict(req.headers)
@@ -1263,7 +1264,7 @@
if dirs and not dirs[0]:
dirs = dirs[1:]
try:
- fw = self.connect_ftp(user, passwd, host, port, dirs)
+ fw = self.connect_ftp(user, passwd, host, port, dirs, req.timeout)
type = file and 'I' or 'D'
for attr in attrs:
attr, value = splitvalue(attr)
@@ -1283,8 +1284,8 @@
except ftplib.all_errors as msg:
raise IOError, ('ftp error', msg), sys.exc_info()[2]
- def connect_ftp(self, user, passwd, host, port, dirs):
- fw = ftpwrapper(user, passwd, host, port, dirs)
+ def connect_ftp(self, user, passwd, host, port, dirs, timeout):
+ fw = ftpwrapper(user, passwd, host, port, dirs, timeout)
## fw.ftp.set_debuglevel(1)
return fw
@@ -1304,12 +1305,12 @@
def setMaxConns(self, m):
self.max_conns = m
- def connect_ftp(self, user, passwd, host, port, dirs):
- key = user, host, port, '/'.join(dirs)
+ def connect_ftp(self, user, passwd, host, port, dirs, timeout):
+ key = user, host, port, '/'.join(dirs), timeout
if key in self.cache:
self.timeout[key] = time.time() + self.delay
else:
- self.cache[key] = ftpwrapper(user, passwd, host, port, dirs)
+ self.cache[key] = ftpwrapper(user, passwd, host, port, dirs, timeout)
self.timeout[key] = time.time() + self.delay
self.check_cache()
return self.cache[key]
diff --git a/Lib/uu.py b/Lib/uu.py
index 4d3cbd6..ff1ffe4 100755
--- a/Lib/uu.py
+++ b/Lib/uu.py
@@ -68,11 +68,11 @@
if name is None:
name = '-'
if mode is None:
- mode = 0666
+ mode = 0o666
#
# Write the data
#
- out_file.write('begin %o %s\n' % ((mode&0777),name))
+ out_file.write('begin %o %s\n' % ((mode & 0o777),name))
data = in_file.read(45)
while len(data) > 0:
out_file.write(binascii.b2a_uu(data))
diff --git a/Lib/weakref.py b/Lib/weakref.py
index 33896f5..bdb89fb 100644
--- a/Lib/weakref.py
+++ b/Lib/weakref.py
@@ -204,7 +204,7 @@
return self
def __init__(self, ob, callback, key):
- super(KeyedRef, self).__init__(ob, callback)
+ super().__init__(ob, callback)
class WeakKeyDictionary(UserDict.UserDict):
diff --git a/Lib/xml/dom/domreg.py b/Lib/xml/dom/domreg.py
index ec3acdf..cfd8231 100644
--- a/Lib/xml/dom/domreg.py
+++ b/Lib/xml/dom/domreg.py
@@ -72,7 +72,7 @@
for creator in well_known_implementations.keys():
try:
dom = getDOMImplementation(name = creator)
- except StandardError: # typically ImportError, or AttributeError
+ except Exception: # typically ImportError, or AttributeError
continue
if _good_enough(dom, features):
return dom