test_float.py

importmath
importrandom
importsys
importunittest
importwarnings

fromtest.test_capi.test_getargsimport (Float, FloatSubclass, FloatSubclass2,
BadIndex2, BadFloat2, Index, BadIndex,
BadFloat)
fromtest.supportimportimport_helper

_testcapi=import_helper.import_module('_testcapi')
_testlimitedcapi=import_helper.import_module('_testlimitedcapi')

NULL=None

# For PyFloat_Pack/Unpack*
BIG_ENDIAN=0
LITTLE_ENDIAN=1
EPSILON= {
2: 2.0**-11, # binary16
4: 2.0**-24, # binary32
8: 2.0**-53, # binary64
}

HAVE_IEEE_754=float.__getformat__("double").startswith("IEEE")
INF=float("inf")
NAN=float("nan")


classCAPIFloatTest(unittest.TestCase):
deftest_check(self):
# Test PyFloat_Check()
check=_testlimitedcapi.float_check

self.assertTrue(check(4.25))
self.assertTrue(check(FloatSubclass(4.25)))
self.assertFalse(check(Float()))
self.assertFalse(check(3))
self.assertFalse(check(object()))

# CRASHES check(NULL)

deftest_checkexact(self):
# Test PyFloat_CheckExact()
checkexact=_testlimitedcapi.float_checkexact

self.assertTrue(checkexact(4.25))
self.assertFalse(checkexact(FloatSubclass(4.25)))
self.assertFalse(checkexact(Float()))
self.assertFalse(checkexact(3))
self.assertFalse(checkexact(object()))

# CRASHES checkexact(NULL)

deftest_fromstring(self):
# Test PyFloat_FromString()
fromstring=_testlimitedcapi.float_fromstring

self.assertEqual(fromstring("4.25"), 4.25)
self.assertEqual(fromstring(b"4.25"), 4.25)
self.assertRaises(ValueError, fromstring, "4.25\0")
self.assertRaises(ValueError, fromstring, b"4.25\0")

self.assertEqual(fromstring(bytearray(b"4.25")), 4.25)

self.assertEqual(fromstring(memoryview(b"4.25")), 4.25)
self.assertEqual(fromstring(memoryview(b"4.255")[:-1]), 4.25)
self.assertRaises(TypeError, fromstring, memoryview(b"4.25")[::2])

self.assertRaises(TypeError, fromstring, 4.25)

# CRASHES fromstring(NULL)

deftest_fromdouble(self):
# Test PyFloat_FromDouble()
fromdouble=_testlimitedcapi.float_fromdouble

self.assertEqual(fromdouble(4.25), 4.25)

deftest_asdouble(self):
# Test PyFloat_AsDouble()
asdouble=_testlimitedcapi.float_asdouble

classBadFloat3:
def__float__(self):
raiseRuntimeError

self.assertEqual(asdouble(4.25), 4.25)
self.assertEqual(asdouble(-1.0), -1.0)
self.assertEqual(asdouble(42), 42.0)
self.assertEqual(asdouble(-1), -1.0)
self.assertEqual(asdouble(2**1000), float(2**1000))

self.assertEqual(asdouble(FloatSubclass(4.25)), 4.25)
self.assertEqual(asdouble(FloatSubclass2(4.25)), 4.25)
self.assertEqual(asdouble(Index()), 99.)

self.assertRaises(TypeError, asdouble, BadIndex())
self.assertRaises(TypeError, asdouble, BadFloat())
self.assertRaises(RuntimeError, asdouble, BadFloat3())
withself.assertWarns(DeprecationWarning):
self.assertEqual(asdouble(BadIndex2()), 1.)
withself.assertWarns(DeprecationWarning):
self.assertEqual(asdouble(BadFloat2()), 4.25)
withwarnings.catch_warnings():
warnings.simplefilter("error", DeprecationWarning)
self.assertRaises(DeprecationWarning, asdouble, BadFloat2())
self.assertRaises(TypeError, asdouble, object())
self.assertRaises(TypeError, asdouble, NULL)

deftest_getinfo(self):
# Test PyFloat_GetInfo()
getinfo=_testlimitedcapi.float_getinfo

self.assertEqual(getinfo(), sys.float_info)

deftest_getmax(self):
# Test PyFloat_GetMax()
getmax=_testlimitedcapi.float_getmax

self.assertEqual(getmax(), sys.float_info.max)

deftest_getmin(self):
# Test PyFloat_GetMax()
getmin=_testlimitedcapi.float_getmin

self.assertEqual(getmin(), sys.float_info.min)

deftest_pack(self):
# Test PyFloat_Pack2(), PyFloat_Pack4() and PyFloat_Pack8()
pack=_testcapi.float_pack

self.assertEqual(pack(2, 1.5, BIG_ENDIAN), b'>\x00')
self.assertEqual(pack(4, 1.5, BIG_ENDIAN), b'?\xc0\x00\x00')
self.assertEqual(pack(8, 1.5, BIG_ENDIAN),
b'?\xf8\x00\x00\x00\x00\x00\x00')
self.assertEqual(pack(2, 1.5, LITTLE_ENDIAN), b'\x00>')
self.assertEqual(pack(4, 1.5, LITTLE_ENDIAN), b'\x00\x00\xc0?')
self.assertEqual(pack(8, 1.5, LITTLE_ENDIAN),
b'\x00\x00\x00\x00\x00\x00\xf8?')

deftest_unpack(self):
# Test PyFloat_Unpack2(), PyFloat_Unpack4() and PyFloat_Unpack8()
unpack=_testcapi.float_unpack

self.assertEqual(unpack(b'>\x00', BIG_ENDIAN), 1.5)
self.assertEqual(unpack(b'?\xc0\x00\x00', BIG_ENDIAN), 1.5)
self.assertEqual(unpack(b'?\xf8\x00\x00\x00\x00\x00\x00', BIG_ENDIAN),
1.5)
self.assertEqual(unpack(b'\x00>', LITTLE_ENDIAN), 1.5)
self.assertEqual(unpack(b'\x00\x00\xc0?', LITTLE_ENDIAN), 1.5)
self.assertEqual(unpack(b'\x00\x00\x00\x00\x00\x00\xf8?', LITTLE_ENDIAN),
1.5)

deftest_pack_unpack_roundtrip(self):
pack=_testcapi.float_pack
unpack=_testcapi.float_unpack

large=2.0**100
values= [1.0, 1.5, large, 1.0/7, math.pi]
ifHAVE_IEEE_754:
values.extend((INF, NAN))
forvalueinvalues:
forsizein (2, 4, 8,):
ifsize==2andvalue==large:
# too large for 16-bit float
continue
rel_tol=EPSILON[size]
forendianin (BIG_ENDIAN, LITTLE_ENDIAN):
withself.subTest(value=value, size=size, endian=endian):
data=pack(size, value, endian)
value2=unpack(data, endian)
ifmath.isnan(value):
self.assertTrue(math.isnan(value2), (value, value2))
elifsize<8:
self.assertTrue(math.isclose(value2, value, rel_tol=rel_tol),
 (value, value2))
else:
self.assertEqual(value2, value)

@unittest.skipUnless(HAVE_IEEE_754, "requires IEEE 754")
deftest_pack_unpack_roundtrip_for_nans(self):
pack=_testcapi.float_pack
unpack=_testcapi.float_unpack
for_inrange(1000):
forsizein (2, 4, 8):
sign=random.randint(0, 1)
signaling=random.randint(0, 1)
quiet=int(notsignaling)
ifsize==8:
payload=random.randint(signaling, 1<<50)
i= (sign<<63) + (0x7ff<<52) + (quiet<<51) +payload
elifsize==4:
payload=random.randint(signaling, 1<<21)
i= (sign<<31) + (0xff<<23) + (quiet<<22) +payload
elifsize==2:
payload=random.randint(signaling, 1<<8)
i= (sign<<15) + (0x1f<<10) + (quiet<<9) +payload
data=bytes.fromhex(f'{i:x}')
forendianin (BIG_ENDIAN, LITTLE_ENDIAN):
withself.subTest(data=data, size=size, endian=endian):
data1=dataifendian==BIG_ENDIANelsedata[::-1]
value=unpack(data1, endian)
ifsignalingandsys.platform=='win32':
# On this platform sNaN becomes qNaN when returned
# from function. That's a known bug, e.g.
# https://developercommunity.visualstudio.com/t/155064
# (see also gh-130317).
value=_testcapi.float_set_snan(value)
data2=pack(size, value, endian)
self.assertTrue(math.isnan(value))
self.assertEqual(data1, data2)


if__name__=="__main__":
unittest.main()