Debian Codegraph @

Lib/test/test_capi/test_float.py

raw
1 import math
2 import random
3 import sys
4 import unittest
5 import warnings
6
7 from test.test_capi.test_getargs import (Float, FloatSubclass, FloatSubclass2,
8 BadIndex2, BadFloat2, Index, BadIndex,
9 BadFloat)
10 from test.support import import_helper
11
12 _testcapi = import_helper.import_module('_testcapi')
13 _testlimitedcapi = import_helper.import_module('_testlimitedcapi')
14
15 NULL = None
16
17 # For PyFloat_Pack/Unpack*
18 BIG_ENDIAN = 0
19 LITTLE_ENDIAN = 1
20 EPSILON = {
21 2: 2.0 ** -11, # binary16
22 4: 2.0 ** -24, # binary32
23 8: 2.0 ** -53, # binary64
24 }
25
26 HAVE_IEEE_754 = float.__getformat__("double").startswith("IEEE")
27 INF = float("inf")
28 NAN = float("nan")
29
30
31 def make_nan(size, sign, quiet, payload=None):
32 if size == 8:
33 payload_mask = 0x7ffffffffffff
34 i = (sign << 63) + (0x7ff << 52) + (quiet << 51)
35 elif size == 4:
36 payload_mask = 0x3fffff
37 i = (sign << 31) + (0xff << 23) + (quiet << 22)
38 elif size == 2:
39 payload_mask = 0x1ff
40 i = (sign << 15) + (0x1f << 10) + (quiet << 9)
41 else:
42 raise ValueError("size must be either 2, 4, or 8")
43 if payload is None:
44 payload = random.randint(not quiet, payload_mask)
45 return i + payload
46
47
48 class CAPIFloatTest(unittest.TestCase):
49 def test_check(self):
50 # Test PyFloat_Check()
51 check = _testlimitedcapi.float_check
52
53 self.assertTrue(check(4.25))
54 self.assertTrue(check(FloatSubclass(4.25)))
55 self.assertFalse(check(Float()))
56 self.assertFalse(check(3))
57 self.assertFalse(check(object()))
58
59 # CRASHES check(NULL)
60
61 def test_checkexact(self):
62 # Test PyFloat_CheckExact()
63 checkexact = _testlimitedcapi.float_checkexact
64
65 self.assertTrue(checkexact(4.25))
66 self.assertFalse(checkexact(FloatSubclass(4.25)))
67 self.assertFalse(checkexact(Float()))
68 self.assertFalse(checkexact(3))
69 self.assertFalse(checkexact(object()))
70
71 # CRASHES checkexact(NULL)
72
73 def test_fromstring(self):
74 # Test PyFloat_FromString()
75 fromstring = _testlimitedcapi.float_fromstring
76
77 self.assertEqual(fromstring("4.25"), 4.25)
78 self.assertEqual(fromstring(b"4.25"), 4.25)
79 self.assertRaises(ValueError, fromstring, "4.25\0")
80 self.assertRaises(ValueError, fromstring, b"4.25\0")
81
82 self.assertEqual(fromstring(bytearray(b"4.25")), 4.25)
83
84 self.assertEqual(fromstring(memoryview(b"4.25")), 4.25)
85 self.assertEqual(fromstring(memoryview(b"4.255")[:-1]), 4.25)
86 self.assertRaises(TypeError, fromstring, memoryview(b"4.25")[::2])
87
88 self.assertRaises(TypeError, fromstring, 4.25)
89
90 # CRASHES fromstring(NULL)
91
92 def test_fromdouble(self):
93 # Test PyFloat_FromDouble()
94 fromdouble = _testlimitedcapi.float_fromdouble
95
96 self.assertEqual(fromdouble(4.25), 4.25)
97
98 def test_asdouble(self):
99 # Test PyFloat_AsDouble()
100 asdouble = _testlimitedcapi.float_asdouble
101
102 class BadFloat3:
103 def __float__(self):
104 raise RuntimeError
105
106 self.assertEqual(asdouble(4.25), 4.25)
107 self.assertEqual(asdouble(-1.0), -1.0)
108 self.assertEqual(asdouble(42), 42.0)
109 self.assertEqual(asdouble(-1), -1.0)
110 self.assertEqual(asdouble(2**1000), float(2**1000))
111
112 self.assertEqual(asdouble(FloatSubclass(4.25)), 4.25)
113 self.assertEqual(asdouble(FloatSubclass2(4.25)), 4.25)
114 self.assertEqual(asdouble(Index()), 99.)
115
116 self.assertRaises(TypeError, asdouble, BadIndex())
117 self.assertRaises(TypeError, asdouble, BadFloat())
118 self.assertRaises(RuntimeError, asdouble, BadFloat3())
119 with self.assertWarns(DeprecationWarning):
120 self.assertEqual(asdouble(BadIndex2()), 1.)
121 with self.assertWarns(DeprecationWarning):
122 self.assertEqual(asdouble(BadFloat2()), 4.25)
123 with warnings.catch_warnings():
124 warnings.simplefilter("error", DeprecationWarning)
125 self.assertRaises(DeprecationWarning, asdouble, BadFloat2())
126 self.assertRaises(TypeError, asdouble, object())
127 self.assertRaises(TypeError, asdouble, NULL)
128
129 def test_getinfo(self):
130 # Test PyFloat_GetInfo()
131 getinfo = _testlimitedcapi.float_getinfo
132
133 self.assertEqual(getinfo(), sys.float_info)
134
135 def test_getmax(self):
136 # Test PyFloat_GetMax()
137 getmax = _testlimitedcapi.float_getmax
138
139 self.assertEqual(getmax(), sys.float_info.max)
140
141 def test_getmin(self):
142 # Test PyFloat_GetMax()
143 getmin = _testlimitedcapi.float_getmin
144
145 self.assertEqual(getmin(), sys.float_info.min)
146
147 def test_pack(self):
148 # Test PyFloat_Pack2(), PyFloat_Pack4() and PyFloat_Pack8()
149 pack = _testcapi.float_pack
150
151 self.assertEqual(pack(2, 1.5, BIG_ENDIAN), b'>\x00')
152 self.assertEqual(pack(4, 1.5, BIG_ENDIAN), b'?\xc0\x00\x00')
153 self.assertEqual(pack(8, 1.5, BIG_ENDIAN),
154 b'?\xf8\x00\x00\x00\x00\x00\x00')
155 self.assertEqual(pack(2, 1.5, LITTLE_ENDIAN), b'\x00>')
156 self.assertEqual(pack(4, 1.5, LITTLE_ENDIAN), b'\x00\x00\xc0?')
157 self.assertEqual(pack(8, 1.5, LITTLE_ENDIAN),
158 b'\x00\x00\x00\x00\x00\x00\xf8?')
159
160 def test_unpack(self):
161 # Test PyFloat_Unpack2(), PyFloat_Unpack4() and PyFloat_Unpack8()
162 unpack = _testcapi.float_unpack
163
164 self.assertEqual(unpack(b'>\x00', BIG_ENDIAN), 1.5)
165 self.assertEqual(unpack(b'?\xc0\x00\x00', BIG_ENDIAN), 1.5)
166 self.assertEqual(unpack(b'?\xf8\x00\x00\x00\x00\x00\x00', BIG_ENDIAN),
167 1.5)
168 self.assertEqual(unpack(b'\x00>', LITTLE_ENDIAN), 1.5)
169 self.assertEqual(unpack(b'\x00\x00\xc0?', LITTLE_ENDIAN), 1.5)
170 self.assertEqual(unpack(b'\x00\x00\x00\x00\x00\x00\xf8?', LITTLE_ENDIAN),
171 1.5)
172
173 def test_pack_unpack_roundtrip(self):
174 pack = _testcapi.float_pack
175 unpack = _testcapi.float_unpack
176
177 large = 2.0 ** 100
178 values = [1.0, 1.5, large, 1.0/7, math.pi]
179 if HAVE_IEEE_754:
180 values.extend((INF, NAN))
181 for value in values:
182 for size in (2, 4, 8,):
183 if size == 2 and value == large:
184 # too large for 16-bit float
185 continue
186 rel_tol = EPSILON[size]
187 for endian in (BIG_ENDIAN, LITTLE_ENDIAN):
188 with self.subTest(value=value, size=size, endian=endian):
189 data = pack(size, value, endian)
190 value2 = unpack(data, endian)
191 if math.isnan(value):
192 self.assertTrue(math.isnan(value2), (value, value2))
193 elif size < 8:
194 self.assertTrue(math.isclose(value2, value, rel_tol=rel_tol),
195 (value, value2))
196 else:
197 self.assertEqual(value2, value)
198
199 @unittest.skipUnless(HAVE_IEEE_754, "requires IEEE 754")
200 def test_pack_unpack_roundtrip_for_nans(self):
201 pack = _testcapi.float_pack
202 unpack = _testcapi.float_unpack
203
204 for _ in range(10):
205 for size in (2, 4, 8):
206 sign = random.randint(0, 1)
207 if sys.maxsize != 2147483647: # not it 32-bit mode
208 signaling = random.randint(0, 1)
209 else:
210 # Skip sNaN's on x86 (32-bit). The problem is that sNaN
211 # doubles become qNaN doubles just by the C calling
212 # convention, there is no way to preserve sNaN doubles
213 # between C function calls with the current
214 # PyFloat_Pack/Unpack*() API. See also gh-130317 and
215 # e.g. https://developercommunity.visualstudio.com/t/155064
216 signaling = 0
217 if _testcapi.nan_msb_is_signaling:
218 # HP PA RISC and some MIPS CPUs use 0 for quiet, see:
219 # https://en.wikipedia.org/wiki/NaN#Encoding
220 signaling = 1
221 i = make_nan(size, sign, not signaling)
222 data = bytes.fromhex(f'{i:x}')
223 for endian in (BIG_ENDIAN, LITTLE_ENDIAN):
224 with self.subTest(data=data, size=size, endian=endian):
225 data1 = data if endian == BIG_ENDIAN else data[::-1]
226 value = unpack(data1, endian)
227 data2 = pack(size, value, endian)
228 self.assertTrue(math.isnan(value))
229 self.assertEqual(data1, data2)
230
231 @unittest.skipUnless(HAVE_IEEE_754, "requires IEEE 754")
232 @unittest.skipUnless(sys.maxsize != 2147483647, "requires 64-bit mode")
233 def test_pack_unpack_nans_for_different_formats(self):
234 pack = _testcapi.float_pack
235 unpack = _testcapi.float_unpack
236
237 for endian in (BIG_ENDIAN, LITTLE_ENDIAN):
238 with self.subTest(endian=endian):
239 byteorder = "big" if endian == BIG_ENDIAN else "little"
240
241 # Convert sNaN to qNaN, if payload got truncated
242 data = make_nan(8, 0, False, 0x80001).to_bytes(8, byteorder)
243 snan_low = unpack(data, endian)
244 qnan4 = make_nan(4, 0, True, 0).to_bytes(4, byteorder)
245 qnan2 = make_nan(2, 0, True, 0).to_bytes(2, byteorder)
246 self.assertEqual(pack(4, snan_low, endian), qnan4)
247 self.assertEqual(pack(2, snan_low, endian), qnan2)
248
249 # Preserve NaN type, if payload not truncated
250 data = make_nan(8, 0, False, 0x80000000001).to_bytes(8, byteorder)
251 snan_high = unpack(data, endian)
252 snan4 = make_nan(4, 0, False, 16384).to_bytes(4, byteorder)
253 snan2 = make_nan(2, 0, False, 2).to_bytes(2, byteorder)
254 self.assertEqual(pack(4, snan_high, endian), snan4)
255 self.assertEqual(pack(2, snan_high, endian), snan2)
256
257
258 if __name__ == "__main__":
259 unittest.main()