Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617-60678 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk ........ r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines Remove month parameter from Calendar.yeardatescalendar(), Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods don't have such a parameter. Fixes issue #2017. Rewrap content to 80 chars. ........ r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines Fixes issue 1959. Converted tests to unittest. Thanks Giampaolo Rodola. ........ r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines Fixed refcounts and error handling. Should not be merged to py3k branch. ........ r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN raise InvalidOperation (and return False if InvalidOperation is trapped). ........ r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines Remove incorrect usage of :const: in documentation. ........ r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines Revert accidental changes to test_queue in r60605. ........ r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. ........ r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines Fix broken link in decimal documentation. ........ r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines IEEE 754 should be IEEE 854; give precise reference for comparisons involving NaNs. ........ r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line Return ints instead of longs for tuple.count() and tuple.index(). ........ r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line Merge 60627. ........ r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs. ........ r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines Cast a struct to a void pointer so as to do a type-safe pointer comparison (mistmatch found by clang). ........ r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines Remove unnecessary curly braces around an int literal. ........ r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line Update URL ........ r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines Fixes issue 2026. Tests converted to unittest. Thanks Giampaolo Rodola. ........ r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet. ........ r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines Fixes Issue 1401. When redirected, a possible POST get converted to GET, so it loses its payload. So, it also must lose the headers related to the payload (if it has no content any more, it shouldn't indicate content length and type). ........ r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines Clarify that the output of TextCalendar.formatmonth() and TextCalendar.formatyear() for custom instances won't be influenced by calls to the module global setfirstweekday() function. Fixes #2018. ........ r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines Fix documentation for Calendar.iterweekdays(): firstweekday is a property. Fixes second part of #2018. ........ r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines Fix typo in docstring for Calendar.itermonthdays(). ........ r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line The float conversion recipe is simpler in Py2.6 ........ r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line Fix typo ........ r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines Make sure a switch statement does not have repetitive case statements. Error found through LLVM post-2.1 svn. ........ r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line Deallocate content of the dict free list on interpreter shutdown ........ r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line Use prefix decrement ........ r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines issue 2045: Infinite recursion when printing a subclass of defaultdict, if default_factory is set to a bound method. Will backport. ........ r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines Oops! 2.6's Rational.__ne__ didn't work. ........ r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines Update big5hkscs codec to conform to the HKSCS:2004 revision. ........ r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines Remove unnecessary modulo division. The preceding test guarantees that 0 <= i < len. ........ r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line Speed-up __iter__() mixin method. ........ r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line Fill-in missing Set comparisons ........ r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line Add advice on choosing between DictMixin and MutableMapping ........
This commit is contained in:
Christian Heimes
parent
409fb2c809
commit
77c02ebf38
|
|
@ -37,9 +37,9 @@ it's the base calendar for all computations.
|
|||
|
||||
.. method:: Calendar.iterweekdays(weekday)
|
||||
|
||||
Return an iterator for the week day numbers that will be used for one week. The
|
||||
first number from the iterator will be the same as the number returned by
|
||||
:meth:`firstweekday`.
|
||||
Return an iterator for the week day numbers that will be used for one week.
|
||||
The first value from the iterator will be the same as the value of the
|
||||
:attr:`firstweekday` property.
|
||||
|
||||
|
||||
.. method:: Calendar.itermonthdates(year, month)
|
||||
|
|
@ -81,22 +81,22 @@ it's the base calendar for all computations.
|
|||
Weeks are lists of seven day numbers.
|
||||
|
||||
|
||||
.. method:: Calendar.yeardatescalendar(year, month[, width])
|
||||
.. method:: Calendar.yeardatescalendar(year[, width])
|
||||
|
||||
Return the data for the specified year ready for formatting. The return value is
|
||||
a list of month rows. Each month row contains up to *width* months (defaulting
|
||||
to 3). Each month contains between 4 and 6 weeks and each week contains 1--7
|
||||
days. Days are :class:`datetime.date` objects.
|
||||
Return the data for the specified year ready for formatting. The return value
|
||||
is a list of month rows. Each month row contains up to *width* months
|
||||
(defaulting to 3). Each month contains between 4 and 6 weeks and each week
|
||||
contains 1--7 days. Days are :class:`datetime.date` objects.
|
||||
|
||||
|
||||
.. method:: Calendar.yeardays2calendar(year, month[, width])
|
||||
.. method:: Calendar.yeardays2calendar(year[, width])
|
||||
|
||||
Return the data for the specified year ready for formatting (similar to
|
||||
:meth:`yeardatescalendar`). Entries in the week lists are tuples of day numbers
|
||||
and weekday numbers. Day numbers outside this month are zero.
|
||||
:meth:`yeardatescalendar`). Entries in the week lists are tuples of day
|
||||
numbers and weekday numbers. Day numbers outside this month are zero.
|
||||
|
||||
|
||||
.. method:: Calendar.yeardayscalendar(year, month[, width])
|
||||
.. method:: Calendar.yeardayscalendar(year[, width])
|
||||
|
||||
Return the data for the specified year ready for formatting (similar to
|
||||
:meth:`yeardatescalendar`). Entries in the week lists are day numbers. Day
|
||||
|
|
@ -113,9 +113,10 @@ it's the base calendar for all computations.
|
|||
.. method:: TextCalendar.formatmonth(theyear, themonth[, w[, l]])
|
||||
|
||||
Return a month's calendar in a multi-line string. If *w* is provided, it
|
||||
specifies the width of the date columns, which are centered. If *l* is given, it
|
||||
specifies the number of lines that each week will use. Depends on the first
|
||||
weekday as set by :func:`setfirstweekday`.
|
||||
specifies the width of the date columns, which are centered. If *l* is given,
|
||||
it specifies the number of lines that each week will use. Depends on the
|
||||
first weekday as specified in the constructor or set by the
|
||||
:meth:`setfirstweekday` method.
|
||||
|
||||
|
||||
.. method:: TextCalendar.prmonth(theyear, themonth[, w[, l]])
|
||||
|
|
@ -125,11 +126,12 @@ it's the base calendar for all computations.
|
|||
|
||||
.. method:: TextCalendar.formatyear(theyear, themonth[, w[, l[, c[, m]]]])
|
||||
|
||||
Return a *m*-column calendar for an entire year as a multi-line string. Optional
|
||||
parameters *w*, *l*, and *c* are for date column width, lines per week, and
|
||||
number of spaces between month columns, respectively. Depends on the first
|
||||
weekday as set by :meth:`setfirstweekday`. The earliest year for which a
|
||||
calendar can be generated is platform-dependent.
|
||||
Return a *m*-column calendar for an entire year as a multi-line string.
|
||||
Optional parameters *w*, *l*, and *c* are for date column width, lines per
|
||||
week, and number of spaces between month columns, respectively. Depends on
|
||||
the first weekday as specified in the constructor or set by the
|
||||
:meth:`setfirstweekday` method. The earliest year for which a calendar can
|
||||
be generated is platform-dependent.
|
||||
|
||||
|
||||
.. method:: TextCalendar.pryear(theyear[, w[, l[, c[, m]]]])
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ reset them before monitoring a calculation.
|
|||
Specification <http://www2.hursley.ibm.com/decimal/decarith.html>`_.
|
||||
|
||||
* IEEE standard 854-1987, `Unofficial IEEE 854 Text
|
||||
<http://www.cs.berkeley.edu/~ejr/projects/754/private/drafts/854-1987/dir.html>`_.
|
||||
<http://754r.ucbtest.org/standards/854.pdf>`_.
|
||||
|
||||
.. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
|
||||
|
|
@ -1238,6 +1238,19 @@ A variant is :const:`sNaN` which signals rather than remaining quiet after every
|
|||
operation. This is a useful return value when an invalid result needs to
|
||||
interrupt a calculation for special handling.
|
||||
|
||||
The behavior of Python's comparison operators can be a little surprising where a
|
||||
:const:`NaN` is involved. A test for equality where one of the operands is a
|
||||
quiet or signaling :const:`NaN` always returns :const:`False` (even when doing
|
||||
``Decimal('NaN')==Decimal('NaN')``), while a test for inequality always returns
|
||||
:const:`True`. An attempt to compare two Decimals using any of the ``<``,
|
||||
``<=``, ``>`` or ``>=`` operators will raise the :exc:`InvalidOperation` signal
|
||||
if either operand is a :const:`NaN`, and return :const:`False` if this signal is
|
||||
trapped. Note that the General Decimal Arithmetic specification does not
|
||||
specify the behavior of direct comparisons; these rules for comparisons
|
||||
involving a :const:`NaN` were taken from the IEEE 854 standard (see Table 3 in
|
||||
section 5.7). To ensure strict standards-compliance, use the :meth:`compare`
|
||||
and :meth:`compare-signal` methods instead.
|
||||
|
||||
The signed zeros can result from calculations that underflow. They keep the sign
|
||||
that would have resulted if the calculation had been carried out to greater
|
||||
precision. Since their magnitude is zero, both positive and negative zeros are
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
|
||||
|
||||
:mod:`UserList` --- Class wrapper for list objects
|
||||
==================================================
|
||||
|
||||
|
|
|
|||
|
|
@ -134,6 +134,7 @@ PyAPI_FUNC(void) _PyImport_Fini(void);
|
|||
PyAPI_FUNC(void) PyMethod_Fini(void);
|
||||
PyAPI_FUNC(void) PyFrame_Fini(void);
|
||||
PyAPI_FUNC(void) PyCFunction_Fini(void);
|
||||
PyAPI_FUNC(void) PyDict_Fini(void);
|
||||
PyAPI_FUNC(void) PyTuple_Fini(void);
|
||||
PyAPI_FUNC(void) PyList_Fini(void);
|
||||
PyAPI_FUNC(void) PySet_Fini(void);
|
||||
|
|
|
|||
|
|
@ -179,8 +179,8 @@ class Calendar(object):
|
|||
|
||||
def itermonthdays(self, year, month):
|
||||
"""
|
||||
Like itermonthdates(), but will yield day numbers tuples. For days
|
||||
outside the specified month the day number is 0.
|
||||
Like itermonthdates(), but will yield day numbers. For days outside
|
||||
the specified month the day number is 0.
|
||||
"""
|
||||
for date in self.itermonthdates(year, month):
|
||||
if date.month != month:
|
||||
|
|
|
|||
162
Lib/decimal.py
162
Lib/decimal.py
|
|
@ -718,6 +718,39 @@ class Decimal(_numbers.Real, _numbers.Inexact):
|
|||
return other._fix_nan(context)
|
||||
return 0
|
||||
|
||||
def _compare_check_nans(self, other, context):
|
||||
"""Version of _check_nans used for the signaling comparisons
|
||||
compare_signal, __le__, __lt__, __ge__, __gt__.
|
||||
|
||||
Signal InvalidOperation if either self or other is a (quiet
|
||||
or signaling) NaN. Signaling NaNs take precedence over quiet
|
||||
NaNs.
|
||||
|
||||
Return 0 if neither operand is a NaN.
|
||||
|
||||
"""
|
||||
if context is None:
|
||||
context = getcontext()
|
||||
|
||||
if self._is_special or other._is_special:
|
||||
if self.is_snan():
|
||||
return context._raise_error(InvalidOperation,
|
||||
'comparison involving sNaN',
|
||||
self)
|
||||
elif other.is_snan():
|
||||
return context._raise_error(InvalidOperation,
|
||||
'comparison involving sNaN',
|
||||
other)
|
||||
elif self.is_qnan():
|
||||
return context._raise_error(InvalidOperation,
|
||||
'comparison involving NaN',
|
||||
self)
|
||||
elif other.is_qnan():
|
||||
return context._raise_error(InvalidOperation,
|
||||
'comparison involving NaN',
|
||||
other)
|
||||
return 0
|
||||
|
||||
def __bool__(self):
|
||||
"""Return True if self is nonzero; otherwise return False.
|
||||
|
||||
|
|
@ -725,18 +758,13 @@ class Decimal(_numbers.Real, _numbers.Inexact):
|
|||
"""
|
||||
return self._is_special or self._int != '0'
|
||||
|
||||
def __cmp__(self, other):
|
||||
other = _convert_other(other)
|
||||
if other is NotImplemented:
|
||||
# Never return NotImplemented
|
||||
return 1
|
||||
def _cmp(self, other):
|
||||
"""Compare the two non-NaN decimal instances self and other.
|
||||
|
||||
Returns -1 if self < other, 0 if self == other and 1
|
||||
if self > other. This routine is for internal use only."""
|
||||
|
||||
if self._is_special or other._is_special:
|
||||
# check for nans, without raising on a signaling nan
|
||||
if self._isnan() or other._isnan():
|
||||
return 1 # Comparison involving NaN's always reports self > other
|
||||
|
||||
# INF = INF
|
||||
return cmp(self._isinfinity(), other._isinfinity())
|
||||
|
||||
# check for zeros; note that cmp(0, -0) should return 0
|
||||
|
|
@ -765,35 +793,72 @@ class Decimal(_numbers.Real, _numbers.Inexact):
|
|||
else: # self_adjusted < other_adjusted
|
||||
return -((-1)**self._sign)
|
||||
|
||||
# Note: The Decimal standard doesn't cover rich comparisons for
|
||||
# Decimals. In particular, the specification is silent on the
|
||||
# subject of what should happen for a comparison involving a NaN.
|
||||
# We take the following approach:
|
||||
#
|
||||
# == comparisons involving a NaN always return False
|
||||
# != comparisons involving a NaN always return True
|
||||
# <, >, <= and >= comparisons involving a (quiet or signaling)
|
||||
# NaN signal InvalidOperation, and return False if the
|
||||
# InvalidOperation is trapped.
|
||||
#
|
||||
# This behavior is designed to conform as closely as possible to
|
||||
# that specified by IEEE 754.
|
||||
|
||||
def __eq__(self, other):
|
||||
if not isinstance(other, (Decimal, int)):
|
||||
return NotImplemented
|
||||
return self.__cmp__(other) == 0
|
||||
other = _convert_other(other)
|
||||
if other is NotImplemented:
|
||||
return other
|
||||
if self.is_nan() or other.is_nan():
|
||||
return False
|
||||
return self._cmp(other) == 0
|
||||
|
||||
def __ne__(self, other):
|
||||
if not isinstance(other, (Decimal, int)):
|
||||
return NotImplemented
|
||||
return self.__cmp__(other) != 0
|
||||
other = _convert_other(other)
|
||||
if other is NotImplemented:
|
||||
return other
|
||||
if self.is_nan() or other.is_nan():
|
||||
return True
|
||||
return self._cmp(other) != 0
|
||||
|
||||
def __lt__(self, other):
|
||||
if not isinstance(other, (Decimal, int)):
|
||||
return NotImplemented
|
||||
return self.__cmp__(other) < 0
|
||||
|
||||
def __le__(self, other):
|
||||
if not isinstance(other, (Decimal, int)):
|
||||
return NotImplemented
|
||||
return self.__cmp__(other) <= 0
|
||||
def __lt__(self, other, context=None):
|
||||
other = _convert_other(other)
|
||||
if other is NotImplemented:
|
||||
return other
|
||||
ans = self._compare_check_nans(other, context)
|
||||
if ans:
|
||||
return False
|
||||
return self._cmp(other) < 0
|
||||
|
||||
def __gt__(self, other):
|
||||
if not isinstance(other, (Decimal, int)):
|
||||
return NotImplemented
|
||||
return self.__cmp__(other) > 0
|
||||
def __le__(self, other, context=None):
|
||||
other = _convert_other(other)
|
||||
if other is NotImplemented:
|
||||
return other
|
||||
ans = self._compare_check_nans(other, context)
|
||||
if ans:
|
||||
return False
|
||||
return self._cmp(other) <= 0
|
||||
|
||||
def __ge__(self, other):
|
||||
if not isinstance(other, (Decimal, int)):
|
||||
return NotImplemented
|
||||
return self.__cmp__(other) >= 0
|
||||
def __gt__(self, other, context=None):
|
||||
other = _convert_other(other)
|
||||
if other is NotImplemented:
|
||||
return other
|
||||
ans = self._compare_check_nans(other, context)
|
||||
if ans:
|
||||
return False
|
||||
return self._cmp(other) > 0
|
||||
|
||||
def __ge__(self, other, context=None):
|
||||
other = _convert_other(other)
|
||||
if other is NotImplemented:
|
||||
return other
|
||||
ans = self._compare_check_nans(other, context)
|
||||
if ans:
|
||||
return False
|
||||
return self._cmp(other) >= 0
|
||||
|
||||
def compare(self, other, context=None):
|
||||
"""Compares one to another.
|
||||
|
|
@ -812,7 +877,7 @@ class Decimal(_numbers.Real, _numbers.Inexact):
|
|||
if ans:
|
||||
return ans
|
||||
|
||||
return Decimal(self.__cmp__(other))
|
||||
return Decimal(self._cmp(other))
|
||||
|
||||
def __hash__(self):
|
||||
"""x.__hash__() <==> hash(x)"""
|
||||
|
|
@ -2463,7 +2528,7 @@ class Decimal(_numbers.Real, _numbers.Inexact):
|
|||
return other._fix_nan(context)
|
||||
return self._check_nans(other, context)
|
||||
|
||||
c = self.__cmp__(other)
|
||||
c = self._cmp(other)
|
||||
if c == 0:
|
||||
# If both operands are finite and equal in numerical value
|
||||
# then an ordering is applied:
|
||||
|
|
@ -2505,7 +2570,7 @@ class Decimal(_numbers.Real, _numbers.Inexact):
|
|||
return other._fix_nan(context)
|
||||
return self._check_nans(other, context)
|
||||
|
||||
c = self.__cmp__(other)
|
||||
c = self._cmp(other)
|
||||
if c == 0:
|
||||
c = self.compare_total(other)
|
||||
|
||||
|
|
@ -2553,23 +2618,10 @@ class Decimal(_numbers.Real, _numbers.Inexact):
|
|||
It's pretty much like compare(), but all NaNs signal, with signaling
|
||||
NaNs taking precedence over quiet NaNs.
|
||||
"""
|
||||
if context is None:
|
||||
context = getcontext()
|
||||
|
||||
self_is_nan = self._isnan()
|
||||
other_is_nan = other._isnan()
|
||||
if self_is_nan == 2:
|
||||
return context._raise_error(InvalidOperation, 'sNaN',
|
||||
self)
|
||||
if other_is_nan == 2:
|
||||
return context._raise_error(InvalidOperation, 'sNaN',
|
||||
other)
|
||||
if self_is_nan:
|
||||
return context._raise_error(InvalidOperation, 'NaN in compare_signal',
|
||||
self)
|
||||
if other_is_nan:
|
||||
return context._raise_error(InvalidOperation, 'NaN in compare_signal',
|
||||
other)
|
||||
other = _convert_other(other, raiseit = True)
|
||||
ans = self._compare_check_nans(other, context)
|
||||
if ans:
|
||||
return ans
|
||||
return self.compare(other, context=context)
|
||||
|
||||
def compare_total(self, other):
|
||||
|
|
@ -3076,7 +3128,7 @@ class Decimal(_numbers.Real, _numbers.Inexact):
|
|||
return other._fix_nan(context)
|
||||
return self._check_nans(other, context)
|
||||
|
||||
c = self.copy_abs().__cmp__(other.copy_abs())
|
||||
c = self.copy_abs()._cmp(other.copy_abs())
|
||||
if c == 0:
|
||||
c = self.compare_total(other)
|
||||
|
||||
|
|
@ -3106,7 +3158,7 @@ class Decimal(_numbers.Real, _numbers.Inexact):
|
|||
return other._fix_nan(context)
|
||||
return self._check_nans(other, context)
|
||||
|
||||
c = self.copy_abs().__cmp__(other.copy_abs())
|
||||
c = self.copy_abs()._cmp(other.copy_abs())
|
||||
if c == 0:
|
||||
c = self.compare_total(other)
|
||||
|
||||
|
|
@ -3181,7 +3233,7 @@ class Decimal(_numbers.Real, _numbers.Inexact):
|
|||
if ans:
|
||||
return ans
|
||||
|
||||
comparison = self.__cmp__(other)
|
||||
comparison = self._cmp(other)
|
||||
if comparison == 0:
|
||||
return self.copy_sign(other)
|
||||
|
||||
|
|
|
|||
|
|
@ -154,7 +154,10 @@ class Complex(Number):
|
|||
"""self == other"""
|
||||
raise NotImplementedError
|
||||
|
||||
# __ne__ is inherited from object and negates whatever __eq__ does.
|
||||
def __ne__(self, other):
|
||||
"""self != other"""
|
||||
# The default __ne__ doesn't negate __eq__ until 3.0.
|
||||
return not (self == other)
|
||||
|
||||
Complex.register(complex)
|
||||
|
||||
|
|
|
|||
|
|
@ -64,8 +64,10 @@ b"\x88\x91\xe5\x80\x91\xe6\x89\x80\x0a\xe8\xa6\x81\xe8\xa8\x8e\xe8"
|
|||
b"\xab\x96\xe7\x9a\x84\xe5\x95\x8f\xe9\xa1\x8c\xe5\xb0\xb1\xe6\x98"
|
||||
b"\xaf\x3a\x0a\x0a"),
|
||||
'big5hkscs': (
|
||||
b"\x88\x45\x88\x5c\x8a\x73\x8b\xda\x8d\xd8\x0a",
|
||||
b"\xf0\xa0\x84\x8c\xc4\x9a\xe9\xb5\xae\xe7\xbd\x93\xe6\xb4\x86\x0a"),
|
||||
b"\x88\x45\x88\x5c\x8a\x73\x8b\xda\x8d\xd8\x0a\x88\x66\x88\x62\x88"
|
||||
b"\xa7\x20\x88\xa7\x88\xa3\x0a",
|
||||
b"\xf0\xa0\x84\x8c\xc4\x9a\xe9\xb5\xae\xe7\xbd\x93\xe6\xb4\x86\x0a"
|
||||
b"\xc3\x8a\xc3\x8a\xcc\x84\xc3\xaa\x20\xc3\xaa\xc3\xaa\xcc\x84\x0a"),
|
||||
'cp949': (
|
||||
b"\x8c\x63\xb9\xe6\xb0\xa2\xc7\xcf\x20\xbc\x84\xbd\xc3\xc4\xdd\xb6"
|
||||
b"\xf3\x0a\x0a\xa8\xc0\xa8\xc0\xb3\xb3\x21\x21\x20\xec\xd7\xce\xfa"
|
||||
|
|
|
|||
|
|
@ -11,10 +11,11 @@ import unittest
|
|||
class TestBig5HKSCSMap(test_multibytecodec_support.TestBase_Mapping,
|
||||
unittest.TestCase):
|
||||
encoding = 'big5hkscs'
|
||||
mapfileurl = 'http://people.freebsd.org/~perky/i18n/BIG5HKSCS.TXT'
|
||||
mapfileurl = 'http://people.freebsd.org/~perky/i18n/BIG5HKSCS-2004.TXT'
|
||||
|
||||
def test_main():
|
||||
test_support.run_unittest(__name__)
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_support.use_resources = ['urlfetch']
|
||||
test_main()
|
||||
|
|
|
|||
|
|
@ -1,72 +1,53 @@
|
|||
from test.test_support import TestFailed
|
||||
from test.test_support import run_unittest
|
||||
import unittest
|
||||
|
||||
|
||||
class base_set:
|
||||
|
||||
def __init__(self, el):
|
||||
self.el = el
|
||||
|
||||
class set(base_set):
|
||||
|
||||
def __contains__(self, el):
|
||||
return self.el == el
|
||||
|
||||
class seq(base_set):
|
||||
|
||||
def __getitem__(self, n):
|
||||
return [self.el][n]
|
||||
|
||||
def check(ok, *args):
|
||||
if not ok:
|
||||
raise TestFailed(" ".join(map(str, args)))
|
||||
|
||||
class TestContains(unittest.TestCase):
|
||||
def test_common_tests(self):
|
||||
a = base_set(1)
|
||||
b = set(1)
|
||||
c = seq(1)
|
||||
self.assert_(1 in b)
|
||||
self.assert_(0 not in b)
|
||||
self.assert_(1 in c)
|
||||
self.assert_(0 not in c)
|
||||
self.assertRaises(TypeError, lambda: 1 in a)
|
||||
self.assertRaises(TypeError, lambda: 1 not in a)
|
||||
|
||||
check(1 in b, "1 not in set(1)")
|
||||
check(0 not in b, "0 in set(1)")
|
||||
check(1 in c, "1 not in seq(1)")
|
||||
check(0 not in c, "0 in seq(1)")
|
||||
# test char in string
|
||||
self.assert_('c' in 'abc')
|
||||
self.assert_('d' not in 'abc')
|
||||
|
||||
try:
|
||||
1 in a
|
||||
check(0, "in base_set did not raise error")
|
||||
except TypeError:
|
||||
pass
|
||||
self.assert_('' in '')
|
||||
self.assert_('' in 'abc')
|
||||
|
||||
try:
|
||||
1 not in a
|
||||
check(0, "not in base_set did not raise error")
|
||||
except TypeError:
|
||||
pass
|
||||
self.assertRaises(TypeError, lambda: None in 'abc')
|
||||
|
||||
# Test char in string
|
||||
|
||||
check('c' in 'abc', "'c' not in 'abc'")
|
||||
check('d' not in 'abc', "'d' in 'abc'")
|
||||
|
||||
check('' in '', "'' not in ''")
|
||||
check('' in 'abc', "'' not in 'abc'")
|
||||
|
||||
try:
|
||||
None in 'abc'
|
||||
check(0, "None in 'abc' did not raise error")
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
|
||||
# A collection of tests on builtin sequence types
|
||||
a = list(range(10))
|
||||
def test_builtin_sequence_types(self):
|
||||
# a collection of tests on builtin sequence types
|
||||
a = range(10)
|
||||
for i in a:
|
||||
check(i in a, "%r not in %r" % (i, a))
|
||||
check(16 not in a, "16 not in %r" % (a,))
|
||||
check(a not in a, "%s not in %r" % (a, a))
|
||||
self.assert_(i in a)
|
||||
self.assert_(16 not in a)
|
||||
self.assert_(a not in a)
|
||||
|
||||
a = tuple(a)
|
||||
for i in a:
|
||||
check(i in a, "%r not in %r" % (i, a))
|
||||
check(16 not in a, "16 not in %r" % (a,))
|
||||
check(a not in a, "%r not in %r" % (a, a))
|
||||
self.assert_(i in a)
|
||||
self.assert_(16 not in a)
|
||||
self.assert_(a not in a)
|
||||
|
||||
class Deviant1:
|
||||
"""Behaves strangely when compared
|
||||
|
|
@ -74,9 +55,7 @@ class Deviant1:
|
|||
This class is designed to make sure that the contains code
|
||||
works when the list is modified during the check.
|
||||
"""
|
||||
|
||||
aList = list(range(15))
|
||||
|
||||
aList = range(15)
|
||||
def __cmp__(self, other):
|
||||
if other == 12:
|
||||
self.aList.remove(12)
|
||||
|
|
@ -84,7 +63,7 @@ class Deviant1:
|
|||
self.aList.remove(14)
|
||||
return 1
|
||||
|
||||
check(Deviant1() not in Deviant1.aList, "Deviant1 failed")
|
||||
self.assert_(Deviant1() not in Deviant1.aList)
|
||||
|
||||
class Deviant2:
|
||||
"""Behaves strangely when compared
|
||||
|
|
@ -92,12 +71,18 @@ class Deviant2:
|
|||
This class raises an exception during comparison. That in
|
||||
turn causes the comparison to fail with a TypeError.
|
||||
"""
|
||||
|
||||
def __cmp__(self, other):
|
||||
if other == 4:
|
||||
raise RuntimeError("gotcha")
|
||||
|
||||
try:
|
||||
check(Deviant2() not in a, "oops")
|
||||
self.assert_(Deviant2() not in a)
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
|
||||
def test_main():
|
||||
run_unittest(TestContains)
|
||||
|
||||
if __name__ == '__main__':
|
||||
test_main()
|
||||
|
|
|
|||
|
|
@ -833,6 +833,19 @@ class DecimalArithmeticOperatorsTest(unittest.TestCase):
|
|||
self.assertEqual(-Decimal(45), Decimal(-45)) # -
|
||||
self.assertEqual(abs(Decimal(45)), abs(Decimal(-45))) # abs
|
||||
|
||||
def test_nan_comparisons(self):
|
||||
n = Decimal('NaN')
|
||||
s = Decimal('sNaN')
|
||||
i = Decimal('Inf')
|
||||
f = Decimal('2')
|
||||
for x, y in [(n, n), (n, i), (i, n), (n, f), (f, n),
|
||||
(s, n), (n, s), (s, i), (i, s), (s, f), (f, s), (s, s)]:
|
||||
self.assert_(x != y)
|
||||
self.assert_(not (x == y))
|
||||
self.assert_(not (x < y))
|
||||
self.assert_(not (x <= y))
|
||||
self.assert_(not (x > y))
|
||||
self.assert_(not (x >= y))
|
||||
|
||||
# The following are two functions used to test threading in the next class
|
||||
|
||||
|
|
@ -1137,7 +1150,12 @@ class DecimalUsabilityTest(unittest.TestCase):
|
|||
checkSameDec("__abs__")
|
||||
checkSameDec("__add__", True)
|
||||
checkSameDec("__divmod__", True)
|
||||
checkSameDec("__cmp__", True)
|
||||
checkSameDec("__eq__", True)
|
||||
checkSameDec("__ne__", True)
|
||||
checkSameDec("__le__", True)
|
||||
checkSameDec("__lt__", True)
|
||||
checkSameDec("__ge__", True)
|
||||
checkSameDec("__gt__", True)
|
||||
checkSameDec("__float__")
|
||||
checkSameDec("__floordiv__", True)
|
||||
checkSameDec("__hash__")
|
||||
|
|
|
|||
|
|
@ -141,6 +141,29 @@ class TestDefaultDict(unittest.TestCase):
|
|||
else:
|
||||
self.fail("expected KeyError")
|
||||
|
||||
def test_recursive_repr(self):
|
||||
# Issue2045: stack overflow when default_factory is a bound method
|
||||
class sub(defaultdict):
|
||||
def __init__(self):
|
||||
self.default_factory = self._factory
|
||||
def _factory(self):
|
||||
return []
|
||||
d = sub()
|
||||
self.assert_(repr(d).startswith(
|
||||
"defaultdict(<bound method sub._factory of defaultdict(..."))
|
||||
|
||||
# NOTE: printing a subclass of a builtin type does not call its
|
||||
# tp_print slot. So this part is essentially the same test as above.
|
||||
tfn = tempfile.mktemp()
|
||||
try:
|
||||
f = open(tfn, "w+")
|
||||
try:
|
||||
print(d, file=f)
|
||||
finally:
|
||||
f.close()
|
||||
finally:
|
||||
os.remove(tfn)
|
||||
|
||||
|
||||
def test_main():
|
||||
test_support.run_unittest(TestDefaultDict)
|
||||
|
|
|
|||
|
|
@ -196,7 +196,6 @@ class TestListReversed(TestInvariantWithoutMutations):
|
|||
self.assertEqual(len(it), 0)
|
||||
|
||||
|
||||
|
||||
def test_main():
|
||||
unittests = [
|
||||
TestRepeat,
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
#!python
|
||||
"""Test largefile support on system where this makes sense.
|
||||
"""
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# test largefile support on system where this makes sense
|
||||
#
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
from test import test_support
|
||||
import os, stat, sys
|
||||
import os
|
||||
import stat
|
||||
import sys
|
||||
import unittest
|
||||
from test.test_support import run_unittest, TESTFN, verbose, requires, \
|
||||
TestSkipped, unlink
|
||||
|
||||
try:
|
||||
import signal
|
||||
|
|
@ -17,154 +17,160 @@ try:
|
|||
except (ImportError, AttributeError):
|
||||
pass
|
||||
|
||||
|
||||
# create >2GB file (2GB = 2147483648 bytes)
|
||||
size = 2500000000
|
||||
name = test_support.TESTFN
|
||||
|
||||
|
||||
# On Windows and Mac OSX this test comsumes large resources; It takes
|
||||
# a long time to build the >2GB file and takes >2GB of disk space
|
||||
# therefore the resource must be enabled to run this test. If not,
|
||||
# nothing after this line stanza will be executed.
|
||||
if sys.platform[:3] == 'win' or sys.platform == 'darwin':
|
||||
test_support.requires(
|
||||
'largefile',
|
||||
'test requires %s bytes and a long time to run' % str(size))
|
||||
else:
|
||||
# Only run if the current filesystem supports large files.
|
||||
# (Skip this test on Windows, since we now always support large files.)
|
||||
f = open(test_support.TESTFN, 'wb')
|
||||
try:
|
||||
# 2**31 == 2147483648
|
||||
f.seek(2147483649)
|
||||
# Seeking is not enough of a test: you must write and flush, too!
|
||||
f.write(b"x")
|
||||
f.flush()
|
||||
except (IOError, OverflowError):
|
||||
f.close()
|
||||
os.unlink(test_support.TESTFN)
|
||||
raise test_support.TestSkipped(
|
||||
"filesystem does not have largefile support")
|
||||
else:
|
||||
f.close()
|
||||
class TestCase(unittest.TestCase):
|
||||
"""Test that each file function works as expected for a large
|
||||
(i.e. > 2GB, do we have to check > 4GB) files.
|
||||
"""
|
||||
|
||||
|
||||
def expect(got_this, expect_this):
|
||||
if test_support.verbose:
|
||||
print('%r =?= %r ...' % (got_this, expect_this), end=' ')
|
||||
if got_this != expect_this:
|
||||
if test_support.verbose:
|
||||
print('no')
|
||||
raise test_support.TestFailed('got %r, but expected %r'
|
||||
% (got_this, expect_this))
|
||||
else:
|
||||
if test_support.verbose:
|
||||
print('yes')
|
||||
|
||||
|
||||
# test that each file function works as expected for a large (i.e. >2GB, do
|
||||
# we have to check >4GB) files
|
||||
|
||||
if test_support.verbose:
|
||||
def test_seek(self):
|
||||
if verbose:
|
||||
print('create large file via seek (may be sparse file) ...')
|
||||
f = open(name, 'wb')
|
||||
f = open(TESTFN, 'wb')
|
||||
try:
|
||||
f.write(b'z')
|
||||
f.write('z')
|
||||
f.seek(0)
|
||||
f.seek(size)
|
||||
f.write(b'a')
|
||||
f.write('a')
|
||||
f.flush()
|
||||
if test_support.verbose:
|
||||
if verbose:
|
||||
print('check file size with os.fstat')
|
||||
expect(os.fstat(f.fileno())[stat.ST_SIZE], size+1)
|
||||
self.assertEqual(os.fstat(f.fileno())[stat.ST_SIZE], size+1)
|
||||
finally:
|
||||
f.close()
|
||||
if test_support.verbose:
|
||||
|
||||
def test_osstat(self):
|
||||
if verbose:
|
||||
print('check file size with os.stat')
|
||||
expect(os.stat(name)[stat.ST_SIZE], size+1)
|
||||
self.assertEqual(os.stat(TESTFN)[stat.ST_SIZE], size+1)
|
||||
|
||||
if test_support.verbose:
|
||||
def test_seek_read(self):
|
||||
if verbose:
|
||||
print('play around with seek() and read() with the built largefile')
|
||||
f = open(name, 'rb')
|
||||
f = open(TESTFN, 'rb')
|
||||
try:
|
||||
expect(f.tell(), 0)
|
||||
expect(f.read(1), b'z')
|
||||
expect(f.tell(), 1)
|
||||
self.assertEqual(f.tell(), 0)
|
||||
self.assertEqual(f.read(1), 'z')
|
||||
self.assertEqual(f.tell(), 1)
|
||||
f.seek(0)
|
||||
expect(f.tell(), 0)
|
||||
self.assertEqual(f.tell(), 0)
|
||||
f.seek(0, 0)
|
||||
expect(f.tell(), 0)
|
||||
self.assertEqual(f.tell(), 0)
|
||||
f.seek(42)
|
||||
expect(f.tell(), 42)
|
||||
self.assertEqual(f.tell(), 42)
|
||||
f.seek(42, 0)
|
||||
expect(f.tell(), 42)
|
||||
self.assertEqual(f.tell(), 42)
|
||||
f.seek(42, 1)
|
||||
expect(f.tell(), 84)
|
||||
self.assertEqual(f.tell(), 84)
|
||||
f.seek(0, 1)
|
||||
expect(f.tell(), 84)
|
||||
self.assertEqual(f.tell(), 84)
|
||||
f.seek(0, 2) # seek from the end
|
||||
expect(f.tell(), size + 1 + 0)
|
||||
self.assertEqual(f.tell(), size + 1 + 0)
|
||||
f.seek(-10, 2)
|
||||
expect(f.tell(), size + 1 - 10)
|
||||
self.assertEqual(f.tell(), size + 1 - 10)
|
||||
f.seek(-size-1, 2)
|
||||
expect(f.tell(), 0)
|
||||
self.assertEqual(f.tell(), 0)
|
||||
f.seek(size)
|
||||
expect(f.tell(), size)
|
||||
expect(f.read(1), b'a') # the 'a' that was written at the end of file above
|
||||
self.assertEqual(f.tell(), size)
|
||||
# the 'a' that was written at the end of file above
|
||||
self.assertEqual(f.read(1), 'a')
|
||||
f.seek(-size-1, 1)
|
||||
expect(f.read(1), b'z')
|
||||
expect(f.tell(), 1)
|
||||
self.assertEqual(f.read(1), 'z')
|
||||
self.assertEqual(f.tell(), 1)
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
if test_support.verbose:
|
||||
def test_lseek(self):
|
||||
if verbose:
|
||||
print('play around with os.lseek() with the built largefile')
|
||||
f = open(name, 'rb')
|
||||
f = open(TESTFN, 'rb')
|
||||
try:
|
||||
expect(os.lseek(f.fileno(), 0, 0), 0)
|
||||
expect(os.lseek(f.fileno(), 42, 0), 42)
|
||||
expect(os.lseek(f.fileno(), 42, 1), 84)
|
||||
expect(os.lseek(f.fileno(), 0, 1), 84)
|
||||
expect(os.lseek(f.fileno(), 0, 2), size+1+0)
|
||||
expect(os.lseek(f.fileno(), -10, 2), size+1-10)
|
||||
expect(os.lseek(f.fileno(), -size-1, 2), 0)
|
||||
expect(os.lseek(f.fileno(), size, 0), size)
|
||||
expect(f.read(1), b'a') # the 'a' that was written at the end of file above
|
||||
self.assertEqual(os.lseek(f.fileno(), 0, 0), 0)
|
||||
self.assertEqual(os.lseek(f.fileno(), 42, 0), 42)
|
||||
self.assertEqual(os.lseek(f.fileno(), 42, 1), 84)
|
||||
self.assertEqual(os.lseek(f.fileno(), 0, 1), 84)
|
||||
self.assertEqual(os.lseek(f.fileno(), 0, 2), size+1+0)
|
||||
self.assertEqual(os.lseek(f.fileno(), -10, 2), size+1-10)
|
||||
self.assertEqual(os.lseek(f.fileno(), -size-1, 2), 0)
|
||||
self.assertEqual(os.lseek(f.fileno(), size, 0), size)
|
||||
# the 'a' that was written at the end of file above
|
||||
self.assertEqual(f.read(1), 'a')
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
if hasattr(f, 'truncate'):
|
||||
if test_support.verbose:
|
||||
def test_truncate(self):
|
||||
if verbose:
|
||||
print('try truncate')
|
||||
f = open(name, 'r+b')
|
||||
f = open(TESTFN, 'r+b')
|
||||
# this is already decided before start running the test suite
|
||||
# but we do it anyway for extra protection
|
||||
if not hasattr(f, 'truncate'):
|
||||
raise TestSkipped("open().truncate() not available on this system")
|
||||
try:
|
||||
f.seek(0, 2)
|
||||
expect(f.tell(), size+1) # else we've lost track of the true size
|
||||
# else we've lost track of the true size
|
||||
self.assertEqual(f.tell(), size+1)
|
||||
# Cut it back via seek + truncate with no argument.
|
||||
newsize = size - 10
|
||||
f.seek(newsize)
|
||||
f.truncate()
|
||||
expect(f.tell(), newsize) # else pointer moved
|
||||
self.assertEqual(f.tell(), newsize) # else pointer moved
|
||||
f.seek(0, 2)
|
||||
expect(f.tell(), newsize) # else wasn't truncated
|
||||
# Ensure that truncate(smaller than true size) shrinks the file.
|
||||
self.assertEqual(f.tell(), newsize) # else wasn't truncated
|
||||
# Ensure that truncate(smaller than true size) shrinks
|
||||
# the file.
|
||||
newsize -= 1
|
||||
f.seek(42)
|
||||
f.truncate(newsize)
|
||||
expect(f.tell(), 42) # else pointer moved
|
||||
self.assertEqual(f.tell(), 42) # else pointer moved
|
||||
f.seek(0, 2)
|
||||
expect(f.tell(), newsize) # else wasn't truncated
|
||||
|
||||
# XXX truncate(larger than true size) is ill-defined across platforms
|
||||
|
||||
# cut it waaaaay back
|
||||
self.assertEqual(f.tell(), newsize) # else wasn't truncated
|
||||
# XXX truncate(larger than true size) is ill-defined
|
||||
# across platform; cut it waaaaay back
|
||||
f.seek(0)
|
||||
f.truncate(1)
|
||||
expect(f.tell(), 0) # else pointer moved
|
||||
expect(len(f.read()), 1) # else wasn't truncated
|
||||
|
||||
self.assertEqual(f.tell(), 0) # else pointer moved
|
||||
self.assertEqual(len(f.read()), 1) # else wasn't truncated
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
os.unlink(name)
|
||||
def main_test():
|
||||
# On Windows and Mac OSX this test comsumes large resources; It
|
||||
# takes a long time to build the >2GB file and takes >2GB of disk
|
||||
# space therefore the resource must be enabled to run this test.
|
||||
# If not, nothing after this line stanza will be executed.
|
||||
if sys.platform[:3] == 'win' or sys.platform == 'darwin':
|
||||
requires('largefile',
|
||||
'test requires %s bytes and a long time to run' % str(size))
|
||||
else:
|
||||
# Only run if the current filesystem supports large files.
|
||||
# (Skip this test on Windows, since we now always support
|
||||
# large files.)
|
||||
f = open(TESTFN, 'wb')
|
||||
try:
|
||||
# 2**31 == 2147483648
|
||||
f.seek(2147483649)
|
||||
# Seeking is not enough of a test: you must write and
|
||||
# flush, too!
|
||||
f.write("x")
|
||||
f.flush()
|
||||
except (IOError, OverflowError):
|
||||
f.close()
|
||||
unlink(TESTFN)
|
||||
raise TestSkipped("filesystem does not have largefile support")
|
||||
else:
|
||||
f.close()
|
||||
suite = unittest.TestSuite()
|
||||
suite.addTest(TestCase('test_seek'))
|
||||
suite.addTest(TestCase('test_osstat'))
|
||||
suite.addTest(TestCase('test_seek_read'))
|
||||
suite.addTest(TestCase('test_lseek'))
|
||||
f = open(TESTFN, 'w')
|
||||
if hasattr(f, 'truncate'):
|
||||
suite.addTest(TestCase('test_truncate'))
|
||||
|
||||
if __name__ == '__main__':
|
||||
main_test()
|
||||
|
|
|
|||
|
|
@ -328,6 +328,8 @@ class RationalTest(unittest.TestCase):
|
|||
self.assertFalse(R(2, 3) <= R(1, 2))
|
||||
self.assertTrue(R(1, 2) == R(1, 2))
|
||||
self.assertFalse(R(1, 2) == R(1, 3))
|
||||
self.assertFalse(R(1, 2) != R(1, 2))
|
||||
self.assertTrue(R(1, 2) != R(1, 3))
|
||||
|
||||
def testMixedLess(self):
|
||||
self.assertTrue(2 < R(5, 2))
|
||||
|
|
|
|||
|
|
@ -817,6 +817,8 @@ class HandlerTests(unittest.TestCase):
|
|||
method = getattr(h, "http_error_%s" % code)
|
||||
req = Request(from_url, data)
|
||||
req.add_header("Nonsense", "viking=withhold")
|
||||
if data is not None:
|
||||
req.add_header("Content-Length", str(len(data)))
|
||||
req.add_unredirected_header("Spam", "spam")
|
||||
try:
|
||||
method(req, MockFile(), code, "Blah",
|
||||
|
|
@ -829,6 +831,13 @@ class HandlerTests(unittest.TestCase):
|
|||
self.assertEqual(o.req.get_method(), "GET")
|
||||
except AttributeError:
|
||||
self.assert_(not o.req.has_data())
|
||||
|
||||
# now it's a GET, there should not be headers regarding content
|
||||
# (possibly dragged from before being a POST)
|
||||
headers = [x.lower() for x in o.req.headers]
|
||||
self.assertTrue("content-length" not in headers)
|
||||
self.assertTrue("content-type" not in headers)
|
||||
|
||||
self.assertEqual(o.req.headers["Nonsense"],
|
||||
"viking=withhold")
|
||||
self.assert_("Spam" not in o.req.headers)
|
||||
|
|
|
|||
|
|
@ -531,8 +531,11 @@ class HTTPRedirectHandler(BaseHandler):
|
|||
# do the same.
|
||||
# be conciliant with URIs containing a space
|
||||
newurl = newurl.replace(' ', '%20')
|
||||
newheaders = dict((k,v) for k,v in req.headers.items()
|
||||
if k.lower() not in ("content-length", "content-type")
|
||||
)
|
||||
return Request(newurl,
|
||||
headers=req.headers,
|
||||
headers=newheaders,
|
||||
origin_req_host=req.get_origin_req_host(),
|
||||
unverifiable=True)
|
||||
else:
|
||||
|
|
|
|||
|
|
@ -1209,16 +1209,32 @@ static PyObject *
|
|||
defdict_repr(defdictobject *dd)
|
||||
{
|
||||
PyObject *baserepr;
|
||||
PyObject *def;
|
||||
PyObject *defrepr;
|
||||
PyObject *result;
|
||||
baserepr = PyDict_Type.tp_repr((PyObject *)dd);
|
||||
if (baserepr == NULL)
|
||||
return NULL;
|
||||
if (dd->default_factory == NULL)
|
||||
def = Py_None;
|
||||
defrepr = PyUnicode_FromString("None");
|
||||
else
|
||||
def = dd->default_factory;
|
||||
result = PyUnicode_FromFormat("defaultdict(%R, %U)", def, baserepr);
|
||||
{
|
||||
int status = Py_ReprEnter(dd->default_factory);
|
||||
if (status != 0) {
|
||||
if (status < 0)
|
||||
return NULL;
|
||||
defrepr = PyUnicode_FromString("...");
|
||||
}
|
||||
else
|
||||
defrepr = PyObject_Repr(dd->default_factory);
|
||||
Py_ReprLeave(dd->default_factory);
|
||||
}
|
||||
if (defrepr == NULL) {
|
||||
Py_DECREF(baserepr);
|
||||
return NULL;
|
||||
}
|
||||
result = PyUnicode_FromFormat("defaultdict(%U, %U)",
|
||||
defrepr, baserepr);
|
||||
Py_DECREF(defrepr);
|
||||
Py_DECREF(baserepr);
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4814,11 +4814,48 @@ static PyTypeObject PyComError_Type = {
|
|||
static int
|
||||
create_comerror(void)
|
||||
{
|
||||
PyComError_Type.tp_base = (PyTypeObject*)PyExc_Exception;
|
||||
if (PyType_Ready(&PyComError_Type) < 0)
|
||||
PyObject *dict = PyDict_New();
|
||||
PyMethodDef *methods = comerror_methods;
|
||||
PyObject *s;
|
||||
int status;
|
||||
|
||||
if (dict == NULL)
|
||||
return -1;
|
||||
|
||||
while (methods->ml_name) {
|
||||
/* get a wrapper for the built-in function */
|
||||
PyObject *func = PyCFunction_New(methods, NULL);
|
||||
PyObject *meth;
|
||||
if (func == NULL)
|
||||
goto error;
|
||||
meth = PyMethod_New(func, NULL, ComError);
|
||||
Py_DECREF(func);
|
||||
if (meth == NULL)
|
||||
goto error;
|
||||
PyDict_SetItemString(dict, methods->ml_name, meth);
|
||||
Py_DECREF(meth);
|
||||
++methods;
|
||||
}
|
||||
|
||||
s = PyString_FromString(comerror_doc);
|
||||
if (s == NULL)
|
||||
goto error;
|
||||
ComError = (PyObject*)&PyComError_Type;
|
||||
status = PyDict_SetItemString(dict, "__doc__", s);
|
||||
Py_DECREF(s);
|
||||
if (status == -1)
|
||||
goto error;
|
||||
|
||||
ComError = PyErr_NewException("_ctypes.COMError",
|
||||
NULL,
|
||||
dict);
|
||||
if (ComError == NULL)
|
||||
goto error;
|
||||
|
||||
return 0;
|
||||
error:
|
||||
Py_DECREF(dict);
|
||||
return -1;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -146,7 +146,9 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
|
|||
case FFI_TYPE_SINT64:
|
||||
case FFI_TYPE_FLOAT:
|
||||
case FFI_TYPE_DOUBLE:
|
||||
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
||||
case FFI_TYPE_LONGDOUBLE:
|
||||
#endif
|
||||
cif->flags = (unsigned) cif->rtype->type;
|
||||
break;
|
||||
|
||||
|
|
|
|||
|
|
@ -26,6 +26,16 @@ CODEC_INIT(big5hkscs)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* There are four possible pair unicode -> big5hkscs maps as in HKSCS 2004:
|
||||
* U+00CA U+0304 -> 8862 (U+00CA alone is mapped to 8866)
|
||||
* U+00CA U+030C -> 8864
|
||||
* U+00EA U+0304 -> 88a3 (U+00EA alone is mapped to 88a7)
|
||||
* U+00EA U+030C -> 88a5
|
||||
* These are handled by not mapping tables but a hand-written code.
|
||||
*/
|
||||
static const DBCHAR big5hkscs_pairenc_table[4] = {0x8862, 0x8864, 0x88a3, 0x88a5};
|
||||
|
||||
ENCODER(big5hkscs)
|
||||
{
|
||||
while (inleft > 0) {
|
||||
|
|
@ -46,7 +56,27 @@ ENCODER(big5hkscs)
|
|||
REQUIRE_OUTBUF(2)
|
||||
|
||||
if (c < 0x10000) {
|
||||
TRYMAP_ENC(big5hkscs_bmp, code, c);
|
||||
TRYMAP_ENC(big5hkscs_bmp, code, c) {
|
||||
if (code == MULTIC) {
|
||||
if (inleft >= 2 &&
|
||||
((c & 0xffdf) == 0x00ca) &&
|
||||
(((*inbuf)[1] & 0xfff7) == 0x0304)) {
|
||||
code = big5hkscs_pairenc_table[
|
||||
((c >> 4) |
|
||||
((*inbuf)[1] >> 3)) & 3];
|
||||
insize = 2;
|
||||
}
|
||||
else if (inleft < 2 &&
|
||||
!(flags & MBENC_FLUSH))
|
||||
return MBERR_TOOFEW;
|
||||
else {
|
||||
if (c == 0xca)
|
||||
code = 0x8866;
|
||||
else /* c == 0xea */
|
||||
code = 0x88a7;
|
||||
}
|
||||
}
|
||||
}
|
||||
else TRYMAP_ENC(big5, code, c);
|
||||
else return 1;
|
||||
}
|
||||
|
|
@ -67,7 +97,7 @@ ENCODER(big5hkscs)
|
|||
return 0;
|
||||
}
|
||||
|
||||
#define BH2S(c1, c2) (((c1) - 0x88) * (0xfe - 0x40 + 1) + ((c2) - 0x40))
|
||||
#define BH2S(c1, c2) (((c1) - 0x87) * (0xfe - 0x40 + 1) + ((c2) - 0x40))
|
||||
|
||||
DECODER(big5hkscs)
|
||||
{
|
||||
|
|
@ -96,19 +126,19 @@ hkscsdec: TRYMAP_DEC(big5hkscs, decoded, c, IN2) {
|
|||
int s = BH2S(c, IN2);
|
||||
const unsigned char *hintbase;
|
||||
|
||||
assert(0x88 <= c && c <= 0xfe);
|
||||
assert(0x87 <= c && c <= 0xfe);
|
||||
assert(0x40 <= IN2 && IN2 <= 0xfe);
|
||||
|
||||
if (BH2S(0x88, 0x40) <= s && s <= BH2S(0xa0, 0xfe)) {
|
||||
if (BH2S(0x87, 0x40) <= s && s <= BH2S(0xa0, 0xfe)) {
|
||||
hintbase = big5hkscs_phint_0;
|
||||
s -= BH2S(0x88, 0x40);
|
||||
s -= BH2S(0x87, 0x40);
|
||||
}
|
||||
else if (BH2S(0xc6,0xa1) <= s && s <= BH2S(0xc8,0xfe)){
|
||||
hintbase = big5hkscs_phint_11939;
|
||||
hintbase = big5hkscs_phint_12130;
|
||||
s -= BH2S(0xc6, 0xa1);
|
||||
}
|
||||
else if (BH2S(0xf9,0xd6) <= s && s <= BH2S(0xfe,0xfe)){
|
||||
hintbase = big5hkscs_phint_21733;
|
||||
hintbase = big5hkscs_phint_21924;
|
||||
s -= BH2S(0xf9, 0xd6);
|
||||
}
|
||||
else
|
||||
|
|
@ -123,7 +153,17 @@ hkscsdec: TRYMAP_DEC(big5hkscs, decoded, c, IN2) {
|
|||
NEXT(2, 1)
|
||||
}
|
||||
}
|
||||
else return 2;
|
||||
else {
|
||||
switch ((c << 8) | IN2) {
|
||||
case 0x8862: WRITE2(0x00ca, 0x0304); break;
|
||||
case 0x8864: WRITE2(0x00ca, 0x030c); break;
|
||||
case 0x88a3: WRITE2(0x00ea, 0x0304); break;
|
||||
case 0x88a5: WRITE2(0x00ea, 0x030c); break;
|
||||
default: return 2;
|
||||
}
|
||||
|
||||
NEXT(2, 2) /* all decoded codepoints are pairs, above. */
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -163,6 +163,22 @@ show_counts(void)
|
|||
}
|
||||
#endif
|
||||
|
||||
/* Debug statistic to compare allocations with reuse through the free list */
|
||||
#undef SHOW_ALLOC_COUNT
|
||||
#ifdef SHOW_ALLOC_COUNT
|
||||
static size_t count_alloc = 0;
|
||||
static size_t count_reuse = 0;
|
||||
|
||||
static void
|
||||
show_alloc(void)
|
||||
{
|
||||
fprintf(stderr, "Dict allocations: %zd\n", count_alloc);
|
||||
fprintf(stderr, "Dict reuse through freelist: %zd\n", count_reuse);
|
||||
fprintf(stderr, "%.2f%% reuse rate\n\n",
|
||||
(100.0*count_reuse/(count_alloc+count_reuse)));
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Initialization macros.
|
||||
There are two ways to create a dict: PyDict_New() is the main C API
|
||||
function, and the tp_new slot maps to dict_new(). In the latter case we
|
||||
|
|
@ -190,6 +206,18 @@ show_counts(void)
|
|||
static PyDictObject *free_list[PyDict_MAXFREELIST];
|
||||
static int numfree = 0;
|
||||
|
||||
void
|
||||
PyDict_Fini(void)
|
||||
{
|
||||
PyDictObject *op;
|
||||
|
||||
while (numfree) {
|
||||
op = free_list[--numfree];
|
||||
assert(PyDict_CheckExact(op));
|
||||
PyObject_GC_Del(op);
|
||||
}
|
||||
}
|
||||
|
||||
PyObject *
|
||||
PyDict_New(void)
|
||||
{
|
||||
|
|
@ -200,6 +228,9 @@ PyDict_New(void)
|
|||
return NULL;
|
||||
#ifdef SHOW_CONVERSION_COUNTS
|
||||
Py_AtExit(show_counts);
|
||||
#endif
|
||||
#ifdef SHOW_ALLOC_COUNT
|
||||
Py_AtExit(show_alloc);
|
||||
#endif
|
||||
}
|
||||
if (numfree) {
|
||||
|
|
@ -213,11 +244,17 @@ PyDict_New(void)
|
|||
assert (mp->ma_used == 0);
|
||||
assert (mp->ma_table == mp->ma_smalltable);
|
||||
assert (mp->ma_mask == PyDict_MINSIZE - 1);
|
||||
#ifdef SHOW_ALLOC_COUNT
|
||||
count_reuse++;
|
||||
#endif
|
||||
} else {
|
||||
mp = PyObject_GC_New(PyDictObject, &PyDict_Type);
|
||||
if (mp == NULL)
|
||||
return NULL;
|
||||
EMPTY_TO_MINSIZE(mp);
|
||||
#ifdef SHOW_ALLOC_COUNT
|
||||
count_alloc++;
|
||||
#endif
|
||||
}
|
||||
mp->ma_lookup = lookdict_unicode;
|
||||
#ifdef SHOW_CONVERSION_COUNTS
|
||||
|
|
|
|||
|
|
@ -63,6 +63,22 @@ list_resize(PyListObject *self, Py_ssize_t newsize)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* Debug statistic to compare allocations with reuse through the free list */
|
||||
#undef SHOW_ALLOC_COUNT
|
||||
#ifdef SHOW_ALLOC_COUNT
|
||||
static size_t count_alloc = 0;
|
||||
static size_t count_reuse = 0;
|
||||
|
||||
static void
|
||||
show_alloc(void)
|
||||
{
|
||||
fprintf(stderr, "List allocations: %zd\n", count_alloc);
|
||||
fprintf(stderr, "List reuse through freelist: %zd\n", count_reuse);
|
||||
fprintf(stderr, "%.2f%% reuse rate\n\n",
|
||||
(100.0*count_reuse/(count_alloc+count_reuse)));
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Empty list reuse scheme to save calls to malloc and free */
|
||||
#ifndef PyList_MAXFREELIST
|
||||
#define PyList_MAXFREELIST 80
|
||||
|
|
@ -76,8 +92,7 @@ PyList_Fini(void)
|
|||
PyListObject *op;
|
||||
|
||||
while (numfree) {
|
||||
numfree--;
|
||||
op = free_list[numfree];
|
||||
op = free_list[--numfree];
|
||||
assert(PyList_CheckExact(op));
|
||||
PyObject_GC_Del(op);
|
||||
}
|
||||
|
|
@ -88,6 +103,13 @@ PyList_New(Py_ssize_t size)
|
|||
{
|
||||
PyListObject *op;
|
||||
size_t nbytes;
|
||||
#ifdef SHOW_ALLOC_COUNT
|
||||
static int initialized = 0;
|
||||
if (!initialized) {
|
||||
Py_AtExit(show_alloc);
|
||||
initialized = 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (size < 0) {
|
||||
PyErr_BadInternalCall();
|
||||
|
|
@ -101,10 +123,16 @@ PyList_New(Py_ssize_t size)
|
|||
numfree--;
|
||||
op = free_list[numfree];
|
||||
_Py_NewReference((PyObject *)op);
|
||||
#ifdef SHOW_ALLOC_COUNT
|
||||
count_reuse++;
|
||||
#endif
|
||||
} else {
|
||||
op = PyObject_GC_New(PyListObject, &PyList_Type);
|
||||
if (op == NULL)
|
||||
return NULL;
|
||||
#ifdef SHOW_ALLOC_COUNT
|
||||
count_alloc++;
|
||||
#endif
|
||||
}
|
||||
if (size <= 0)
|
||||
op->ob_item = NULL;
|
||||
|
|
|
|||
|
|
@ -405,9 +405,9 @@ compiler_unit_check(struct compiler_unit *u)
|
|||
{
|
||||
basicblock *block;
|
||||
for (block = u->u_blocks; block != NULL; block = block->b_list) {
|
||||
assert(block != (void *)0xcbcbcbcb);
|
||||
assert(block != (void *)0xfbfbfbfb);
|
||||
assert(block != (void *)0xdbdbdbdb);
|
||||
assert((void *)block != (void *)0xcbcbcbcb);
|
||||
assert((void *)block != (void *)0xfbfbfbfb);
|
||||
assert((void *)block != (void *)0xdbdbdbdb);
|
||||
if (block->b_instr != NULL) {
|
||||
assert(block->b_ialloc > 0);
|
||||
assert(block->b_iused > 0);
|
||||
|
|
|
|||
|
|
@ -504,6 +504,7 @@ Py_Finalize(void)
|
|||
PyBytes_Fini();
|
||||
PyLong_Fini();
|
||||
PyFloat_Fini();
|
||||
PyDict_Fini();
|
||||
|
||||
/* Cleanup Unicode implementation */
|
||||
_PyUnicode_Fini();
|
||||
|
|
|
|||
|
|
@ -44,11 +44,11 @@
|
|||
I do know about <values.h>, but the whole point of this file is that
|
||||
we can't always trust that stuff to be there or to be correct.
|
||||
*/
|
||||
static int MDMINEXPT = {-323};
|
||||
static int MDMINEXPT = -323;
|
||||
static char MDMINFRAC[] = "494065645841246544";
|
||||
static double ZERO = 0.0;
|
||||
|
||||
static int MDMAXEXPT = { 309};
|
||||
static int MDMAXEXPT = 309;
|
||||
static char MDMAXFRAC[] = "17976931348623157";
|
||||
static double HUGE = 1.7976931348623157e308;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue