python/python-persistent
SHA256
15
0
Fork 0
forked from pool/python-persistent
Code Pull Requests Activity

Accepting request 306255 from home:benoit_monin:branches:devel:languages:python

Browse Source 
- update to version 4.0.9
- update project URL
- point the source URL to pypi
- drop type-mismatch.patch: fixed upstream
- add fix_32-bit_timestamp_hashcode.patch: fix timestamp hash computation on 32 bit platform
- pass -q to test to avoid spamming the build log
- rename CHANGES.txt and README.txt to CHANGES.rst and README.rst: changed upstream

OBS-URL: https://build.opensuse.org/request/show/306255
OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-persistent?expand=0&rev=5
This commit is contained in:
Hans-Peter Jansen
2015-05-11 06:23:41 +00:00
committed by Git OBS Bridge
parent b6cfd62ffe
commit 0356b6357d
6 changed files with 182 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
fix_32-bit_timestamp_hashcode.patch Normal file
View File

@@ -0,0 +1,131 @@
fix timestamp hash computation on 32-bit platform.
Patch extracted from PR #22 and #23, see:
https://github.com/zopefoundation/persistent/issues/21
https://github.com/zopefoundation/persistent/pull/22
https://github.com/zopefoundation/persistent/pull/23
---
persistent/tests/test_timestamp.py | 64 +++++++++++++++++++++++++++++++++----
persistent/timestamp.py | 4 +-
2 files changed, 60 insertions(+), 8 deletions(-)
Index: persistent-4.0.9/persistent/tests/test_timestamp.py
===================================================================
--- persistent-4.0.9.orig/persistent/tests/test_timestamp.py
+++ persistent-4.0.9/persistent/tests/test_timestamp.py
@@ -253,9 +253,45 @@ class PyAndCComparisonTests(unittest.Tes
c, py = self._make_C_and_Py(*self.now_ts_args)
self.assertEqual(hash(c), hash(py))
+ def test_py_hash_32_64_bit(self):
+ # We happen to know that on a 32-bit platform, the hashcode
+ # of the c version should be exactly
+ # -1419374591
+ # and the 64-bit should be exactly:
+ # -3850693964765720575
+ # Fake out the python version to think it's on a 32-bit
+ # platform and test the same; also verify 64 bit
+ bit_32_hash = -1419374591
+ bit_64_hash = -3850693964765720575
+ import persistent.timestamp
+ import ctypes
+ orig_c_long = persistent.timestamp.c_long
+ try:
+ persistent.timestamp.c_long = ctypes.c_int32
+ py = self._makePy(*self.now_ts_args)
+ self.assertEqual(hash(py), bit_32_hash)
+
+ persistent.timestamp.c_long = ctypes.c_int64
+ # call __hash__ directly to avoid interpreter truncation
+ # in hash() on 32-bit platforms
+ self.assertEqual(py.__hash__(), bit_64_hash)
+ finally:
+ persistent.timestamp.c_long = orig_c_long
+
+ if orig_c_long is ctypes.c_int32:
+ self.assertEqual(py.__hash__(), bit_32_hash)
+ elif orig_c_long is ctypes.c_int64:
+ self.assertEqual(py.__hash__(), bit_64_hash)
+ else:
+ self.fail("Unknown bitness")
+
def test_hash_equal_constants(self):
# The simple constants make it easier to diagnose
# a difference in algorithms
+ import persistent.timestamp
+ import ctypes
+ is_32_bit = persistent.timestamp.c_long == ctypes.c_int32
+
c, py = self._make_C_and_Py(b'\x00\x00\x00\x00\x00\x00\x00\x00')
self.assertEqual(hash(c), 8)
self.assertEqual(hash(c), hash(py))
@@ -268,25 +304,41 @@ class PyAndCComparisonTests(unittest.Tes
self.assertEqual(hash(c), 1000011)
self.assertEqual(hash(c), hash(py))
+ # overflow kicks in here on 32-bit platforms
c, py = self._make_C_and_Py(b'\x00\x00\x00\x00\x00\x01\x00\x00')
- self.assertEqual(hash(c), 1000006000001)
+ if is_32_bit:
+ self.assertEqual(hash(c), -721379967)
+ else:
+ self.assertEqual(hash(c), 1000006000001)
self.assertEqual(hash(c), hash(py))
c, py = self._make_C_and_Py(b'\x00\x00\x00\x00\x01\x00\x00\x00')
- self.assertEqual(hash(c), 1000009000027000019)
+ if is_32_bit:
+ self.assertEqual(hash(c), 583896275)
+ else:
+ self.assertEqual(hash(c), 1000009000027000019)
self.assertEqual(hash(c), hash(py))
- # Overflow kicks in at this point
+ # Overflow kicks in at this point on 64-bit platforms
c, py = self._make_C_and_Py(b'\x00\x00\x00\x01\x00\x00\x00\x00')
- self.assertEqual(hash(c), -4442925868394654887)
+ if is_32_bit:
+ self.assertEqual(hash(c), 1525764953)
+ else:
+ self.assertEqual(hash(c), -4442925868394654887)
self.assertEqual(hash(c), hash(py))
c, py = self._make_C_and_Py(b'\x00\x00\x01\x00\x00\x00\x00\x00')
- self.assertEqual(hash(c), -3993531167153147845)
+ if is_32_bit:
+ self.assertEqual(hash(c), -429739973)
+ else:
+ self.assertEqual(hash(c), -3993531167153147845)
self.assertEqual(hash(c), hash(py))
c, py = self._make_C_and_Py(b'\x01\x00\x00\x00\x00\x00\x00\x00')
- self.assertEqual(hash(c), -3099646879006235965)
+ if is_32_bit:
+ self.assertEqual(hash(c), 263152323)
+ else:
+ self.assertEqual(hash(c), -3099646879006235965)
self.assertEqual(hash(c), hash(py))
def test_ordering(self):
Index: persistent-4.0.9/persistent/timestamp.py
===================================================================
--- persistent-4.0.9.orig/persistent/timestamp.py
+++ persistent-4.0.9/persistent/timestamp.py
@@ -13,7 +13,7 @@
##############################################################################
__all__ = ('TimeStamp',)
-from ctypes import c_int64
+from ctypes import c_long
import datetime
import math
import struct
@@ -158,7 +158,7 @@ class pyTimeStamp(object):
# Make sure to overflow and wraparound just
# like the C code does.
- x = c_int64(x).value
+ x = c_long(x).value
if x == -1: #pragma: no cover
# The C version has this condition, but it's not clear
# why; it's also not immediately obvious what bytestring