diff options
Diffstat (limited to 'Lib')
104 files changed, 2185 insertions, 647 deletions
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 @@ def executable(path): 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 @@ class LocaleTime(object): # 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 @@ class TimeRE(dict): 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 @@ class TimeRE(dict): 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 @@ if not _defaultmod: 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 @@ class _DBWithCursor(_iter_mixin): #---------------------------------------------------------------------- # 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 hashopen(file, flag='c', mode=0666, pgsize=None, ffactor=None, nelem=None, #---------------------------------------------------------------------- -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 btopen(file, flag='c', mode=0666, #---------------------------------------------------------------------- -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 @@ from . import db #------------------------------------------------------------------------ -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 @@ except NameError: class DBIncompleteError(Exception): pass -class TableDBError(StandardError): +class TableDBError(Exception): pass class TableAlreadyExists(TableDBError): pass @@ -134,9 +134,9 @@ def contains_metastrings(s) : 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 @@ env.open(env_name, db.DB_CREATE | db.DB_INIT_TXN | db.DB_INIT_MPOOL) 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 @@ class BasicTestCase(unittest.TestCase): 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 @@ class DBEnvClosedEarlyCrash(unittest.TestCase): 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 @@ class DBEnvClosedEarlyCrash(unittest.TestCase): 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 @@ class DBSequenceTest(unittest.TestCase): 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 _collections import deque, defaultdict 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 @@ class py_object(_SimpleCData): _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 @@ class _swapped_meta(type(Structure)): 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 @@ class X(Structure): 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 @@ class NumberTestCase(unittest.TestCase): 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 @@ __all__ = ["error","open"] 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 @@ main (int argc, char **argv) { 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 @@ class Command: 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 @@ class build_py (Command): 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 @@ class build_scripts (Command): 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 @@ class install_scripts (Command): 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 @@ Your selection [default 1]: ''', end=' ') 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 @@ _path_created = {} # 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 @@ def mkpath (name, mode=0777, verbose=0, dry_run=0): # 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 @@ from distutils.ccompiler import \ 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 @@ class MWerksCompiler (CCompiler) : # 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 @@ from distutils import log 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 @@ class TempdirManager(object): """ 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 @@ class BuildPyTestCase(support.TempdirManager, 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 @@ class _Database(UserDict.DictMixin): 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 @@ def open(file, flag=None, mode=0666): 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 @@ class FTP: 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 @@ def _os_path_isdir(pathname): 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 @@ class Maildir(Mailbox): 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 @@ class MH(Mailbox): 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 @@ s = m.getbodytext(0) # text of message's body, not decoded MH_PROFILE = '~/.mh_profile' PATH = '~/Mail' MH_SEQUENCES = '.mh_sequences' -FOLDER_PROTECT = 0700 +FOLDER_PROTECT = 0o700 # Imported modules @@ -147,8 +147,8 @@ SEEK_END = 2 # 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 @@ def _execvpe(file, args, env=None): 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 - - # Fake unsetenv() for Windows - # not sure about os2 here but - # I'm guessing they are the same. - - if name in ('os2', 'nt'): - def unsetenv(key): - putenv(key, "") - - 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) + # Change environ to automatically call putenv(), unsetenv if they exist. + from _abcoll import MutableMapping # Can't use collections (bootstrap) + + 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] + + try: + _putenv = putenv + except NameError: + _putenv = lambda key, value: None + else: + __all__.append("putenv") + + 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) - - - environ = _Environ(environ) + _keymap = lambda key: key + + environ = _Environ(environ, _keymap, _putenv, _unsetenv) + 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 @@ _DIRENT_H = 1 # 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 = NAME_MAX 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_ISFIFO(m): return (((m) & S_IFMT) == S_IFIFO) 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 @@ S_IXUGO = (S_IXUSR|S_IXGRP|S_IXOTH) _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 @@ def pack(x, forcetype = None): 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 @@ class AppBuilder(BundleBuilder): 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 @@ class AppBuilder(BundleBuilder): 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 @@ def mkdirs(dst): 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 @@ class Dict(_InternalDict): 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 @@ class Plist(_InternalDict): 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 @@ NGROUPS_MAX_DEFAULT = 16 NZERO = 20 NULL = 0 NULL = 0 -CMASK = 022 +CMASK = 0o22 CDLIMIT = (1<<11) NBPS = 0x20000 NBPSCTR = 512 @@ -733,13 +733,13 @@ _SPARC_MAXREGWINDOW = 31 _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_STAT = (AT_MODE|AT_UID|AT_GID|AT_FSID|AT_NODEID|AT_NLINK|\ 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 @@ NGROUPS_MAX_DEFAULT = 16 NZERO = 20 NULL = 0 NULL = 0 -CMASK = 022 +CMASK = 0o22 CDLIMIT = (1<<11) NBPS = 0x20000 NBPSCTR = 512 @@ -730,13 +730,13 @@ _SPARC_MAXREGWINDOW = 31 _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_STAT = (AT_MODE|AT_UID|AT_GID|AT_FSID|AT_NODEID|AT_NLINK|\ 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 = 2 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_PRVSETS = 6 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 @@ MUXID_ALL = (-1) 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 @@ _release_version = re.compile(r'([^0-9]+)' _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 @@ def win32_ver(release='',version='',csd='',ptype=''): 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 @@ def uname(): # (_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 @@ -55,7 +55,7 @@ def _open_terminal(): 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 @@ class Random(_random.Random): 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 @@ class Repr: 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 @@ class ModuleTests(unittest.TestCase): 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 @@ ST_CTIME = 9 # 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 @@ def S_ISSOCK(mode): # 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 @@ PAX_NUMBER_FIELDS = { #--------------------------------------------------------- # 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 - -TSUID = 04000 # set UID on execution -TSGID = 02000 # set GID on execution -TSVTX = 01000 # 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 +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 = 0o4000 # set UID on execution +TSGID = 0o2000 # set GID on execution +TSVTX = 0o1000 # reserved + +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 @@ def nti(s): """ # 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 @@ def itn(n, digits=8, format=DEFAULT_FORMAT): # 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 @@ def itn(n, digits=8, format=DEFAULT_FORMAT): 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 @@ class TarInfo(object): 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 @@ class TarInfo(object): """ 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 @@ class TarInfo(object): """ 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 @@ class TarFile(object): # 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 @@ def _get_default_tempdir(): 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 @@ def _mkstemp_inner(dir, pre, suf, flags): 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 @@ def mkdtemp(suffix="", prefix=template, dir=None): 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 @@ BaseException +-- 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 @@ class CommonTest(seq_tests.CommonTest): 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 @@ __abs__: () __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 @@ test_tokenize 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 @@ def dash_R_cleanup(fs, ps, pic): 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 @@ def dash_R_cleanup(fs, ps, pic): 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 @@ class BaseTest(unittest.TestCase): 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 BaseTest(unittest.TestCase): 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 @@ class BuiltinTest(unittest.TestCase): 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 @@ class BuiltinTest(unittest.TestCase): 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 @@ class BytesAsStringTest(test.string_tests.BaseTest): 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 @@ def do_test(buf, method): 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 @@ class AllTests: 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) int(testme) float(testme) oct(testme) -hex(testme) # And the rest... @@ -287,8 +282,6 @@ class BadTypeClass: __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 @@ class TestNamedTuple(unittest.TestCase): 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 @@ class TestSpecifics(unittest.TestCase): 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 @@ if 1: 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 @@ if 1: 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 @@ def inherits(): 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 @@ class DumbDBMTestCase(unittest.TestCase): 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 @@ testboth("%#+027.23X", big, "+0X0001234567890ABCDEF12345") # 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("%.33o", big, "012345670123456701234567012345670") 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", 0, "0X0") 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, 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 @@ class TokenTests(unittest.TestCase): 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 @@ class TokenTests(unittest.TestCase): def testLongIntegers(self): x = 0 - x = 0 - x = 0xffffffffffffffff x = 0xffffffffffffffff - x = 077777777777777777 - x = 077777777777777777 - x = 123456789012345678901234567890 + x = 0Xffffffffffffffff + x = 0o77777777777777777 + x = 0O77777777777777777 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 @@ class TextHexOct(unittest.TestCase): 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 @@ class ListTest(list_tests.CommonTest): type2test = list def test_truth(self): - super(ListTest, self).test_truth() + super().test_truth() self.assert_(not []) self.assert_([42]) @@ -13,7 +13,7 @@ class ListTest(list_tests.CommonTest): 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 @@ class LongTest(unittest.TestCase): 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 @@ class LongTest(unittest.TestCase): 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 @@ class Test_IncrementalDecoder(unittest.TestCase): 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 @@ class TestTranforms(unittest.TestCase): 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 @@ class UsageTests(unittest.TestCase): """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 @@ import unittest 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 @@ class ReprTests(unittest.TestCase): 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 @@ class StrTest( 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 @@ class TimeRETests(unittest.TestCase): "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 @@ class CalculationTests(unittest.TestCase): "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 @@ from _testcapi import test_structmembersType, \ 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 @@ class ReadWriteTests(unittest.TestCase): 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 @@ class ProcessTestCase(unittest.TestCase): 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 @@ class ProcessTestCase(unittest.TestCase): 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 @@ with guard_warnings_filter(): 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 @@ with guard_warnings_filter(): 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 @@ class MiscReadTest(ReadTest): 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 @@ class MemberReadTest(ReadTest): 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 @@ class LimitsTest(unittest.TestCase): # 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 @@ class LimitsTest(unittest.TestCase): # 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 @@ class LimitsTest(unittest.TestCase): 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 @@ class test__mkstemp_inner(TC): 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 @@ class test_mkdtemp(TC): 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 @@ class test_mktemp(TC): 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 @@ class ThreadTests(unittest.TestCase): 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 @@ class TupleTest(seq_tests.CommonTest): 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 @@ Written by Marc-Andre Lemburg (mal@lemburg.com). (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 @@ class UnicodeTest( 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 @@ class TestUnicodeFiles(unittest.TestCase): 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 @@ from unittest import TestCase 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 HandlerTests(unittest.TestCase): 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 @@ class HandlerTests(unittest.TestCase): "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 @@ class HandlerTests(unittest.TestCase): 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 @@ class HandlerTests(unittest.TestCase): 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 @@ class OtherNetworkTests(unittest.TestCase): 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 @@ def test_main(): 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 @@ class UserListTest(list_tests.CommonTest): 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 @@ class UserListTest(list_tests.CommonTest): 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 @@ class UUTest(unittest.TestCase): 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 @@ class UUStdIOTest(unittest.TestCase): 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 @@ class UUFileTest(unittest.TestCase): 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 @@ class UUFileTest(unittest.TestCase): 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 @@ class UUFileTest(unittest.TestCase): 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 SubclassableWeakrefTestCase(unittest.TestCase): 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 @@ None >>> 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 @@ None ... '''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 @@ alist = [{'astring': 'foo@bar.baz.spam', '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 @@ class XMLRPCTestCase(unittest.TestCase): # 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 @@ class XMLRPCTestCase(unittest.TestCase): # 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 @@ class XMLRPCTestCase(unittest.TestCase): # 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 @@ class BadFileZipImportTestCase(unittest.TestCase): 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 @@ try: 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 @@ x = 0 # 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 @@ class _RLock(_Verbose): __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 @@ class _Condition(_Verbose): 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 @@ class _Condition(_Verbose): 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 @@ class _Semaphore(_Verbose): # 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 @@ class Thread(_Verbose): 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 @@ class Thread(_Verbose): _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 @@ class Thread(_Verbose): 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 @@ Comment = r'#[^\r\n]*' 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 @@ from urllib import localhost, url2pathname, getproxies __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 @@ class OpenerDirector: 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 @@ class OpenerDirector: if data is not None: req.add_data(data) + req.timeout = timeout protocol = req.get_type() # pre-process request @@ -944,7 +945,7 @@ class AbstractDigestAuthHandler: 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 @@ class AbstractHTTPHandler(BaseHandler): 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 @@ class FTPHandler(BaseHandler): 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 @@ class FTPHandler(BaseHandler): 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 @@ class CacheFTPHandler(FTPHandler): 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] @@ -68,11 +68,11 @@ def encode(in_file, out_file, name=None, mode=None): 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 @@ class KeyedRef(ref): 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 @@ def getDOMImplementation(name = None, features = ()): 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 |