Index: Python/Python-ast.c =================================================================== --- Python/Python-ast.c (Revision 52821) +++ Python/Python-ast.c (Arbeitskopie) @@ -3008,7 +3008,7 @@ if (PyDict_SetItemString(d, "AST", (PyObject*)AST_type) < 0) return; if (PyModule_AddIntConstant(m, "PyCF_ONLY_AST", PyCF_ONLY_AST) < 0) return; - if (PyModule_AddStringConstant(m, "__version__", "51773") < 0) + if (PyModule_AddStringConstant(m, "__version__", "52491") < 0) return; if (PyDict_SetItemString(d, "mod", (PyObject*)mod_type) < 0) return; if (PyDict_SetItemString(d, "Module", (PyObject*)Module_type) < 0) Index: Include/object.h =================================================================== --- Include/object.h (Revision 52821) +++ Include/object.h (Arbeitskopie) @@ -160,7 +160,7 @@ unaryfunc nb_negative; unaryfunc nb_positive; unaryfunc nb_absolute; - inquiry nb_nonzero; + inquiry nb_bool; unaryfunc nb_invert; binaryfunc nb_lshift; binaryfunc nb_rshift; Index: Demo/classes/Rat.py =================================================================== --- Demo/classes/Rat.py (Revision 52821) +++ Demo/classes/Rat.py (Arbeitskopie) @@ -223,7 +223,7 @@ return cmp(Rat(a), b) # a != 0 - def __nonzero__(a): + def __bool__(a): return a.__num != 0 # coercion Index: Demo/classes/Complex.py =================================================================== --- Demo/classes/Complex.py (Revision 52821) +++ Demo/classes/Complex.py (Arbeitskopie) @@ -165,7 +165,7 @@ other = ToComplex(other) return cmp(other, self) - def __nonzero__(self): + def __bool__(self): return not (self.re == self.im == 0) abs = radius = __abs__ Index: Objects/complexobject.c =================================================================== --- Objects/complexobject.c (Revision 52821) +++ Objects/complexobject.c (Arbeitskopie) @@ -568,7 +568,7 @@ } static int -complex_nonzero(PyComplexObject *v) +complex_bool(PyComplexObject *v) { return v->cval.real != 0.0 || v->cval.imag != 0.0; } @@ -938,7 +938,7 @@ (unaryfunc)complex_neg, /* nb_negative */ (unaryfunc)complex_pos, /* nb_positive */ (unaryfunc)complex_abs, /* nb_absolute */ - (inquiry)complex_nonzero, /* nb_nonzero */ + (inquiry)complex_bool, /* nb_bool */ 0, /* nb_invert */ 0, /* nb_lshift */ 0, /* nb_rshift */ Index: Objects/object.c =================================================================== --- Objects/object.c (Revision 52821) +++ Objects/object.c (Arbeitskopie) @@ -1246,8 +1246,8 @@ if (v == Py_None) return 0; else if (v->ob_type->tp_as_number != NULL && - v->ob_type->tp_as_number->nb_nonzero != NULL) - res = (*v->ob_type->tp_as_number->nb_nonzero)(v); + v->ob_type->tp_as_number->nb_bool != NULL) + res = (*v->ob_type->tp_as_number->nb_bool)(v); else if (v->ob_type->tp_as_mapping != NULL && v->ob_type->tp_as_mapping->mp_length != NULL) res = (*v->ob_type->tp_as_mapping->mp_length)(v); Index: Objects/typeobject.c =================================================================== --- Objects/typeobject.c (Revision 52821) +++ Objects/typeobject.c (Arbeitskopie) @@ -2928,7 +2928,7 @@ COPYNUM(nb_negative); COPYNUM(nb_positive); COPYNUM(nb_absolute); - COPYNUM(nb_nonzero); + COPYNUM(nb_bool); COPYNUM(nb_invert); COPYNUM(nb_lshift); COPYNUM(nb_rshift); @@ -4206,39 +4206,66 @@ SLOT0(slot_nb_absolute, "__abs__") static int -slot_nb_nonzero(PyObject *self) +slot_nb_bool(PyObject *self) { - PyObject *func, *args; - static PyObject *nonzero_str, *len_str; + static PyObject *bool_str = NULL, *len_str = NULL; + PyObject *func, *args, *temp; int result = -1; - - func = lookup_maybe(self, "__nonzero__", &nonzero_str); - if (func == NULL) { - if (PyErr_Occurred()) - return -1; - func = lookup_maybe(self, "__len__", &len_str); - if (func == NULL) - return PyErr_Occurred() ? -1 : 1; - } - args = PyTuple_New(0); - if (args != NULL) { - PyObject *temp = PyObject_Call(func, args, NULL); - Py_DECREF(args); - if (temp != NULL) { - if (PyInt_CheckExact(temp) || PyBool_Check(temp)) + + /* + * [tomer] there's some code duplication, but it can't be completely + * avoided, as we have different treatment for __bool__ and __len__. + * anyway, i figured it's important to keep this function as fast as + * possible, since it's invoked very often. + */ + + /* first see if it has __bool__ */ + func = lookup_maybe(self, "__bool__", &bool_str); + if (func == NULL && PyErr_Occurred()) { + return -1; + } + else { + args = PyTuple_New(0); + if (args != NULL) { + temp = PyObject_Call(func, args, NULL); + if (temp != NULL) { + if (PyBool_Check(temp)) { + result = PyObject_IsTrue(temp); + } + else { + PyErr_Format(PyExc_TypeError, + "__bool__ must return a bool, not %.200s", + temp->ob_type->tp_name); + } + Py_DECREF(temp); + } + Py_DECREF(args); + } + Py_DECREF(func); + return result; + } + + /* maybe it has __len__ */ + func = lookup_maybe(self, "__len__", &len_str); + if (func == NULL && PyErr_Occurred()) { + return -1; + } + else { + args = PyTuple_New(0); + if (args != NULL) { + temp = PyObject_Call(func, args, NULL); + if (temp != NULL) { result = PyObject_IsTrue(temp); - else { - PyErr_Format(PyExc_TypeError, - "__nonzero__ should return " - "bool or int, returned %s", - temp->ob_type->tp_name); - result = -1; + Py_DECREF(temp); } - Py_DECREF(temp); + Py_DECREF(args); } + Py_DECREF(func); + return result; } - Py_DECREF(func); - return result; + + /* all objects are True unless proven guilty */ + return 1; } @@ -4887,7 +4914,7 @@ UNSLOT("__pos__", nb_positive, slot_nb_positive, wrap_unaryfunc, "+x"), UNSLOT("__abs__", nb_absolute, slot_nb_absolute, wrap_unaryfunc, "abs(x)"), - UNSLOT("__nonzero__", nb_nonzero, slot_nb_nonzero, wrap_inquirypred, + UNSLOT("__bool__", nb_bool, slot_nb_bool, wrap_inquirypred, "x != 0"), UNSLOT("__invert__", nb_invert, slot_nb_invert, wrap_unaryfunc, "~x"), BINSLOT("__lshift__", nb_lshift, slot_nb_lshift, "<<"), Index: Objects/weakrefobject.c =================================================================== --- Objects/weakrefobject.c (Revision 52821) +++ Objects/weakrefobject.c (Arbeitskopie) @@ -499,7 +499,7 @@ WRAP_BINARY(proxy_ior, PyNumber_InPlaceOr) static int -proxy_nonzero(PyWeakReference *proxy) +proxy_bool(PyWeakReference *proxy) { PyObject *o = PyWeakref_GET_OBJECT(proxy); if (!proxy_checkref(proxy)) @@ -596,7 +596,7 @@ proxy_neg, /*nb_negative*/ proxy_pos, /*nb_positive*/ proxy_abs, /*nb_absolute*/ - (inquiry)proxy_nonzero, /*nb_nonzero*/ + (inquiry)proxy_bool, /*nb_bool*/ proxy_invert, /*nb_invert*/ proxy_lshift, /*nb_lshift*/ proxy_rshift, /*nb_rshift*/ Index: Objects/intobject.c =================================================================== --- Objects/intobject.c (Revision 52821) +++ Objects/intobject.c (Arbeitskopie) @@ -780,7 +780,7 @@ } static int -int_nonzero(PyIntObject *v) +int_bool(PyIntObject *v) { return v->ob_ival != 0; } @@ -1034,14 +1034,14 @@ (unaryfunc)int_neg, /*nb_negative*/ (unaryfunc)int_pos, /*nb_positive*/ (unaryfunc)int_abs, /*nb_absolute*/ - (inquiry)int_nonzero, /*nb_nonzero*/ + (inquiry)int_bool, /*nb_bool*/ (unaryfunc)int_invert, /*nb_invert*/ (binaryfunc)int_lshift, /*nb_lshift*/ (binaryfunc)int_rshift, /*nb_rshift*/ (binaryfunc)int_and, /*nb_and*/ (binaryfunc)int_xor, /*nb_xor*/ (binaryfunc)int_or, /*nb_or*/ - 0, /*nb_coerce*/ + 0, /*nb_coerce*/ (unaryfunc)int_int, /*nb_int*/ (unaryfunc)int_long, /*nb_long*/ (unaryfunc)int_float, /*nb_float*/ Index: Objects/boolobject.c =================================================================== --- Objects/boolobject.c (Revision 52821) +++ Objects/boolobject.c (Arbeitskopie) @@ -112,7 +112,7 @@ 0, /* nb_negative */ 0, /* nb_positive */ 0, /* nb_absolute */ - 0, /* nb_nonzero */ + 0, /* nb_bool */ 0, /* nb_invert */ 0, /* nb_lshift */ 0, /* nb_rshift */ Index: Objects/setobject.c =================================================================== --- Objects/setobject.c (Revision 52821) +++ Objects/setobject.c (Arbeitskopie) @@ -1784,7 +1784,7 @@ 0, /*nb_negative*/ 0, /*nb_positive*/ 0, /*nb_absolute*/ - 0, /*nb_nonzero*/ + 0, /*nb_bool*/ 0, /*nb_invert*/ 0, /*nb_lshift*/ 0, /*nb_rshift*/ @@ -1894,7 +1894,7 @@ 0, /*nb_negative*/ 0, /*nb_positive*/ 0, /*nb_absolute*/ - 0, /*nb_nonzero*/ + 0, /*nb_bool*/ 0, /*nb_invert*/ 0, /*nb_lshift*/ 0, /*nb_rshift*/ Index: Objects/longobject.c =================================================================== --- Objects/longobject.c (Revision 52821) +++ Objects/longobject.c (Arbeitskopie) @@ -2886,7 +2886,7 @@ } static int -long_nonzero(PyLongObject *v) +long_bool(PyLongObject *v) { return ABS(v->ob_size) != 0; } @@ -3298,43 +3298,43 @@ converting a non-string."); static PyNumberMethods long_as_number = { - (binaryfunc) long_add, /*nb_add*/ - (binaryfunc) long_sub, /*nb_subtract*/ - (binaryfunc) long_mul, /*nb_multiply*/ - long_mod, /*nb_remainder*/ - long_divmod, /*nb_divmod*/ - long_pow, /*nb_power*/ - (unaryfunc) long_neg, /*nb_negative*/ - (unaryfunc) long_pos, /*tp_positive*/ - (unaryfunc) long_abs, /*tp_absolute*/ - (inquiry) long_nonzero, /*tp_nonzero*/ - (unaryfunc) long_invert, /*nb_invert*/ - long_lshift, /*nb_lshift*/ - (binaryfunc) long_rshift, /*nb_rshift*/ - long_and, /*nb_and*/ - long_xor, /*nb_xor*/ - long_or, /*nb_or*/ - 0, /*nb_coerce*/ - long_int, /*nb_int*/ - long_long, /*nb_long*/ - long_float, /*nb_float*/ - long_oct, /*nb_oct*/ - long_hex, /*nb_hex*/ - 0, /* nb_inplace_add */ - 0, /* nb_inplace_subtract */ - 0, /* nb_inplace_multiply */ - 0, /* nb_inplace_remainder */ - 0, /* nb_inplace_power */ - 0, /* nb_inplace_lshift */ - 0, /* nb_inplace_rshift */ - 0, /* nb_inplace_and */ - 0, /* nb_inplace_xor */ - 0, /* nb_inplace_or */ - long_div, /* nb_floor_divide */ - long_true_divide, /* nb_true_divide */ - 0, /* nb_inplace_floor_divide */ - 0, /* nb_inplace_true_divide */ - long_long, /* nb_index */ + (binaryfunc)long_add, /*nb_add*/ + (binaryfunc)long_sub, /*nb_subtract*/ + (binaryfunc)long_mul, /*nb_multiply*/ + long_mod, /*nb_remainder*/ + long_divmod, /*nb_divmod*/ + long_pow, /*nb_power*/ + (unaryfunc) long_neg, /*nb_negative*/ + (unaryfunc) long_pos, /*tp_positive*/ + (unaryfunc) long_abs, /*tp_absolute*/ + (inquiry)long_bool, /*nb_bool*/ + (unaryfunc)long_invert, /*nb_invert*/ + long_lshift, /*nb_lshift*/ + (binaryfunc)long_rshift,/*nb_rshift*/ + long_and, /*nb_and*/ + long_xor, /*nb_xor*/ + long_or, /*nb_or*/ + 0, /*nb_coerce*/ + long_int, /*nb_int*/ + long_long, /*nb_long*/ + long_float, /*nb_float*/ + long_oct, /*nb_oct*/ + long_hex, /*nb_hex*/ + 0, /* nb_inplace_add */ + 0, /* nb_inplace_subtract */ + 0, /* nb_inplace_multiply */ + 0, /* nb_inplace_remainder */ + 0, /* nb_inplace_power */ + 0, /* nb_inplace_lshift */ + 0, /* nb_inplace_rshift */ + 0, /* nb_inplace_and */ + 0, /* nb_inplace_xor */ + 0, /* nb_inplace_or */ + long_div, /* nb_floor_divide */ + long_true_divide, /* nb_true_divide */ + 0, /* nb_inplace_floor_divide */ + 0, /* nb_inplace_true_divide */ + long_long, /* nb_index */ }; PyTypeObject PyLong_Type = { Index: Objects/floatobject.c =================================================================== --- Objects/floatobject.c (Revision 52821) +++ Objects/floatobject.c (Arbeitskopie) @@ -837,7 +837,7 @@ } static int -float_nonzero(PyFloatObject *v) +float_bool(PyFloatObject *v) { return v->ob_fval != 0.0; } @@ -1087,7 +1087,7 @@ (unaryfunc)float_neg, /*nb_negative*/ (unaryfunc)float_pos, /*nb_positive*/ (unaryfunc)float_abs, /*nb_absolute*/ - (inquiry)float_nonzero, /*nb_nonzero*/ + (inquiry)float_bool, /*nb_bool*/ 0, /*nb_invert*/ 0, /*nb_lshift*/ 0, /*nb_rshift*/ Index: PC/_winreg.c =================================================================== --- PC/_winreg.c (Revision 52821) +++ PC/_winreg.c (Arbeitskopie) @@ -305,7 +305,7 @@ "handle - The integer Win32 handle.\n" "\n" "Operations:\n" -"__nonzero__ - Handles with an open object return true, otherwise false.\n" +"__bool__ - Handles with an open object return true, otherwise false.\n" "__int__ - Converting a handle to an integer returns the Win32 handle.\n" "__cmp__ - Handle objects are compared using the handle value."); @@ -375,7 +375,7 @@ } static int -PyHKEY_nonzeroFunc(PyObject *ob) +PyHKEY_boolFunc(PyObject *ob) { return ((PyHKEYObject *)ob)->hkey != 0; } @@ -437,7 +437,7 @@ PyHKEY_unaryFailureFunc, /* nb_negative */ PyHKEY_unaryFailureFunc, /* nb_positive */ PyHKEY_unaryFailureFunc, /* nb_absolute */ - PyHKEY_nonzeroFunc, /* nb_nonzero */ + PyHKEY_boolFunc, /* nb_bool */ PyHKEY_unaryFailureFunc, /* nb_invert */ PyHKEY_binaryFailureFunc, /* nb_lshift */ PyHKEY_binaryFailureFunc, /* nb_rshift */ Index: Doc/lib/liboperator.tex =================================================================== --- Doc/lib/liboperator.tex (Revision 52821) +++ Doc/lib/liboperator.tex (Arbeitskopie) @@ -55,7 +55,7 @@ Return the outcome of \keyword{not} \var{o}. (Note that there is no \method{__not__()} method for object instances; only the interpreter core defines this operation. The result is affected by the -\method{__nonzero__()} and \method{__len__()} methods.) +\method{__bool__()} and \method{__len__()} methods.) \end{funcdesc} \begin{funcdesc}{truth}{o} Index: Doc/lib/libwinreg.tex =================================================================== --- Doc/lib/libwinreg.tex (Revision 52821) +++ Doc/lib/libwinreg.tex (Arbeitskopie) @@ -375,7 +375,7 @@ also accept an integer, however, use of the handle object is encouraged. - Handle objects provide semantics for \method{__nonzero__()} - thus + Handle objects provide semantics for \method{__bool__()} - thus \begin{verbatim} if handle: print "Yes" Index: Doc/lib/libxmlrpclib.tex =================================================================== --- Doc/lib/libxmlrpclib.tex (Revision 52821) +++ Doc/lib/libxmlrpclib.tex (Arbeitskopie) @@ -171,7 +171,7 @@ This class may be initialized from any Python value; the instance returned depends only on its truth value. It supports various Python operators through \method{__cmp__()}, \method{__repr__()}, -\method{__int__()}, and \method{__nonzero__()} methods, all +\method{__int__()}, and \method{__bool__()} methods, all implemented in the obvious ways. It also has the following method, supported mainly for internal use by Index: Doc/lib/libtimeit.tex =================================================================== --- Doc/lib/libtimeit.tex (Revision 52821) +++ Doc/lib/libtimeit.tex (Arbeitskopie) @@ -162,13 +162,13 @@ missing and present object attributes. \begin{verbatim} -% timeit.py 'try:' ' str.__nonzero__' 'except AttributeError:' ' pass' +% timeit.py 'try:' ' str.__bool__' 'except AttributeError:' ' pass' 100000 loops, best of 3: 15.7 usec per loop -% timeit.py 'if hasattr(str, "__nonzero__"): pass' +% timeit.py 'if hasattr(str, "__bool__"): pass' 100000 loops, best of 3: 4.26 usec per loop -% timeit.py 'try:' ' int.__nonzero__' 'except AttributeError:' ' pass' +% timeit.py 'try:' ' int.__bool__' 'except AttributeError:' ' pass' 1000000 loops, best of 3: 1.43 usec per loop -% timeit.py 'if hasattr(int, "__nonzero__"): pass' +% timeit.py 'if hasattr(int, "__bool__"): pass' 100000 loops, best of 3: 2.23 usec per loop \end{verbatim} @@ -176,7 +176,7 @@ >>> import timeit >>> s = """\ ... try: -... str.__nonzero__ +... str.__bool__ ... except AttributeError: ... pass ... """ @@ -184,14 +184,14 @@ >>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000) 17.09 usec/pass >>> s = """\ -... if hasattr(str, '__nonzero__'): pass +... if hasattr(str, '__bool__'): pass ... """ >>> t = timeit.Timer(stmt=s) >>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000) 4.85 usec/pass >>> s = """\ ... try: -... int.__nonzero__ +... int.__bool__ ... except AttributeError: ... pass ... """ @@ -199,7 +199,7 @@ >>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000) 1.97 usec/pass >>> s = """\ -... if hasattr(int, '__nonzero__'): pass +... if hasattr(int, '__bool__'): pass ... """ >>> t = timeit.Timer(stmt=s) >>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000) Index: Doc/lib/libstdtypes.tex =================================================================== --- Doc/lib/libstdtypes.tex (Revision 52821) +++ Doc/lib/libstdtypes.tex (Arbeitskopie) @@ -51,7 +51,7 @@ \item any empty mapping, for example, \code{\{\}}. \item instances of user-defined classes, if the class defines a - \method{__nonzero__()} or \method{__len__()} method, when that + \method{__bool__()} or \method{__len__()} method, when that method returns the integer zero or \class{bool} value \code{False}.\footnote{Additional information on these special methods may be found in the Index: Doc/ref/ref3.tex =================================================================== --- Doc/ref/ref3.tex (Revision 52821) +++ Doc/ref/ref3.tex (Arbeitskopie) @@ -1313,13 +1313,13 @@ \withsubitem{(object method)}{\ttindex{__cmp__()}} \end{methoddesc} -\begin{methoddesc}[object]{__nonzero__}{self} +\begin{methoddesc}[object]{__bool__}{self} Called to implement truth value testing, and the built-in operation -\code{bool()}; should return \code{False} or \code{True}, or their -integer equivalents \code{0} or \code{1}. +\code{bool()}; should return \code{False} or \code{True}. When this method is not defined, \method{__len__()} is -called, if it is defined (see below). If a class defines neither -\method{__len__()} nor \method{__nonzero__()}, all its instances are +called, if it is defined (see below) and \code{True} is returned when +the length is not zero. If a class defines neither +\method{__len__()} nor \method{__bool__()}, all its instances are considered true. \withsubitem{(mapping object method)}{\ttindex{__len__()}} \end{methoddesc} @@ -1693,9 +1693,9 @@ Called to implement the built-in function \function{len()}\bifuncindex{len}. Should return the length of the object, an integer \code{>=} 0. Also, an object that doesn't define a -\method{__nonzero__()} method and whose \method{__len__()} method +\method{__bool__()} method and whose \method{__len__()} method returns zero is considered to be false in a Boolean context. -\withsubitem{(object method)}{\ttindex{__nonzero__()}} +\withsubitem{(object method)}{\ttindex{__bool__()}} \end{methoddesc} \begin{methoddesc}[container object]{__getitem__}{self, key} Index: Lib/decimal.py =================================================================== --- Lib/decimal.py (Revision 52821) +++ Lib/decimal.py (Arbeitskopie) @@ -633,7 +633,7 @@ return other return 0 - def __nonzero__(self): + def __bool__(self): """Is the number non-zero? 0 if self == 0 @@ -759,7 +759,7 @@ i = int(self) if self == Decimal(i): return hash(i) - assert self.__nonzero__() # '-0' handled by integer case + assert self.__bool__() # '-0' handled by integer case return hash(str(self.normalize())) def as_tuple(self): Index: Lib/test/test_descr.py =================================================================== --- Lib/test/test_descr.py (Revision 52821) +++ Lib/test/test_descr.py (Arbeitskopie) @@ -417,8 +417,8 @@ if verbose: print "Testing int operations..." numops(100, 3) # The following crashes in Python 2.2 - vereq((1).__nonzero__(), 1) - vereq((0).__nonzero__(), 0) + vereq((1).__bool__(), True) + vereq((0).__bool__(), False) # This returns 'NotImplemented' in Python 2.2 class C(int): def __add__(self, other): @@ -1682,7 +1682,7 @@ class Proxy(object): def __init__(self, x): self.x = x - def __nonzero__(self): + def __bool__(self): return not not self.x def __hash__(self): return hash(self.x) @@ -1722,7 +1722,7 @@ class DProxy(object): def __init__(self, x): self.x = x - def __nonzero__(self): + def __bool__(self): return not not self.x def __hash__(self): return hash(self.x) Index: Lib/test/test_operator.py =================================================================== --- Lib/test/test_operator.py (Revision 52821) +++ Lib/test/test_operator.py (Arbeitskopie) @@ -319,7 +319,7 @@ def test_truth(self): class C(object): - def __nonzero__(self): + def __bool__(self): raise SyntaxError self.failUnlessRaises(TypeError, operator.truth) self.failUnlessRaises(SyntaxError, operator.truth, C()) Index: Lib/test/test_iter.py =================================================================== --- Lib/test/test_iter.py (Revision 52821) +++ Lib/test/test_iter.py (Arbeitskopie) @@ -327,7 +327,7 @@ class Boolean: def __init__(self, truth): self.truth = truth - def __nonzero__(self): + def __bool__(self): return self.truth bTrue = Boolean(1) bFalse = Boolean(0) Index: Lib/test/test_decimal.py =================================================================== --- Lib/test/test_decimal.py (Revision 52821) +++ Lib/test/test_decimal.py (Arbeitskopie) @@ -990,7 +990,7 @@ checkSameDec("__mod__", True) checkSameDec("__mul__", True) checkSameDec("__neg__") - checkSameDec("__nonzero__") + checkSameDec("__bool__") checkSameDec("__pos__") checkSameDec("__pow__", True) checkSameDec("__radd__", True) Index: Lib/test/test_bool.py =================================================================== --- Lib/test/test_bool.py (Revision 52821) +++ Lib/test/test_bool.py (Arbeitskopie) @@ -335,25 +335,36 @@ def test_convert_to_bool(self): # Verify that TypeError occurs when bad things are returned - # from __nonzero__(). This isn't really a bool test, but + # from __bool__(). This isn't really a bool test, but # it's related. check = lambda o: self.assertRaises(TypeError, bool, o) class Foo(object): - def __nonzero__(self): + def __bool__(self): return self check(Foo()) class Bar(object): - def __nonzero__(self): + def __bool__(self): return "Yes" check(Bar()) class Baz(int): - def __nonzero__(self): + def __bool__(self): return self check(Baz()) + # __bool__() must return a bool not an int + class Spam(int): + def __bool__(self): + return 1 + check(Spam()) + class Eggs: + def __len__(self): + return -1 + self.assertRaises(ValueError, bool, Eggs()) + + def test_main(): test_support.run_unittest(BoolTest) Index: Lib/test/test_richcmp.py =================================================================== --- Lib/test/test_richcmp.py (Revision 52821) +++ Lib/test/test_richcmp.py (Arbeitskopie) @@ -51,7 +51,7 @@ def __hash__(self): raise TypeError, "Vectors cannot be hashed" - def __nonzero__(self): + def __bool__(self): raise TypeError, "Vectors cannot be used in Boolean contexts" def __cmp__(self, other): @@ -133,7 +133,7 @@ for ops in opmap.itervalues(): for op in ops: - # calls __nonzero__, which should fail + # calls __bool__, which should fail self.assertRaises(TypeError, bool, op(a, b)) class NumberTest(unittest.TestCase): @@ -208,13 +208,13 @@ self.assertRaises(RuntimeError, cmp, a, b) def test_not(self): - # Check that exceptions in __nonzero__ are properly + # Check that exceptions in __bool__ are properly # propagated by the not operator import operator class Exc(Exception): pass class Bad: - def __nonzero__(self): + def __bool__(self): raise Exc def do(bad): Index: Lib/test/test_builtin.py =================================================================== --- Lib/test/test_builtin.py (Revision 52821) +++ Lib/test/test_builtin.py (Arbeitskopie) @@ -94,7 +94,7 @@ ] class TestFailingBool: - def __nonzero__(self): + def __bool__(self): raise RuntimeError class TestFailingIter: Index: Lib/xml/dom/minidom.py =================================================================== --- Lib/xml/dom/minidom.py (Revision 52821) +++ Lib/xml/dom/minidom.py (Arbeitskopie) @@ -38,7 +38,7 @@ prefix = EMPTY_PREFIX # non-null only for NS elements and attributes - def __nonzero__(self): + def __bool__(self): return True def toxml(self, encoding = None): Index: Modules/_ctypes/_ctypes.c =================================================================== --- Modules/_ctypes/_ctypes.c (Revision 52821) +++ Modules/_ctypes/_ctypes.c (Arbeitskopie) @@ -4017,7 +4017,7 @@ { NULL, NULL }, }; -static int Simple_nonzero(CDataObject *self) +static int Simple_bool(CDataObject *self) { return memcmp(self->b_ptr, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", self->b_size); } @@ -4032,7 +4032,7 @@ 0, /* nb_negative */ 0, /* nb_positive */ 0, /* nb_absolute */ - (inquiry)Simple_nonzero, /* nb_nonzero */ + (inquiry)Simple_bool, /* nb_bool */ }; #if (PY_VERSION_HEX < 0x02040000) @@ -4364,7 +4364,7 @@ }; static int -Pointer_nonzero(CDataObject *self) +Pointer_bool(CDataObject *self) { return *(void **)self->b_ptr != NULL; } @@ -4379,7 +4379,7 @@ 0, /* nb_negative */ 0, /* nb_positive */ 0, /* nb_absolute */ - (inquiry)Pointer_nonzero, /* nb_nonzero */ + (inquiry)Pointer_bool, /* nb_bool */ }; PyTypeObject Pointer_Type = { Index: Modules/datetimemodule.c =================================================================== --- Modules/datetimemodule.c (Revision 52821) +++ Modules/datetimemodule.c (Arbeitskopie) @@ -1958,7 +1958,7 @@ } static int -delta_nonzero(PyDateTime_Delta *self) +delta_bool(PyDateTime_Delta *self) { return (GET_TD_DAYS(self) != 0 || GET_TD_SECONDS(self) != 0 @@ -2083,7 +2083,7 @@ (unaryfunc)delta_negative, /* nb_negative */ (unaryfunc)delta_positive, /* nb_positive */ (unaryfunc)delta_abs, /* nb_absolute */ - (inquiry)delta_nonzero, /* nb_nonzero */ + (inquiry)delta_bool, /* nb_bool */ 0, /*nb_invert*/ 0, /*nb_lshift*/ 0, /*nb_rshift*/ @@ -2653,7 +2653,7 @@ 0, /* nb_negative */ 0, /* nb_positive */ 0, /* nb_absolute */ - 0, /* nb_nonzero */ + 0, /* nb_bool */ }; static PyTypeObject PyDateTime_DateType = { @@ -3324,7 +3324,7 @@ } static int -time_nonzero(PyDateTime_Time *self) +time_bool(PyDateTime_Time *self) { int offset; int none; @@ -3418,7 +3418,7 @@ 0, /* nb_negative */ 0, /* nb_positive */ 0, /* nb_absolute */ - (inquiry)time_nonzero, /* nb_nonzero */ + (inquiry)time_bool, /* nb_bool */ }; static PyTypeObject PyDateTime_TimeType = { @@ -4501,7 +4501,7 @@ 0, /* nb_negative */ 0, /* nb_positive */ 0, /* nb_absolute */ - 0, /* nb_nonzero */ + 0, /* nb_bool */ }; static PyTypeObject PyDateTime_DateTimeType = {