Manual forward port of 64962 - use PyObject_HashNotImplemented as a tp_hash level indicator that the default hash implementation has not been inherited
diff --git a/Lib/decimal.py b/Lib/decimal.py
index 180b177..2c02f11 100644
--- a/Lib/decimal.py
+++ b/Lib/decimal.py
@@ -3783,10 +3783,8 @@
for flag in flags:
self._ignored_flags.remove(flag)
- def __hash__(self):
- """A Context cannot be hashed."""
- # We inherit object.__hash__, so we must deny this explicitly
- raise TypeError("Cannot hash a Context.")
+ # We inherit object.__hash__, so we must deny this explicitly
+ __hash__ = None
def Etiny(self):
"""Returns Etiny (= Emin - prec + 1)"""
diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py
index dd12ee3..962cfe1 100644
--- a/Lib/test/seq_tests.py
+++ b/Lib/test/seq_tests.py
@@ -212,8 +212,7 @@
# So instances of AllEq must be found in all non-empty sequences.
def __eq__(self, other):
return True
- def __hash__(self):
- raise NotImplemented
+ __hash__ = None # Can't meet hash invariant requirements
self.assert_(AllEq() not in self.type2test([]))
self.assert_(AllEq() in self.type2test([1]))
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index bfbb400..3c0bae0 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -3070,12 +3070,20 @@
self.assertEqual(hash(d), 144)
D.__hash__ = lambda self: 100
self.assertEqual(hash(d), 100)
+ D.__hash__ = None
+ self.assertRaises(TypeError, hash, d)
del D.__hash__
self.assertEqual(hash(d), 144)
+ B.__hash__ = None
+ self.assertRaises(TypeError, hash, d)
del B.__hash__
self.assertEqual(hash(d), 314)
+ C.__hash__ = None
+ self.assertRaises(TypeError, hash, d)
del C.__hash__
self.assertEqual(hash(d), 42)
+ A.__hash__ = None
+ self.assertRaises(TypeError, hash, d)
del A.__hash__
self.assertEqual(hash(d), orig_hash)
d.foo = 42
diff --git a/Lib/test/test_hash.py b/Lib/test/test_hash.py
index fb1699a..56974b8 100644
--- a/Lib/test/test_hash.py
+++ b/Lib/test/test_hash.py
@@ -1,9 +1,11 @@
# test the invariant that
# iff a==b then hash(a)==hash(b)
#
+# Also test that hash implementations are inherited as expected
import unittest
from test import support
+from collections import Hashable
class HashEqualityTestCase(unittest.TestCase):
@@ -37,8 +39,74 @@
self.same_hash(float(0.5), complex(0.5, 0.0))
+_default_hash = object.__hash__
+class DefaultHash(object): pass
+
+_FIXED_HASH_VALUE = 42
+class FixedHash(object):
+ def __hash__(self):
+ return _FIXED_HASH_VALUE
+
+class OnlyEquality(object):
+ def __eq__(self, other):
+ return self is other
+
+class OnlyInequality(object):
+ def __ne__(self, other):
+ return self is not other
+
+class OnlyCmp(object):
+ def __cmp__(self, other):
+ return cmp(id(self), id(other))
+
+class InheritedHashWithEquality(FixedHash, OnlyEquality): pass
+class InheritedHashWithInequality(FixedHash, OnlyInequality): pass
+class InheritedHashWithCmp(FixedHash, OnlyCmp): pass
+
+class NoHash(object):
+ __hash__ = None
+
+class HashInheritanceTestCase(unittest.TestCase):
+ default_expected = [object(),
+ DefaultHash(),
+ OnlyInequality(),
+ ]
+ fixed_expected = [FixedHash(),
+ InheritedHashWithEquality(),
+ InheritedHashWithInequality(),
+ InheritedHashWithCmp(),
+ ]
+ error_expected = [NoHash(),
+ OnlyEquality(),
+ OnlyCmp(),
+ ]
+
+ def test_default_hash(self):
+ for obj in self.default_expected:
+ self.assertEqual(hash(obj), _default_hash(obj))
+
+ def test_fixed_hash(self):
+ for obj in self.fixed_expected:
+ self.assertEqual(hash(obj), _FIXED_HASH_VALUE)
+
+ def test_error_hash(self):
+ for obj in self.error_expected:
+ self.assertRaises(TypeError, hash, obj)
+
+ def test_hashable(self):
+ objects = (self.default_expected +
+ self.fixed_expected)
+ for obj in objects:
+ self.assert_(isinstance(obj, Hashable), repr(obj))
+
+ def test_not_hashable(self):
+ for obj in self.error_expected:
+ self.assertFalse(isinstance(obj, Hashable), repr(obj))
+
+
def test_main():
- support.run_unittest(HashEqualityTestCase)
+ support.run_unittest(HashEqualityTestCase,
+ HashInheritanceTestCase)
if __name__ == "__main__":
diff --git a/Lib/test/test_richcmp.py b/Lib/test/test_richcmp.py
index 30dac8f..435de75 100644
--- a/Lib/test/test_richcmp.py
+++ b/Lib/test/test_richcmp.py
@@ -48,8 +48,7 @@
def __setitem__(self, i, v):
self.data[i] = v
- def __hash__(self):
- raise TypeError("Vectors cannot be hashed")
+ __hash__ = None # Vectors cannot be hashed
def __bool__(self):
raise TypeError("Vectors cannot be used in Boolean contexts")
@@ -85,35 +84,6 @@
raise ValueError("Cannot compare vectors of different length")
return other
-
-class SimpleOrder(object):
- """
- A simple class that defines order but not full comparison.
- """
-
- def __init__(self, value):
- self.value = value
-
- def __lt__(self, other):
- if not isinstance(other, SimpleOrder):
- return True
- return self.value < other.value
-
- def __gt__(self, other):
- if not isinstance(other, SimpleOrder):
- return False
- return self.value > other.value
-
-
-class DumbEqualityWithoutHash(object):
- """
- A class that define __eq__, but no __hash__: it shouldn't be hashable.
- """
-
- def __eq__(self, other):
- return False
-
-
opmap = {
"lt": (lambda a,b: a< b, operator.lt, operator.__lt__),
"le": (lambda a,b: a<=b, operator.le, operator.__le__),
@@ -360,38 +330,8 @@
self.assertIs(op(x, y), True)
-class HashableTest(unittest.TestCase):
- """
- Test hashability of classes with rich operators defined.
- """
-
- def test_simpleOrderHashable(self):
- """
- A class that only defines __gt__ and/or __lt__ should be hashable.
- """
- a = SimpleOrder(1)
- b = SimpleOrder(2)
- self.assert_(a < b)
- self.assert_(b > a)
- self.assert_(a.__hash__ is not None)
-
- def test_notHashableException(self):
- """
- If a class is not hashable, it should raise a TypeError with an
- understandable message.
- """
- a = DumbEqualityWithoutHash()
- try:
- hash(a)
- except TypeError as e:
- self.assertEquals(str(e),
- "unhashable type: 'DumbEqualityWithoutHash'")
- else:
- raise support.TestFailed("Should not be here")
-
-
def test_main():
- support.run_unittest(VectorTest, NumberTest, MiscTest, DictTest, ListTest, HashableTest)
+ support.run_unittest(VectorTest, NumberTest, MiscTest, DictTest, ListTest)
if __name__ == "__main__":
test_main()