import fractions
import operator
import os
import random
import sys
import struct
import time
import unittest
from test import support
from test.test_grammar import VALID_UNDERSCORE_LITERALS, INVALID_UNDERSCORE_LITERALS
from math import isinf, isnan, copysign, ldexp
INF = float('inf')
NAN = float('nan')
have_getformat = hasattr(float, '__getformat__')
requires_getformat = unittest.skipUnless(have_getformat,
    'requires __getformat__')
requires_setformat = unittest.skipUnless(hasattr(float, '__setformat__'),
    'requires __setformat__')
test_dir = os.path.dirname(__file__) or os.curdir
format_testfile = os.path.join(test_dir, 'formatfloat_testcases.txt')


class FloatSubclass(float):
    pass


class OtherFloatSubclass(float):
    pass


class GeneralFloatCases(unittest.TestCase):

    def test_float(self):
        self.assertEqual(float(3.14), 3.14)
        self.assertEqual(float(314), 314.0)
        self.assertEqual(float('  3.14  '), 3.14)
        self.assertRaises(ValueError, float, '  0x3.1  ')
        self.assertRaises(ValueError, float, '  -0x3.p-1  ')
        self.assertRaises(ValueError, float, '  +0x3.p-1  ')
        self.assertRaises(ValueError, float, '++3.14')
        self.assertRaises(ValueError, float, '+-3.14')
        self.assertRaises(ValueError, float, '-+3.14')
        self.assertRaises(ValueError, float, '--3.14')
        self.assertRaises(ValueError, float, '.nan')
        self.assertRaises(ValueError, float, '+.inf')
        self.assertRaises(ValueError, float, '.')
        self.assertRaises(ValueError, float, '-.')
        self.assertRaises(TypeError, float, {})
        self.assertRaisesRegex(TypeError, "not 'dict'", float, {})
        self.assertRaises(UnicodeEncodeError, float, '\ud8f0')
        self.assertRaises(ValueError, float, '-1.7d29')
        self.assertRaises(ValueError, float, '3D-14')
        self.assertEqual(float('  ٣.١٤  '), 3.14)
        self.assertEqual(float('\u20033.14\u2002'), 3.14)
        float(b'.' + b'1' * 1000)
        float('.' + '1' * 1000)

    def test_underscores(self):
        for lit in VALID_UNDERSCORE_LITERALS:
            if not any(ch in lit for ch in 'jJxXoObB'):
                self.assertEqual(float(lit), eval(lit))
                self.assertEqual(float(lit), float(lit.replace('_', '')))
        for lit in INVALID_UNDERSCORE_LITERALS:
            if lit in ('0_7', '09_99'):
                continue
            if not any(ch in lit for ch in 'jJxXoObB'):
                self.assertRaises(ValueError, float, lit)
        self.assertRaises(ValueError, float, '_NaN')
        self.assertRaises(ValueError, float, 'Na_N')
        self.assertRaises(ValueError, float, 'IN_F')
        self.assertRaises(ValueError, float, '-_INF')
        self.assertRaises(ValueError, float, '-INF_')
        self.assertRaises(ValueError, float, b'0_.\xff9')

    def test_non_numeric_input_types(self):


        class CustomStr(str):
            pass


        class CustomBytes(bytes):
            pass


        class CustomByteArray(bytearray):
            pass
        factories = [bytes, bytearray, lambda b: CustomStr(b.decode()),
            CustomBytes, CustomByteArray, memoryview]
        try:
            from array import array
        except ImportError:
            pass
        else:
            factories.append(lambda b: array('B', b))
        for f in factories:
            x = f(b' 3.14  ')
            with self.subTest(type(x)):
                self.assertEqual(float(x), 3.14)
                with self.assertRaisesRegex(ValueError, 'could not convert'):
                    float(f(b'A' * 16))

    def test_float_memoryview(self):
        self.assertEqual(float(memoryview(b'12.3')[1:4]), 2.3)
        self.assertEqual(float(memoryview(b'12.3\x00')[1:4]), 2.3)
        self.assertEqual(float(memoryview(b'12.3 ')[1:4]), 2.3)
        self.assertEqual(float(memoryview(b'12.3A')[1:4]), 2.3)
        self.assertEqual(float(memoryview(b'12.34')[1:4]), 2.3)

    def test_error_message(self):

        def check(s):
            with self.assertRaises(ValueError, msg='float(%r)' % (s,)) as cm:
                float(s)
            self.assertEqual(str(cm.exception), 
                'could not convert string to float: %r' % (s,))
        check('½')
        check('123½')
        check('  123 456  ')
        check(b'  123 456  ')
        check('٣١٤!')
        check('123\x00')
        check('123\x00 245')
        check('123\x00245')
        check(b'123\x00')
        check(b'123\xa0')

    @support.run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE')
    def test_float_with_comma(self):
        import locale
        if not locale.localeconv()['decimal_point'] == ',':
            self.skipTest('decimal_point is not ","')
        self.assertEqual(float('  3.14  '), 3.14)
        self.assertEqual(float('+3.14  '), 3.14)
        self.assertEqual(float('-3.14  '), -3.14)
        self.assertEqual(float('.14  '), 0.14)
        self.assertEqual(float('3.  '), 3.0)
        self.assertEqual(float('3.e3  '), 3000.0)
        self.assertEqual(float('3.2e3  '), 3200.0)
        self.assertEqual(float('2.5e-1  '), 0.25)
        self.assertEqual(float('5e-1'), 0.5)
        self.assertRaises(ValueError, float, '  3,14  ')
        self.assertRaises(ValueError, float, '  +3,14  ')
        self.assertRaises(ValueError, float, '  -3,14  ')
        self.assertRaises(ValueError, float, '  0x3.1  ')
        self.assertRaises(ValueError, float, '  -0x3.p-1  ')
        self.assertRaises(ValueError, float, '  +0x3.p-1  ')
        self.assertEqual(float('  25.e-1  '), 2.5)
        self.assertAlmostEqual(float('  .25e-1  '), 0.025)

    def test_floatconversion(self):


        class Foo1(object):

            def __float__(self):
                return 42.0


        class Foo2(float):

            def __float__(self):
                return 42.0


        class Foo3(float):

            def __new__(cls, value=0.0):
                return float.__new__(cls, 2 * value)

            def __float__(self):
                return self


        class Foo4(float):

            def __float__(self):
                return 42


        class FooStr(str):

            def __float__(self):
                return float(str(self)) + 1
        self.assertEqual(float(Foo1()), 42.0)
        self.assertEqual(float(Foo2()), 42.0)
        with self.assertWarns(DeprecationWarning):
            self.assertEqual(float(Foo3(21)), 42.0)
        self.assertRaises(TypeError, float, Foo4(42))
        self.assertEqual(float(FooStr('8')), 9.0)


        class Foo5:

            def __float__(self):
                return ''
        self.assertRaises(TypeError, time.sleep, Foo5())


        class F:

            def __float__(self):
                return OtherFloatSubclass(42.0)
        with self.assertWarns(DeprecationWarning):
            self.assertEqual(float(F()), 42.0)
        with self.assertWarns(DeprecationWarning):
            self.assertIs(type(float(F())), float)
        with self.assertWarns(DeprecationWarning):
            self.assertEqual(FloatSubclass(F()), 42.0)
        with self.assertWarns(DeprecationWarning):
            self.assertIs(type(FloatSubclass(F())), FloatSubclass)

    def test_is_integer(self):
        self.assertFalse((1.1).is_integer())
        self.assertTrue((1.0).is_integer())
        self.assertFalse(float('nan').is_integer())
        self.assertFalse(float('inf').is_integer())

    def test_floatasratio(self):
        for f, ratio in [(0.875, (7, 8)), (-0.875, (-7, 8)), (0.0, (0, 1)),
            (11.5, (23, 2))]:
            self.assertEqual(f.as_integer_ratio(), ratio)
        for i in range(10000):
            f = random.random()
            f *= 10 ** random.randint(-100, 100)
            n, d = f.as_integer_ratio()
            self.assertEqual(float(n).__truediv__(d), f)
        R = fractions.Fraction
        self.assertEqual(R(0, 1), R(*float(0.0).as_integer_ratio()))
        self.assertEqual(R(5, 2), R(*float(2.5).as_integer_ratio()))
        self.assertEqual(R(1, 2), R(*float(0.5).as_integer_ratio()))
        self.assertEqual(R(4728779608739021, 2251799813685248), R(*float(
            2.1).as_integer_ratio()))
        self.assertEqual(R(-4728779608739021, 2251799813685248), R(*float(-
            2.1).as_integer_ratio()))
        self.assertEqual(R(-2100, 1), R(*float(-2100.0).as_integer_ratio()))
        self.assertRaises(OverflowError, float('inf').as_integer_ratio)
        self.assertRaises(OverflowError, float('-inf').as_integer_ratio)
        self.assertRaises(ValueError, float('nan').as_integer_ratio)

    def test_float_containment(self):
        floats = INF, -INF, 0.0, 1.0, NAN
        for f in floats:
            self.assertIn(f, [f])
            self.assertIn(f, (f,))
            self.assertIn(f, {f})
            self.assertIn(f, {f: None})
            self.assertEqual([f].count(f), 1, "[].count('%r') != 1" % f)
            self.assertIn(f, floats)
        for f in floats:
            self.assertTrue([f] == [f], '[%r] != [%r]' % (f, f))
            self.assertTrue((f,) == (f,), '(%r,) != (%r,)' % (f, f))
            self.assertTrue({f} == {f}, '{%r} != {%r}' % (f, f))
            self.assertTrue({f: None} == {f: None}, 
                '{%r : None} != {%r : None}' % (f, f))
            l, t, s, d = [f], (f,), {f}, {f: None}
            self.assertTrue(l == l, '[%r] not equal to itself' % f)
            self.assertTrue(t == t, '(%r,) not equal to itself' % f)
            self.assertTrue(s == s, '{%r} not equal to itself' % f)
            self.assertTrue(d == d, '{%r : None} not equal to itself' % f)

    def assertEqualAndEqualSign(self, a, b):
        self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b)))

    @support.requires_IEEE_754
    def test_float_mod(self):
        mod = operator.mod
        self.assertEqualAndEqualSign(mod(-1.0, 1.0), 0.0)
        self.assertEqualAndEqualSign(mod(-1e-100, 1.0), 1.0)
        self.assertEqualAndEqualSign(mod(-0.0, 1.0), 0.0)
        self.assertEqualAndEqualSign(mod(0.0, 1.0), 0.0)
        self.assertEqualAndEqualSign(mod(1e-100, 1.0), 1e-100)
        self.assertEqualAndEqualSign(mod(1.0, 1.0), 0.0)
        self.assertEqualAndEqualSign(mod(-1.0, -1.0), -0.0)
        self.assertEqualAndEqualSign(mod(-1e-100, -1.0), -1e-100)
        self.assertEqualAndEqualSign(mod(-0.0, -1.0), -0.0)
        self.assertEqualAndEqualSign(mod(0.0, -1.0), -0.0)
        self.assertEqualAndEqualSign(mod(1e-100, -1.0), -1.0)
        self.assertEqualAndEqualSign(mod(1.0, -1.0), -0.0)

    @support.requires_IEEE_754
    def test_float_pow(self):
        for pow_op in (pow, operator.pow):
            self.assertTrue(isnan(pow_op(-INF, NAN)))
            self.assertTrue(isnan(pow_op(-2.0, NAN)))
            self.assertTrue(isnan(pow_op(-1.0, NAN)))
            self.assertTrue(isnan(pow_op(-0.5, NAN)))
            self.assertTrue(isnan(pow_op(-0.0, NAN)))
            self.assertTrue(isnan(pow_op(0.0, NAN)))
            self.assertTrue(isnan(pow_op(0.5, NAN)))
            self.assertTrue(isnan(pow_op(2.0, NAN)))
            self.assertTrue(isnan(pow_op(INF, NAN)))
            self.assertTrue(isnan(pow_op(NAN, NAN)))
            self.assertTrue(isnan(pow_op(NAN, -INF)))
            self.assertTrue(isnan(pow_op(NAN, -2.0)))
            self.assertTrue(isnan(pow_op(NAN, -1.0)))
            self.assertTrue(isnan(pow_op(NAN, -0.5)))
            self.assertTrue(isnan(pow_op(NAN, 0.5)))
            self.assertTrue(isnan(pow_op(NAN, 1.0)))
            self.assertTrue(isnan(pow_op(NAN, 2.0)))
            self.assertTrue(isnan(pow_op(NAN, INF)))
            self.assertRaises(ZeroDivisionError, pow_op, -0.0, -1.0)
            self.assertRaises(ZeroDivisionError, pow_op, 0.0, -1.0)
            self.assertRaises(ZeroDivisionError, pow_op, -0.0, -2.0)
            self.assertRaises(ZeroDivisionError, pow_op, -0.0, -0.5)
            self.assertRaises(ZeroDivisionError, pow_op, 0.0, -2.0)
            self.assertRaises(ZeroDivisionError, pow_op, 0.0, -0.5)
            self.assertEqualAndEqualSign(pow_op(-0.0, 1.0), -0.0)
            self.assertEqualAndEqualSign(pow_op(0.0, 1.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(-0.0, 0.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(-0.0, 2.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.0, 0.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.0, 2.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -INF), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, INF), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -INF), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -2.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -1.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -0.5), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 0.5), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 1.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 2.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, INF), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, NAN), 1.0)
            self.assertEqualAndEqualSign(pow_op(-INF, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-0.5, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-0.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(0.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(0.5, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(INF, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(NAN, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-INF, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-0.5, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-0.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(0.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(0.5, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(INF, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(NAN, -0.0), 1.0)
            self.assertEqual(type(pow_op(-2.0, -0.5)), complex)
            self.assertEqual(type(pow_op(-2.0, 0.5)), complex)
            self.assertEqual(type(pow_op(-1.0, -0.5)), complex)
            self.assertEqual(type(pow_op(-1.0, 0.5)), complex)
            self.assertEqual(type(pow_op(-0.5, -0.5)), complex)
            self.assertEqual(type(pow_op(-0.5, 0.5)), complex)
            self.assertEqualAndEqualSign(pow_op(-0.5, -INF), INF)
            self.assertEqualAndEqualSign(pow_op(-0.0, -INF), INF)
            self.assertEqualAndEqualSign(pow_op(0.0, -INF), INF)
            self.assertEqualAndEqualSign(pow_op(0.5, -INF), INF)
            self.assertEqualAndEqualSign(pow_op(-INF, -INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, -INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(INF, -INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(-0.5, INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(-0.0, INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.0, INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.5, INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(-INF, INF), INF)
            self.assertEqualAndEqualSign(pow_op(-2.0, INF), INF)
            self.assertEqualAndEqualSign(pow_op(2.0, INF), INF)
            self.assertEqualAndEqualSign(pow_op(INF, INF), INF)
            self.assertEqualAndEqualSign(pow_op(-INF, -1.0), -0.0)
            self.assertEqualAndEqualSign(pow_op(-INF, -0.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(-INF, -2.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(-INF, 1.0), -INF)
            self.assertEqualAndEqualSign(pow_op(-INF, 0.5), INF)
            self.assertEqualAndEqualSign(pow_op(-INF, 2.0), INF)
            self.assertEqualAndEqualSign(pow_op(INF, 0.5), INF)
            self.assertEqualAndEqualSign(pow_op(INF, 1.0), INF)
            self.assertEqualAndEqualSign(pow_op(INF, 2.0), INF)
            self.assertEqualAndEqualSign(pow_op(INF, -2.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(INF, -1.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(INF, -0.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, -2.0), 0.25)
            self.assertEqualAndEqualSign(pow_op(-2.0, -1.0), -0.5)
            self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, 1.0), -2.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, 2.0), 4.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -2.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -1.0), -1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, 1.0), -1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, 2.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -2.0), 0.25)
            self.assertEqualAndEqualSign(pow_op(2.0, -1.0), 0.5)
            self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(2.0, 1.0), 2.0)
            self.assertEqualAndEqualSign(pow_op(2.0, 2.0), 4.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -1e+100), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 1e+100), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -1e+100), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, 1e+100), 1.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, -2000.0), 0.0)
            self.assertEqual(type(pow_op(-2.0, -2000.5)), complex)
            self.assertEqualAndEqualSign(pow_op(-2.0, -2001.0), -0.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -2000.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -2000.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -2001.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(-0.5, 2000.0), 0.0)
            self.assertEqual(type(pow_op(-0.5, 2000.5)), complex)
            self.assertEqualAndEqualSign(pow_op(-0.5, 2001.0), -0.0)
            self.assertEqualAndEqualSign(pow_op(0.5, 2000.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.5, 2000.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.5, 2001.0), 0.0)


@requires_setformat
class FormatFunctionsTestCase(unittest.TestCase):

    def setUp(self):
        self.save_formats = {'double': float.__getformat__('double'),
            'float': float.__getformat__('float')}

    def tearDown(self):
        float.__setformat__('double', self.save_formats['double'])
        float.__setformat__('float', self.save_formats['float'])

    def test_getformat(self):
        self.assertIn(float.__getformat__('double'), ['unknown',
            'IEEE, big-endian', 'IEEE, little-endian'])
        self.assertIn(float.__getformat__('float'), ['unknown',
            'IEEE, big-endian', 'IEEE, little-endian'])
        self.assertRaises(ValueError, float.__getformat__, 'chicken')
        self.assertRaises(TypeError, float.__getformat__, 1)

    def test_setformat(self):
        for t in ('double', 'float'):
            float.__setformat__(t, 'unknown')
            if self.save_formats[t] == 'IEEE, big-endian':
                self.assertRaises(ValueError, float.__setformat__, t,
                    'IEEE, little-endian')
            elif self.save_formats[t] == 'IEEE, little-endian':
                self.assertRaises(ValueError, float.__setformat__, t,
                    'IEEE, big-endian')
            else:
                self.assertRaises(ValueError, float.__setformat__, t,
                    'IEEE, big-endian')
                self.assertRaises(ValueError, float.__setformat__, t,
                    'IEEE, little-endian')
            self.assertRaises(ValueError, float.__setformat__, t, 'chicken')
        self.assertRaises(ValueError, float.__setformat__, 'chicken', 'unknown'
            )


BE_DOUBLE_INF = b'\x7f\xf0\x00\x00\x00\x00\x00\x00'
LE_DOUBLE_INF = bytes(reversed(BE_DOUBLE_INF))
BE_DOUBLE_NAN = b'\x7f\xf8\x00\x00\x00\x00\x00\x00'
LE_DOUBLE_NAN = bytes(reversed(BE_DOUBLE_NAN))
BE_FLOAT_INF = b'\x7f\x80\x00\x00'
LE_FLOAT_INF = bytes(reversed(BE_FLOAT_INF))
BE_FLOAT_NAN = b'\x7f\xc0\x00\x00'
LE_FLOAT_NAN = bytes(reversed(BE_FLOAT_NAN))


@requires_setformat
class UnknownFormatTestCase(unittest.TestCase):

    def setUp(self):
        self.save_formats = {'double': float.__getformat__('double'),
            'float': float.__getformat__('float')}
        float.__setformat__('double', 'unknown')
        float.__setformat__('float', 'unknown')

    def tearDown(self):
        float.__setformat__('double', self.save_formats['double'])
        float.__setformat__('float', self.save_formats['float'])

    def test_double_specials_dont_unpack(self):
        for fmt, data in [('>d', BE_DOUBLE_INF), ('>d', BE_DOUBLE_NAN), (
            '<d', LE_DOUBLE_INF), ('<d', LE_DOUBLE_NAN)]:
            self.assertRaises(ValueError, struct.unpack, fmt, data)

    def test_float_specials_dont_unpack(self):
        for fmt, data in [('>f', BE_FLOAT_INF), ('>f', BE_FLOAT_NAN), ('<f',
            LE_FLOAT_INF), ('<f', LE_FLOAT_NAN)]:
            self.assertRaises(ValueError, struct.unpack, fmt, data)


class IEEEFormatTestCase(unittest.TestCase):

    @support.requires_IEEE_754
    def test_double_specials_do_unpack(self):
        for fmt, data in [('>d', BE_DOUBLE_INF), ('>d', BE_DOUBLE_NAN), (
            '<d', LE_DOUBLE_INF), ('<d', LE_DOUBLE_NAN)]:
            struct.unpack(fmt, data)

    @support.requires_IEEE_754
    def test_float_specials_do_unpack(self):
        for fmt, data in [('>f', BE_FLOAT_INF), ('>f', BE_FLOAT_NAN), ('<f',
            LE_FLOAT_INF), ('<f', LE_FLOAT_NAN)]:
            struct.unpack(fmt, data)


class FormatTestCase(unittest.TestCase):

    def test_format(self):
        self.assertEqual(format(0.0, 'f'), '0.000000')
        self.assertEqual(format(0.0, ''), '0.0')
        self.assertEqual(format(0.01, ''), '0.01')
        self.assertEqual(format(0.01, 'g'), '0.01')
        x = 100 / 7.0
        self.assertEqual(format(x, ''), str(x))
        self.assertEqual(format(x, '-'), str(x))
        self.assertEqual(format(x, '>'), str(x))
        self.assertEqual(format(x, '2'), str(x))
        self.assertEqual(format(1.0, 'f'), '1.000000')
        self.assertEqual(format(-1.0, 'f'), '-1.000000')
        self.assertEqual(format(1.0, ' f'), ' 1.000000')
        self.assertEqual(format(-1.0, ' f'), '-1.000000')
        self.assertEqual(format(1.0, '+f'), '+1.000000')
        self.assertEqual(format(-1.0, '+f'), '-1.000000')
        self.assertEqual(format(-1.0, '%'), '-100.000000%')
        self.assertRaises(ValueError, format, 3.0, 's')
        for format_spec in ([chr(x) for x in range(ord('a'), ord('z') + 1)] +
            [chr(x) for x in range(ord('A'), ord('Z') + 1)]):
            if not format_spec in 'eEfFgGn%':
                self.assertRaises(ValueError, format, 0.0, format_spec)
                self.assertRaises(ValueError, format, 1.0, format_spec)
                self.assertRaises(ValueError, format, -1.0, format_spec)
                self.assertRaises(ValueError, format, 1e+100, format_spec)
                self.assertRaises(ValueError, format, -1e+100, format_spec)
                self.assertRaises(ValueError, format, 1e-100, format_spec)
                self.assertRaises(ValueError, format, -1e-100, format_spec)
        self.assertEqual(format(NAN, 'f'), 'nan')
        self.assertEqual(format(NAN, 'F'), 'NAN')
        self.assertEqual(format(INF, 'f'), 'inf')
        self.assertEqual(format(INF, 'F'), 'INF')

    @support.requires_IEEE_754
    def test_format_testfile(self):
        with open(format_testfile) as testfile:
            for line in testfile:
                if line.startswith('--'):
                    continue
                line = line.strip()
                if not line:
                    continue
                lhs, rhs = map(str.strip, line.split('->'))
                fmt, arg = lhs.split()
                self.assertEqual(fmt % float(arg), rhs)
                self.assertEqual(fmt % -float(arg), '-' + rhs)

    def test_issue5864(self):
        self.assertEqual(format(123.456, '.4'), '123.5')
        self.assertEqual(format(1234.56, '.4'), '1.235e+03')
        self.assertEqual(format(12345.6, '.4'), '1.235e+04')


class ReprTestCase(unittest.TestCase):

    def test_repr(self):
        floats_file = open(os.path.join(os.path.split(__file__)[0],
            'floating_points.txt'))
        for line in floats_file:
            line = line.strip()
            if not line or line.startswith('#'):
                continue
            v = eval(line)
            self.assertEqual(v, eval(repr(v)))
        floats_file.close()

    @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
        'applies only when using short float repr style')
    def test_short_repr(self):
        test_strings = ['0.0', '1.0', '0.01', '0.02', '0.03', '0.04',
            '0.05', '1.23456789', '10.0', '100.0', '1000000000000000.0',
            '9999999999999990.0', '1e+16', '1e+17', '0.001', '0.001001',
            '0.00010000000000001', '0.0001', '9.999999999999e-05', '1e-05',
            '8.72293771110361e+25', '7.47005307342313e+26',
            '2.86438000439698e+28', '8.89142905246179e+28',
            '3.08578087079232e+35']
        for s in test_strings:
            negs = '-' + s
            self.assertEqual(s, repr(float(s)))
            self.assertEqual(negs, repr(float(negs)))
            self.assertEqual(repr(float(s)), str(float(s)))
            self.assertEqual(repr(float(negs)), str(float(negs)))


@support.requires_IEEE_754
class RoundTestCase(unittest.TestCase):

    def test_inf_nan(self):
        self.assertRaises(OverflowError, round, INF)
        self.assertRaises(OverflowError, round, -INF)
        self.assertRaises(ValueError, round, NAN)
        self.assertRaises(TypeError, round, INF, 0.0)
        self.assertRaises(TypeError, round, -INF, 1.0)
        self.assertRaises(TypeError, round, NAN, "ceci n'est pas un integer")
        self.assertRaises(TypeError, round, -0.0, 1j)

    def test_large_n(self):
        for n in [324, 325, 400, 2 ** 31 - 1, 2 ** 31, 2 ** 32, 2 ** 100]:
            self.assertEqual(round(123.456, n), 123.456)
            self.assertEqual(round(-123.456, n), -123.456)
            self.assertEqual(round(1e+300, n), 1e+300)
            self.assertEqual(round(1e-320, n), 1e-320)
        self.assertEqual(round(1e+150, 300), 1e+150)
        self.assertEqual(round(1e+300, 307), 1e+300)
        self.assertEqual(round(-3.1415, 308), -3.1415)
        self.assertEqual(round(1e+150, 309), 1e+150)
        self.assertEqual(round(1.4e-315, 315), 1e-315)

    def test_small_n(self):
        for n in [-308, -309, -400, 1 - 2 ** 31, -2 ** 31, -2 ** 31 - 1, -2 **
            100]:
            self.assertEqual(round(123.456, n), 0.0)
            self.assertEqual(round(-123.456, n), -0.0)
            self.assertEqual(round(1e+300, n), 0.0)
            self.assertEqual(round(1e-320, n), 0.0)

    def test_overflow(self):
        self.assertRaises(OverflowError, round, 1.6e+308, -308)
        self.assertRaises(OverflowError, round, -1.7e+308, -308)

    @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
        'applies only when using short float repr style')
    def test_previous_round_bugs(self):
        self.assertEqual(round(562949953421312.5, 1), 562949953421312.5)
        self.assertEqual(round(56294995342131.5, 3), 56294995342131.5)
        self.assertEqual(round(25.0, -1), 20.0)
        self.assertEqual(round(35.0, -1), 40.0)
        self.assertEqual(round(45.0, -1), 40.0)
        self.assertEqual(round(55.0, -1), 60.0)
        self.assertEqual(round(65.0, -1), 60.0)
        self.assertEqual(round(75.0, -1), 80.0)
        self.assertEqual(round(85.0, -1), 80.0)
        self.assertEqual(round(95.0, -1), 100.0)

    @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
        'applies only when using short float repr style')
    def test_matches_float_format(self):
        for i in range(500):
            x = i / 1000.0
            self.assertEqual(float(format(x, '.0f')), round(x, 0))
            self.assertEqual(float(format(x, '.1f')), round(x, 1))
            self.assertEqual(float(format(x, '.2f')), round(x, 2))
            self.assertEqual(float(format(x, '.3f')), round(x, 3))
        for i in range(5, 5000, 10):
            x = i / 1000.0
            self.assertEqual(float(format(x, '.0f')), round(x, 0))
            self.assertEqual(float(format(x, '.1f')), round(x, 1))
            self.assertEqual(float(format(x, '.2f')), round(x, 2))
            self.assertEqual(float(format(x, '.3f')), round(x, 3))
        for i in range(500):
            x = random.random()
            self.assertEqual(float(format(x, '.0f')), round(x, 0))
            self.assertEqual(float(format(x, '.1f')), round(x, 1))
            self.assertEqual(float(format(x, '.2f')), round(x, 2))
            self.assertEqual(float(format(x, '.3f')), round(x, 3))

    def test_format_specials(self):

        def test(fmt, value, expected):
            self.assertEqual(fmt % value, expected, fmt)
            fmt = fmt[1:]
            self.assertEqual(format(value, fmt), expected, fmt)
        for fmt in ['%e', '%f', '%g', '%.0e', '%.6f', '%.20g', '%#e', '%#f',
            '%#g', '%#.20e', '%#.15f', '%#.3g']:
            pfmt = '%+' + fmt[1:]
            sfmt = '% ' + fmt[1:]
            test(fmt, INF, 'inf')
            test(fmt, -INF, '-inf')
            test(fmt, NAN, 'nan')
            test(fmt, -NAN, 'nan')
            test(pfmt, INF, '+inf')
            test(pfmt, -INF, '-inf')
            test(pfmt, NAN, '+nan')
            test(pfmt, -NAN, '+nan')
            test(sfmt, INF, ' inf')
            test(sfmt, -INF, '-inf')
            test(sfmt, NAN, ' nan')
            test(sfmt, -NAN, ' nan')

    def test_None_ndigits(self):
        for x in (round(1.23), round(1.23, None), round(1.23, ndigits=None)):
            self.assertEqual(x, 1)
            self.assertIsInstance(x, int)
        for x in (round(1.78), round(1.78, None), round(1.78, ndigits=None)):
            self.assertEqual(x, 2)
            self.assertIsInstance(x, int)


class InfNanTest(unittest.TestCase):

    def test_inf_from_str(self):
        self.assertTrue(isinf(float('inf')))
        self.assertTrue(isinf(float('+inf')))
        self.assertTrue(isinf(float('-inf')))
        self.assertTrue(isinf(float('infinity')))
        self.assertTrue(isinf(float('+infinity')))
        self.assertTrue(isinf(float('-infinity')))
        self.assertEqual(repr(float('inf')), 'inf')
        self.assertEqual(repr(float('+inf')), 'inf')
        self.assertEqual(repr(float('-inf')), '-inf')
        self.assertEqual(repr(float('infinity')), 'inf')
        self.assertEqual(repr(float('+infinity')), 'inf')
        self.assertEqual(repr(float('-infinity')), '-inf')
        self.assertEqual(repr(float('INF')), 'inf')
        self.assertEqual(repr(float('+Inf')), 'inf')
        self.assertEqual(repr(float('-iNF')), '-inf')
        self.assertEqual(repr(float('Infinity')), 'inf')
        self.assertEqual(repr(float('+iNfInItY')), 'inf')
        self.assertEqual(repr(float('-INFINITY')), '-inf')
        self.assertEqual(str(float('inf')), 'inf')
        self.assertEqual(str(float('+inf')), 'inf')
        self.assertEqual(str(float('-inf')), '-inf')
        self.assertEqual(str(float('infinity')), 'inf')
        self.assertEqual(str(float('+infinity')), 'inf')
        self.assertEqual(str(float('-infinity')), '-inf')
        self.assertRaises(ValueError, float, 'info')
        self.assertRaises(ValueError, float, '+info')
        self.assertRaises(ValueError, float, '-info')
        self.assertRaises(ValueError, float, 'in')
        self.assertRaises(ValueError, float, '+in')
        self.assertRaises(ValueError, float, '-in')
        self.assertRaises(ValueError, float, 'infinit')
        self.assertRaises(ValueError, float, '+Infin')
        self.assertRaises(ValueError, float, '-INFI')
        self.assertRaises(ValueError, float, 'infinitys')
        self.assertRaises(ValueError, float, '++Inf')
        self.assertRaises(ValueError, float, '-+inf')
        self.assertRaises(ValueError, float, '+-infinity')
        self.assertRaises(ValueError, float, '--Infinity')

    def test_inf_as_str(self):
        self.assertEqual(repr(1e+300 * 1e+300), 'inf')
        self.assertEqual(repr(-1e+300 * 1e+300), '-inf')
        self.assertEqual(str(1e+300 * 1e+300), 'inf')
        self.assertEqual(str(-1e+300 * 1e+300), '-inf')

    def test_nan_from_str(self):
        self.assertTrue(isnan(float('nan')))
        self.assertTrue(isnan(float('+nan')))
        self.assertTrue(isnan(float('-nan')))
        self.assertEqual(repr(float('nan')), 'nan')
        self.assertEqual(repr(float('+nan')), 'nan')
        self.assertEqual(repr(float('-nan')), 'nan')
        self.assertEqual(repr(float('NAN')), 'nan')
        self.assertEqual(repr(float('+NAn')), 'nan')
        self.assertEqual(repr(float('-NaN')), 'nan')
        self.assertEqual(str(float('nan')), 'nan')
        self.assertEqual(str(float('+nan')), 'nan')
        self.assertEqual(str(float('-nan')), 'nan')
        self.assertRaises(ValueError, float, 'nana')
        self.assertRaises(ValueError, float, '+nana')
        self.assertRaises(ValueError, float, '-nana')
        self.assertRaises(ValueError, float, 'na')
        self.assertRaises(ValueError, float, '+na')
        self.assertRaises(ValueError, float, '-na')
        self.assertRaises(ValueError, float, '++nan')
        self.assertRaises(ValueError, float, '-+NAN')
        self.assertRaises(ValueError, float, '+-NaN')
        self.assertRaises(ValueError, float, '--nAn')

    def test_nan_as_str(self):
        self.assertEqual(repr(1e+300 * 1e+300 * 0), 'nan')
        self.assertEqual(repr(-1e+300 * 1e+300 * 0), 'nan')
        self.assertEqual(str(1e+300 * 1e+300 * 0), 'nan')
        self.assertEqual(str(-1e+300 * 1e+300 * 0), 'nan')

    def test_inf_signs(self):
        self.assertEqual(copysign(1.0, float('inf')), 1.0)
        self.assertEqual(copysign(1.0, float('-inf')), -1.0)

    @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
        'applies only when using short float repr style')
    def test_nan_signs(self):
        self.assertEqual(copysign(1.0, float('nan')), 1.0)
        self.assertEqual(copysign(1.0, float('-nan')), -1.0)


fromHex = float.fromhex
toHex = float.hex


class HexFloatTestCase(unittest.TestCase):
    MAX = fromHex('0x.fffffffffffff8p+1024')
    MIN = fromHex('0x1p-1022')
    TINY = fromHex('0x0.0000000000001p-1022')
    EPS = fromHex('0x0.0000000000001p0')

    def identical(self, x, y):
        if isnan(x) or isnan(y):
            if isnan(x) == isnan(y):
                return
        elif x == y and (x != 0.0 or copysign(1.0, x) == copysign(1.0, y)):
            return
        self.fail('%r not identical to %r' % (x, y))

    def test_ends(self):
        self.identical(self.MIN, ldexp(1.0, -1022))
        self.identical(self.TINY, ldexp(1.0, -1074))
        self.identical(self.EPS, ldexp(1.0, -52))
        self.identical(self.MAX, 2.0 * (ldexp(1.0, 1023) - ldexp(1.0, 970)))

    def test_invalid_inputs(self):
        invalid_inputs = ['infi', '-Infinit', '++inf', '-+Inf', '--nan',
            '+-NaN', 'snan', 'NaNs', 'nna', 'an', 'nf', 'nfinity', 'inity',
            'iinity', '0xnan', '', ' ', 'x1.0p0', '0xX1.0p0', '+ 0x1.0p0',
            '- 0x1.0p0', '0 x1.0p0', '0x 1.0p0', '0x1 2.0p0', '+0x1 .0p0',
            '0x1. 0p0', '-0x1.0 1p0', '-0x1.0 p0', '+0x1.0p +0',
            '0x1.0p -0', '0x1.0p 0', '+0x1.0p+ 0', '-0x1.0p- 0',
            '++0x1.0p-0', '--0x1.0p0', '+-0x1.0p+0', '-+0x1.0p0',
            '0x1.0p++0', '+0x1.0p+-0', '-0x1.0p-+0', '0x1.0p--0',
            '0x1.0.p0', '0x.p0', '0x1,p0', '0x1pa', '0x1p０', '０x1p0',
            '0x１p0', '0x1.０p0', '0x1p0 \n 0x2p0', '0x1p0\x00 0x1p0']
        for x in invalid_inputs:
            try:
                result = fromHex(x)
            except ValueError:
                pass
            else:
                self.fail(
                    'Expected float.fromhex(%r) to raise ValueError; got %r instead'
                     % (x, result))

    def test_whitespace(self):
        value_pairs = [('inf', INF), ('-Infinity', -INF), ('nan', NAN), (
            '1.0', 1.0), ('-0x.2', -0.125), ('-0.0', -0.0)]
        whitespace = ['', ' ', '\t', '\n', '\n \t', '\x0c', '\x0b', '\r']
        for inp, expected in value_pairs:
            for lead in whitespace:
                for trail in whitespace:
                    got = fromHex(lead + inp + trail)
                    self.identical(got, expected)

    def test_from_hex(self):
        MIN = self.MIN
        MAX = self.MAX
        TINY = self.TINY
        EPS = self.EPS
        self.identical(fromHex('inf'), INF)
        self.identical(fromHex('+Inf'), INF)
        self.identical(fromHex('-INF'), -INF)
        self.identical(fromHex('iNf'), INF)
        self.identical(fromHex('Infinity'), INF)
        self.identical(fromHex('+INFINITY'), INF)
        self.identical(fromHex('-infinity'), -INF)
        self.identical(fromHex('-iNFiNitY'), -INF)
        self.identical(fromHex('nan'), NAN)
        self.identical(fromHex('+NaN'), NAN)
        self.identical(fromHex('-NaN'), NAN)
        self.identical(fromHex('-nAN'), NAN)
        self.identical(fromHex('1'), 1.0)
        self.identical(fromHex('+1'), 1.0)
        self.identical(fromHex('1.'), 1.0)
        self.identical(fromHex('1.0'), 1.0)
        self.identical(fromHex('1.0p0'), 1.0)
        self.identical(fromHex('01'), 1.0)
        self.identical(fromHex('01.'), 1.0)
        self.identical(fromHex('0x1'), 1.0)
        self.identical(fromHex('0x1.'), 1.0)
        self.identical(fromHex('0x1.0'), 1.0)
        self.identical(fromHex('+0x1.0'), 1.0)
        self.identical(fromHex('0x1p0'), 1.0)
        self.identical(fromHex('0X1p0'), 1.0)
        self.identical(fromHex('0X1P0'), 1.0)
        self.identical(fromHex('0x1P0'), 1.0)
        self.identical(fromHex('0x1.p0'), 1.0)
        self.identical(fromHex('0x1.0p0'), 1.0)
        self.identical(fromHex('0x.1p4'), 1.0)
        self.identical(fromHex('0x.1p04'), 1.0)
        self.identical(fromHex('0x.1p004'), 1.0)
        self.identical(fromHex('0x1p+0'), 1.0)
        self.identical(fromHex('0x1P-0'), 1.0)
        self.identical(fromHex('+0x1p0'), 1.0)
        self.identical(fromHex('0x01p0'), 1.0)
        self.identical(fromHex('0x1p00'), 1.0)
        self.identical(fromHex(' 0x1p0 '), 1.0)
        self.identical(fromHex('\n 0x1p0'), 1.0)
        self.identical(fromHex('0x1p0 \t'), 1.0)
        self.identical(fromHex('0xap0'), 10.0)
        self.identical(fromHex('0xAp0'), 10.0)
        self.identical(fromHex('0xaP0'), 10.0)
        self.identical(fromHex('0xAP0'), 10.0)
        self.identical(fromHex('0xbep0'), 190.0)
        self.identical(fromHex('0xBep0'), 190.0)
        self.identical(fromHex('0xbEp0'), 190.0)
        self.identical(fromHex('0XBE0P-4'), 190.0)
        self.identical(fromHex('0xBEp0'), 190.0)
        self.identical(fromHex('0xB.Ep4'), 190.0)
        self.identical(fromHex('0x.BEp8'), 190.0)
        self.identical(fromHex('0x.0BEp12'), 190.0)
        pi = fromHex('0x1.921fb54442d18p1')
        self.identical(fromHex('0x.006487ed5110b46p11'), pi)
        self.identical(fromHex('0x.00c90fdaa22168cp10'), pi)
        self.identical(fromHex('0x.01921fb54442d18p9'), pi)
        self.identical(fromHex('0x.03243f6a8885a3p8'), pi)
        self.identical(fromHex('0x.06487ed5110b46p7'), pi)
        self.identical(fromHex('0x.0c90fdaa22168cp6'), pi)
        self.identical(fromHex('0x.1921fb54442d18p5'), pi)
        self.identical(fromHex('0x.3243f6a8885a3p4'), pi)
        self.identical(fromHex('0x.6487ed5110b46p3'), pi)
        self.identical(fromHex('0x.c90fdaa22168cp2'), pi)
        self.identical(fromHex('0x1.921fb54442d18p1'), pi)
        self.identical(fromHex('0x3.243f6a8885a3p0'), pi)
        self.identical(fromHex('0x6.487ed5110b46p-1'), pi)
        self.identical(fromHex('0xc.90fdaa22168cp-2'), pi)
        self.identical(fromHex('0x19.21fb54442d18p-3'), pi)
        self.identical(fromHex('0x32.43f6a8885a3p-4'), pi)
        self.identical(fromHex('0x64.87ed5110b46p-5'), pi)
        self.identical(fromHex('0xc9.0fdaa22168cp-6'), pi)
        self.identical(fromHex('0x192.1fb54442d18p-7'), pi)
        self.identical(fromHex('0x324.3f6a8885a3p-8'), pi)
        self.identical(fromHex('0x648.7ed5110b46p-9'), pi)
        self.identical(fromHex('0xc90.fdaa22168cp-10'), pi)
        self.identical(fromHex('0x1921.fb54442d18p-11'), pi)
        self.identical(fromHex('0x1921fb54442d1.8p-47'), pi)
        self.identical(fromHex('0x3243f6a8885a3p-48'), pi)
        self.identical(fromHex('0x6487ed5110b46p-49'), pi)
        self.identical(fromHex('0xc90fdaa22168cp-50'), pi)
        self.identical(fromHex('0x1921fb54442d18p-51'), pi)
        self.identical(fromHex('0x3243f6a8885a30p-52'), pi)
        self.identical(fromHex('0x6487ed5110b460p-53'), pi)
        self.identical(fromHex('0xc90fdaa22168c0p-54'), pi)
        self.identical(fromHex('0x1921fb54442d180p-55'), pi)
        self.assertRaises(OverflowError, fromHex, '-0x1p1024')
        self.assertRaises(OverflowError, fromHex, '0x1p+1025')
        self.assertRaises(OverflowError, fromHex, '+0X1p1030')
        self.assertRaises(OverflowError, fromHex, '-0x1p+1100')
        self.assertRaises(OverflowError, fromHex, '0X1p123456789123456789')
        self.assertRaises(OverflowError, fromHex, '+0X.8p+1025')
        self.assertRaises(OverflowError, fromHex, '+0x0.8p1025')
        self.assertRaises(OverflowError, fromHex, '-0x0.4p1026')
        self.assertRaises(OverflowError, fromHex, '0X2p+1023')
        self.assertRaises(OverflowError, fromHex, '0x2.p1023')
        self.assertRaises(OverflowError, fromHex, '-0x2.0p+1023')
        self.assertRaises(OverflowError, fromHex, '+0X4p+1022')
        self.assertRaises(OverflowError, fromHex, '0x1.ffffffffffffffp+1023')
        self.assertRaises(OverflowError, fromHex, '-0X1.fffffffffffff9p1023')
        self.assertRaises(OverflowError, fromHex, '0X1.fffffffffffff8p1023')
        self.assertRaises(OverflowError, fromHex, '+0x3.fffffffffffffp1022')
        self.assertRaises(OverflowError, fromHex, '0x3fffffffffffffp+970')
        self.assertRaises(OverflowError, fromHex, '0x10000000000000000p960')
        self.assertRaises(OverflowError, fromHex, '-0Xffffffffffffffffp960')
        self.identical(fromHex('+0x1.fffffffffffffp+1023'), MAX)
        self.identical(fromHex('-0X1.fffffffffffff7p1023'), -MAX)
        self.identical(fromHex('0X1.fffffffffffff7fffffffffffffp1023'), MAX)
        self.identical(fromHex('0x0p0'), 0.0)
        self.identical(fromHex('0x0p1000'), 0.0)
        self.identical(fromHex('-0x0p1023'), -0.0)
        self.identical(fromHex('0X0p1024'), 0.0)
        self.identical(fromHex('-0x0p1025'), -0.0)
        self.identical(fromHex('0X0p2000'), 0.0)
        self.identical(fromHex('0x0p123456789123456789'), 0.0)
        self.identical(fromHex('-0X0p-0'), -0.0)
        self.identical(fromHex('-0X0p-1000'), -0.0)
        self.identical(fromHex('0x0p-1023'), 0.0)
        self.identical(fromHex('-0X0p-1024'), -0.0)
        self.identical(fromHex('-0x0p-1025'), -0.0)
        self.identical(fromHex('-0x0p-1072'), -0.0)
        self.identical(fromHex('0X0p-1073'), 0.0)
        self.identical(fromHex('-0x0p-1074'), -0.0)
        self.identical(fromHex('0x0p-1075'), 0.0)
        self.identical(fromHex('0X0p-1076'), 0.0)
        self.identical(fromHex('-0X0p-2000'), -0.0)
        self.identical(fromHex('-0x0p-123456789123456789'), -0.0)
        self.identical(fromHex('0X1p-1075'), 0.0)
        self.identical(fromHex('-0X1p-1075'), -0.0)
        self.identical(fromHex('-0x1p-123456789123456789'), -0.0)
        self.identical(fromHex('0x1.00000000000000001p-1075'), TINY)
        self.identical(fromHex('-0x1.1p-1075'), -TINY)
        self.identical(fromHex('0x1.fffffffffffffffffp-1075'), TINY)
        self.identical(fromHex('0x1p-1076'), 0.0)
        self.identical(fromHex('0X2p-1076'), 0.0)
        self.identical(fromHex('0X3p-1076'), TINY)
        self.identical(fromHex('0x4p-1076'), TINY)
        self.identical(fromHex('0X5p-1076'), TINY)
        self.identical(fromHex('0X6p-1076'), 2 * TINY)
        self.identical(fromHex('0x7p-1076'), 2 * TINY)
        self.identical(fromHex('0X8p-1076'), 2 * TINY)
        self.identical(fromHex('0X9p-1076'), 2 * TINY)
        self.identical(fromHex('0xap-1076'), 2 * TINY)
        self.identical(fromHex('0Xbp-1076'), 3 * TINY)
        self.identical(fromHex('0xcp-1076'), 3 * TINY)
        self.identical(fromHex('0Xdp-1076'), 3 * TINY)
        self.identical(fromHex('0Xep-1076'), 4 * TINY)
        self.identical(fromHex('0xfp-1076'), 4 * TINY)
        self.identical(fromHex('0x10p-1076'), 4 * TINY)
        self.identical(fromHex('-0x1p-1076'), -0.0)
        self.identical(fromHex('-0X2p-1076'), -0.0)
        self.identical(fromHex('-0x3p-1076'), -TINY)
        self.identical(fromHex('-0X4p-1076'), -TINY)
        self.identical(fromHex('-0x5p-1076'), -TINY)
        self.identical(fromHex('-0x6p-1076'), -2 * TINY)
        self.identical(fromHex('-0X7p-1076'), -2 * TINY)
        self.identical(fromHex('-0X8p-1076'), -2 * TINY)
        self.identical(fromHex('-0X9p-1076'), -2 * TINY)
        self.identical(fromHex('-0Xap-1076'), -2 * TINY)
        self.identical(fromHex('-0xbp-1076'), -3 * TINY)
        self.identical(fromHex('-0xcp-1076'), -3 * TINY)
        self.identical(fromHex('-0Xdp-1076'), -3 * TINY)
        self.identical(fromHex('-0xep-1076'), -4 * TINY)
        self.identical(fromHex('-0Xfp-1076'), -4 * TINY)
        self.identical(fromHex('-0X10p-1076'), -4 * TINY)
        self.identical(fromHex('0x0.ffffffffffffd6p-1022'), MIN - 3 * TINY)
        self.identical(fromHex('0x0.ffffffffffffd8p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffdap-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffdcp-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffdep-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffe0p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffe2p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffe4p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffe6p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffe8p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffeap-1022'), MIN - TINY)
        self.identical(fromHex('0x0.ffffffffffffecp-1022'), MIN - TINY)
        self.identical(fromHex('0x0.ffffffffffffeep-1022'), MIN - TINY)
        self.identical(fromHex('0x0.fffffffffffff0p-1022'), MIN - TINY)
        self.identical(fromHex('0x0.fffffffffffff2p-1022'), MIN - TINY)
        self.identical(fromHex('0x0.fffffffffffff4p-1022'), MIN - TINY)
        self.identical(fromHex('0x0.fffffffffffff6p-1022'), MIN - TINY)
        self.identical(fromHex('0x0.fffffffffffff8p-1022'), MIN)
        self.identical(fromHex('0x0.fffffffffffffap-1022'), MIN)
        self.identical(fromHex('0x0.fffffffffffffcp-1022'), MIN)
        self.identical(fromHex('0x0.fffffffffffffep-1022'), MIN)
        self.identical(fromHex('0x1.00000000000000p-1022'), MIN)
        self.identical(fromHex('0x1.00000000000002p-1022'), MIN)
        self.identical(fromHex('0x1.00000000000004p-1022'), MIN)
        self.identical(fromHex('0x1.00000000000006p-1022'), MIN)
        self.identical(fromHex('0x1.00000000000008p-1022'), MIN)
        self.identical(fromHex('0x1.0000000000000ap-1022'), MIN + TINY)
        self.identical(fromHex('0x1.0000000000000cp-1022'), MIN + TINY)
        self.identical(fromHex('0x1.0000000000000ep-1022'), MIN + TINY)
        self.identical(fromHex('0x1.00000000000010p-1022'), MIN + TINY)
        self.identical(fromHex('0x1.00000000000012p-1022'), MIN + TINY)
        self.identical(fromHex('0x1.00000000000014p-1022'), MIN + TINY)
        self.identical(fromHex('0x1.00000000000016p-1022'), MIN + TINY)
        self.identical(fromHex('0x1.00000000000018p-1022'), MIN + 2 * TINY)
        self.identical(fromHex('0x0.fffffffffffff0p0'), 1.0 - EPS)
        self.identical(fromHex('0x0.fffffffffffff1p0'), 1.0 - EPS)
        self.identical(fromHex('0X0.fffffffffffff2p0'), 1.0 - EPS)
        self.identical(fromHex('0x0.fffffffffffff3p0'), 1.0 - EPS)
        self.identical(fromHex('0X0.fffffffffffff4p0'), 1.0 - EPS)
        self.identical(fromHex('0X0.fffffffffffff5p0'), 1.0 - EPS / 2)
        self.identical(fromHex('0X0.fffffffffffff6p0'), 1.0 - EPS / 2)
        self.identical(fromHex('0x0.fffffffffffff7p0'), 1.0 - EPS / 2)
        self.identical(fromHex('0x0.fffffffffffff8p0'), 1.0 - EPS / 2)
        self.identical(fromHex('0X0.fffffffffffff9p0'), 1.0 - EPS / 2)
        self.identical(fromHex('0X0.fffffffffffffap0'), 1.0 - EPS / 2)
        self.identical(fromHex('0x0.fffffffffffffbp0'), 1.0 - EPS / 2)
        self.identical(fromHex('0X0.fffffffffffffcp0'), 1.0)
        self.identical(fromHex('0x0.fffffffffffffdp0'), 1.0)
        self.identical(fromHex('0X0.fffffffffffffep0'), 1.0)
        self.identical(fromHex('0x0.ffffffffffffffp0'), 1.0)
        self.identical(fromHex('0X1.00000000000000p0'), 1.0)
        self.identical(fromHex('0X1.00000000000001p0'), 1.0)
        self.identical(fromHex('0x1.00000000000002p0'), 1.0)
        self.identical(fromHex('0X1.00000000000003p0'), 1.0)
        self.identical(fromHex('0x1.00000000000004p0'), 1.0)
        self.identical(fromHex('0X1.00000000000005p0'), 1.0)
        self.identical(fromHex('0X1.00000000000006p0'), 1.0)
        self.identical(fromHex('0X1.00000000000007p0'), 1.0)
        self.identical(fromHex('0x1.00000000000007ffffffffffffffffffffp0'), 1.0
            )
        self.identical(fromHex('0x1.00000000000008p0'), 1.0)
        self.identical(fromHex('0x1.00000000000008000000000000000001p0'), 1 +
            EPS)
        self.identical(fromHex('0X1.00000000000009p0'), 1.0 + EPS)
        self.identical(fromHex('0x1.0000000000000ap0'), 1.0 + EPS)
        self.identical(fromHex('0x1.0000000000000bp0'), 1.0 + EPS)
        self.identical(fromHex('0X1.0000000000000cp0'), 1.0 + EPS)
        self.identical(fromHex('0x1.0000000000000dp0'), 1.0 + EPS)
        self.identical(fromHex('0x1.0000000000000ep0'), 1.0 + EPS)
        self.identical(fromHex('0X1.0000000000000fp0'), 1.0 + EPS)
        self.identical(fromHex('0x1.00000000000010p0'), 1.0 + EPS)
        self.identical(fromHex('0X1.00000000000011p0'), 1.0 + EPS)
        self.identical(fromHex('0x1.00000000000012p0'), 1.0 + EPS)
        self.identical(fromHex('0X1.00000000000013p0'), 1.0 + EPS)
        self.identical(fromHex('0X1.00000000000014p0'), 1.0 + EPS)
        self.identical(fromHex('0x1.00000000000015p0'), 1.0 + EPS)
        self.identical(fromHex('0x1.00000000000016p0'), 1.0 + EPS)
        self.identical(fromHex('0X1.00000000000017p0'), 1.0 + EPS)
        self.identical(fromHex('0x1.00000000000017ffffffffffffffffffffp0'),
            1.0 + EPS)
        self.identical(fromHex('0x1.00000000000018p0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0X1.00000000000018000000000000000001p0'), 
            1.0 + 2 * EPS)
        self.identical(fromHex('0x1.00000000000019p0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0X1.0000000000001ap0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0X1.0000000000001bp0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0x1.0000000000001cp0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0x1.0000000000001dp0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0x1.0000000000001ep0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0X1.0000000000001fp0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0x1.00000000000020p0'), 1.0 + 2 * EPS)

    def test_roundtrip(self):

        def roundtrip(x):
            return fromHex(toHex(x))
        for x in [NAN, INF, self.MAX, self.MIN, self.MIN - self.TINY, self.
            TINY, 0.0]:
            self.identical(x, roundtrip(x))
            self.identical(-x, roundtrip(-x))
        import random
        for i in range(10000):
            e = random.randrange(-1200, 1200)
            m = random.random()
            s = random.choice([1.0, -1.0])
            try:
                x = s * ldexp(m, e)
            except OverflowError:
                pass
            else:
                self.identical(x, fromHex(toHex(x)))

    def test_subclass(self):


        class F(float):

            def __new__(cls, value):
                return float.__new__(cls, value + 1)
        f = F.fromhex((1.5).hex())
        self.assertIs(type(f), F)
        self.assertEqual(f, 2.5)


        class F2(float):

            def __init__(self, value):
                self.foo = 'bar'
        f = F2.fromhex((1.5).hex())
        self.assertIs(type(f), F2)
        self.assertEqual(f, 1.5)
        self.assertEqual(getattr(f, 'foo', 'none'), 'bar')


if __name__ == '__main__':
    unittest.main()

import fractions
import operator
import os
import random
import sys
import struct
import time
import unittest
from test import support
from test.test_grammar import VALID_UNDERSCORE_LITERALS, INVALID_UNDERSCORE_LITERALS
from math import isinf, isnan, copysign, ldexp
INF = float('inf')
NAN = float('nan')
have_getformat = hasattr(float, '__getformat__')
requires_getformat = unittest.skipUnless(have_getformat,
    'requires __getformat__')
requires_setformat = unittest.skipUnless(hasattr(float, '__setformat__'),
    'requires __setformat__')
test_dir = os.path.dirname(__file__) or os.curdir
format_testfile = os.path.join(test_dir, 'formatfloat_testcases.txt')


class FloatSubclass(float):
    pass


class OtherFloatSubclass(float):
    pass


class GeneralFloatCases(unittest.TestCase):

    def test_float(self):
        self.assertEqual(float(3.14), 3.14)
        self.assertEqual(float(314), 314.0)
        self.assertEqual(float('  3.14  '), 3.14)
        self.assertRaises(ValueError, float, '  0x3.1  ')
        self.assertRaises(ValueError, float, '  -0x3.p-1  ')
        self.assertRaises(ValueError, float, '  +0x3.p-1  ')
        self.assertRaises(ValueError, float, '++3.14')
        self.assertRaises(ValueError, float, '+-3.14')
        self.assertRaises(ValueError, float, '-+3.14')
        self.assertRaises(ValueError, float, '--3.14')
        self.assertRaises(ValueError, float, '.nan')
        self.assertRaises(ValueError, float, '+.inf')
        self.assertRaises(ValueError, float, '.')
        self.assertRaises(ValueError, float, '-.')
        self.assertRaises(TypeError, float, {})
        self.assertRaisesRegex(TypeError, "not 'dict'", float, {})
        self.assertRaises(UnicodeEncodeError, float, '\ud8f0')
        self.assertRaises(ValueError, float, '-1.7d29')
        self.assertRaises(ValueError, float, '3D-14')
        self.assertEqual(float('  ٣.١٤  '), 3.14)
        self.assertEqual(float('\u20033.14\u2002'), 3.14)
        float(b'.' + b'1' * 1000)
        float('.' + '1' * 1000)

    def test_underscores(self):
        for lit in VALID_UNDERSCORE_LITERALS:
            if not any(ch in lit for ch in 'jJxXoObB'):
                self.assertEqual(float(lit), eval(lit))
                self.assertEqual(float(lit), float(lit.replace('_', '')))
        for lit in INVALID_UNDERSCORE_LITERALS:
            if lit in ('0_7', '09_99'):
                continue
            if not any(ch in lit for ch in 'jJxXoObB'):
                self.assertRaises(ValueError, float, lit)
        self.assertRaises(ValueError, float, '_NaN')
        self.assertRaises(ValueError, float, 'Na_N')
        self.assertRaises(ValueError, float, 'IN_F')
        self.assertRaises(ValueError, float, '-_INF')
        self.assertRaises(ValueError, float, '-INF_')
        self.assertRaises(ValueError, float, b'0_.\xff9')

    def test_non_numeric_input_types(self):


        class CustomStr(str):
            pass


        class CustomBytes(bytes):
            pass


        class CustomByteArray(bytearray):
            pass
        factories = [bytes, bytearray, lambda b: CustomStr(b.decode()),
            CustomBytes, CustomByteArray, memoryview]
        try:
            from array import array
        except ImportError:
            pass
        else:
            factories.append(lambda b: array('B', b))
        for f in factories:
            x = f(b' 3.14  ')
            with self.subTest(type(x)):
                self.assertEqual(float(x), 3.14)
                with self.assertRaisesRegex(ValueError, 'could not convert'):
                    float(f(b'A' * 16))

    def test_float_memoryview(self):
        self.assertEqual(float(memoryview(b'12.3')[1:4]), 2.3)
        self.assertEqual(float(memoryview(b'12.3\x00')[1:4]), 2.3)
        self.assertEqual(float(memoryview(b'12.3 ')[1:4]), 2.3)
        self.assertEqual(float(memoryview(b'12.3A')[1:4]), 2.3)
        self.assertEqual(float(memoryview(b'12.34')[1:4]), 2.3)

    def test_error_message(self):

        def check(s):
            with self.assertRaises(ValueError, msg='float(%r)' % (s,)) as cm:
                float(s)
            self.assertEqual(str(cm.exception), 
                'could not convert string to float: %r' % (s,))
        check('½')
        check('123½')
        check('  123 456  ')
        check(b'  123 456  ')
        check('٣١٤!')
        check('123\x00')
        check('123\x00 245')
        check('123\x00245')
        check(b'123\x00')
        check(b'123\xa0')

    @support.run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE')
    def test_float_with_comma(self):
        import locale
        if not locale.localeconv()['decimal_point'] == ',':
            self.skipTest('decimal_point is not ","')
        self.assertEqual(float('  3.14  '), 3.14)
        self.assertEqual(float('+3.14  '), 3.14)
        self.assertEqual(float('-3.14  '), -3.14)
        self.assertEqual(float('.14  '), 0.14)
        self.assertEqual(float('3.  '), 3.0)
        self.assertEqual(float('3.e3  '), 3000.0)
        self.assertEqual(float('3.2e3  '), 3200.0)
        self.assertEqual(float('2.5e-1  '), 0.25)
        self.assertEqual(float('5e-1'), 0.5)
        self.assertRaises(ValueError, float, '  3,14  ')
        self.assertRaises(ValueError, float, '  +3,14  ')
        self.assertRaises(ValueError, float, '  -3,14  ')
        self.assertRaises(ValueError, float, '  0x3.1  ')
        self.assertRaises(ValueError, float, '  -0x3.p-1  ')
        self.assertRaises(ValueError, float, '  +0x3.p-1  ')
        self.assertEqual(float('  25.e-1  '), 2.5)
        self.assertAlmostEqual(float('  .25e-1  '), 0.025)

    def test_floatconversion(self):


        class Foo1(object):

            def __float__(self):
                return 42.0


        class Foo2(float):

            def __float__(self):
                return 42.0


        class Foo3(float):

            def __new__(cls, value=0.0):
                return float.__new__(cls, 2 * value)

            def __float__(self):
                return self


        class Foo4(float):

            def __float__(self):
                return 42


        class FooStr(str):

            def __float__(self):
                return float(str(self)) + 1
        self.assertEqual(float(Foo1()), 42.0)
        self.assertEqual(float(Foo2()), 42.0)
        with self.assertWarns(DeprecationWarning):
            self.assertEqual(float(Foo3(21)), 42.0)
        self.assertRaises(TypeError, float, Foo4(42))
        self.assertEqual(float(FooStr('8')), 9.0)


        class Foo5:

            def __float__(self):
                return ''
        self.assertRaises(TypeError, time.sleep, Foo5())


        class F:

            def __float__(self):
                return OtherFloatSubclass(42.0)
        with self.assertWarns(DeprecationWarning):
            self.assertEqual(float(F()), 42.0)
        with self.assertWarns(DeprecationWarning):
            self.assertIs(type(float(F())), float)
        with self.assertWarns(DeprecationWarning):
            self.assertEqual(FloatSubclass(F()), 42.0)
        with self.assertWarns(DeprecationWarning):
            self.assertIs(type(FloatSubclass(F())), FloatSubclass)

    def test_is_integer(self):
        self.assertFalse((1.1).is_integer())
        self.assertTrue((1.0).is_integer())
        self.assertFalse(float('nan').is_integer())
        self.assertFalse(float('inf').is_integer())

    def test_floatasratio(self):
        for f, ratio in [(0.875, (7, 8)), (-0.875, (-7, 8)), (0.0, (0, 1)),
            (11.5, (23, 2))]:
            self.assertEqual(f.as_integer_ratio(), ratio)
        for i in range(10000):
            f = random.random()
            f *= 10 ** random.randint(-100, 100)
            n, d = f.as_integer_ratio()
            self.assertEqual(float(n).__truediv__(d), f)
        R = fractions.Fraction
        self.assertEqual(R(0, 1), R(*float(0.0).as_integer_ratio()))
        self.assertEqual(R(5, 2), R(*float(2.5).as_integer_ratio()))
        self.assertEqual(R(1, 2), R(*float(0.5).as_integer_ratio()))
        self.assertEqual(R(4728779608739021, 2251799813685248), R(*float(
            2.1).as_integer_ratio()))
        self.assertEqual(R(-4728779608739021, 2251799813685248), R(*float(-
            2.1).as_integer_ratio()))
        self.assertEqual(R(-2100, 1), R(*float(-2100.0).as_integer_ratio()))
        self.assertRaises(OverflowError, float('inf').as_integer_ratio)
        self.assertRaises(OverflowError, float('-inf').as_integer_ratio)
        self.assertRaises(ValueError, float('nan').as_integer_ratio)

    def test_float_containment(self):
        floats = INF, -INF, 0.0, 1.0, NAN
        for f in floats:
            self.assertIn(f, [f])
            self.assertIn(f, (f,))
            self.assertIn(f, {f})
            self.assertIn(f, {f: None})
            self.assertEqual([f].count(f), 1, "[].count('%r') != 1" % f)
            self.assertIn(f, floats)
        for f in floats:
            self.assertTrue([f] == [f], '[%r] != [%r]' % (f, f))
            self.assertTrue((f,) == (f,), '(%r,) != (%r,)' % (f, f))
            self.assertTrue({f} == {f}, '{%r} != {%r}' % (f, f))
            self.assertTrue({f: None} == {f: None}, 
                '{%r : None} != {%r : None}' % (f, f))
            l, t, s, d = [f], (f,), {f}, {f: None}
            self.assertTrue(l == l, '[%r] not equal to itself' % f)
            self.assertTrue(t == t, '(%r,) not equal to itself' % f)
            self.assertTrue(s == s, '{%r} not equal to itself' % f)
            self.assertTrue(d == d, '{%r : None} not equal to itself' % f)

    def assertEqualAndEqualSign(self, a, b):
        self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b)))

    @support.requires_IEEE_754
    def test_float_mod(self):
        mod = operator.mod
        self.assertEqualAndEqualSign(mod(-1.0, 1.0), 0.0)
        self.assertEqualAndEqualSign(mod(-1e-100, 1.0), 1.0)
        self.assertEqualAndEqualSign(mod(-0.0, 1.0), 0.0)
        self.assertEqualAndEqualSign(mod(0.0, 1.0), 0.0)
        self.assertEqualAndEqualSign(mod(1e-100, 1.0), 1e-100)
        self.assertEqualAndEqualSign(mod(1.0, 1.0), 0.0)
        self.assertEqualAndEqualSign(mod(-1.0, -1.0), -0.0)
        self.assertEqualAndEqualSign(mod(-1e-100, -1.0), -1e-100)
        self.assertEqualAndEqualSign(mod(-0.0, -1.0), -0.0)
        self.assertEqualAndEqualSign(mod(0.0, -1.0), -0.0)
        self.assertEqualAndEqualSign(mod(1e-100, -1.0), -1.0)
        self.assertEqualAndEqualSign(mod(1.0, -1.0), -0.0)

    @support.requires_IEEE_754
    def test_float_pow(self):
        for pow_op in (pow, operator.pow):
            self.assertTrue(isnan(pow_op(-INF, NAN)))
            self.assertTrue(isnan(pow_op(-2.0, NAN)))
            self.assertTrue(isnan(pow_op(-1.0, NAN)))
            self.assertTrue(isnan(pow_op(-0.5, NAN)))
            self.assertTrue(isnan(pow_op(-0.0, NAN)))
            self.assertTrue(isnan(pow_op(0.0, NAN)))
            self.assertTrue(isnan(pow_op(0.5, NAN)))
            self.assertTrue(isnan(pow_op(2.0, NAN)))
            self.assertTrue(isnan(pow_op(INF, NAN)))
            self.assertTrue(isnan(pow_op(NAN, NAN)))
            self.assertTrue(isnan(pow_op(NAN, -INF)))
            self.assertTrue(isnan(pow_op(NAN, -2.0)))
            self.assertTrue(isnan(pow_op(NAN, -1.0)))
            self.assertTrue(isnan(pow_op(NAN, -0.5)))
            self.assertTrue(isnan(pow_op(NAN, 0.5)))
            self.assertTrue(isnan(pow_op(NAN, 1.0)))
            self.assertTrue(isnan(pow_op(NAN, 2.0)))
            self.assertTrue(isnan(pow_op(NAN, INF)))
            self.assertRaises(ZeroDivisionError, pow_op, -0.0, -1.0)
            self.assertRaises(ZeroDivisionError, pow_op, 0.0, -1.0)
            self.assertRaises(ZeroDivisionError, pow_op, -0.0, -2.0)
            self.assertRaises(ZeroDivisionError, pow_op, -0.0, -0.5)
            self.assertRaises(ZeroDivisionError, pow_op, 0.0, -2.0)
            self.assertRaises(ZeroDivisionError, pow_op, 0.0, -0.5)
            self.assertEqualAndEqualSign(pow_op(-0.0, 1.0), -0.0)
            self.assertEqualAndEqualSign(pow_op(0.0, 1.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(-0.0, 0.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(-0.0, 2.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.0, 0.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.0, 2.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -INF), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, INF), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -INF), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -2.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -1.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -0.5), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 0.5), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 1.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 2.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, INF), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, NAN), 1.0)
            self.assertEqualAndEqualSign(pow_op(-INF, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-0.5, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-0.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(0.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(0.5, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(INF, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(NAN, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-INF, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-0.5, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-0.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(0.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(0.5, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(INF, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(NAN, -0.0), 1.0)
            self.assertEqual(type(pow_op(-2.0, -0.5)), complex)
            self.assertEqual(type(pow_op(-2.0, 0.5)), complex)
            self.assertEqual(type(pow_op(-1.0, -0.5)), complex)
            self.assertEqual(type(pow_op(-1.0, 0.5)), complex)
            self.assertEqual(type(pow_op(-0.5, -0.5)), complex)
            self.assertEqual(type(pow_op(-0.5, 0.5)), complex)
            self.assertEqualAndEqualSign(pow_op(-0.5, -INF), INF)
            self.assertEqualAndEqualSign(pow_op(-0.0, -INF), INF)
            self.assertEqualAndEqualSign(pow_op(0.0, -INF), INF)
            self.assertEqualAndEqualSign(pow_op(0.5, -INF), INF)
            self.assertEqualAndEqualSign(pow_op(-INF, -INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, -INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(INF, -INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(-0.5, INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(-0.0, INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.0, INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.5, INF), 0.0)
            self.assertEqualAndEqualSign(pow_op(-INF, INF), INF)
            self.assertEqualAndEqualSign(pow_op(-2.0, INF), INF)
            self.assertEqualAndEqualSign(pow_op(2.0, INF), INF)
            self.assertEqualAndEqualSign(pow_op(INF, INF), INF)
            self.assertEqualAndEqualSign(pow_op(-INF, -1.0), -0.0)
            self.assertEqualAndEqualSign(pow_op(-INF, -0.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(-INF, -2.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(-INF, 1.0), -INF)
            self.assertEqualAndEqualSign(pow_op(-INF, 0.5), INF)
            self.assertEqualAndEqualSign(pow_op(-INF, 2.0), INF)
            self.assertEqualAndEqualSign(pow_op(INF, 0.5), INF)
            self.assertEqualAndEqualSign(pow_op(INF, 1.0), INF)
            self.assertEqualAndEqualSign(pow_op(INF, 2.0), INF)
            self.assertEqualAndEqualSign(pow_op(INF, -2.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(INF, -1.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(INF, -0.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, -2.0), 0.25)
            self.assertEqualAndEqualSign(pow_op(-2.0, -1.0), -0.5)
            self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, 1.0), -2.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, 2.0), 4.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -2.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -1.0), -1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, 1.0), -1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, 2.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -2.0), 0.25)
            self.assertEqualAndEqualSign(pow_op(2.0, -1.0), 0.5)
            self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
            self.assertEqualAndEqualSign(pow_op(2.0, 1.0), 2.0)
            self.assertEqualAndEqualSign(pow_op(2.0, 2.0), 4.0)
            self.assertEqualAndEqualSign(pow_op(1.0, -1e+100), 1.0)
            self.assertEqualAndEqualSign(pow_op(1.0, 1e+100), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, -1e+100), 1.0)
            self.assertEqualAndEqualSign(pow_op(-1.0, 1e+100), 1.0)
            self.assertEqualAndEqualSign(pow_op(-2.0, -2000.0), 0.0)
            self.assertEqual(type(pow_op(-2.0, -2000.5)), complex)
            self.assertEqualAndEqualSign(pow_op(-2.0, -2001.0), -0.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -2000.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -2000.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(2.0, -2001.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(-0.5, 2000.0), 0.0)
            self.assertEqual(type(pow_op(-0.5, 2000.5)), complex)
            self.assertEqualAndEqualSign(pow_op(-0.5, 2001.0), -0.0)
            self.assertEqualAndEqualSign(pow_op(0.5, 2000.0), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.5, 2000.5), 0.0)
            self.assertEqualAndEqualSign(pow_op(0.5, 2001.0), 0.0)


@requires_setformat
class FormatFunctionsTestCase(unittest.TestCase):

    def setUp(self):
        self.save_formats = {'double': float.__getformat__('double'),
            'float': float.__getformat__('float')}

    def tearDown(self):
        float.__setformat__('double', self.save_formats['double'])
        float.__setformat__('float', self.save_formats['float'])

    def test_getformat(self):
        self.assertIn(float.__getformat__('double'), ['unknown',
            'IEEE, big-endian', 'IEEE, little-endian'])
        self.assertIn(float.__getformat__('float'), ['unknown',
            'IEEE, big-endian', 'IEEE, little-endian'])
        self.assertRaises(ValueError, float.__getformat__, 'chicken')
        self.assertRaises(TypeError, float.__getformat__, 1)

    def test_setformat(self):
        for t in ('double', 'float'):
            float.__setformat__(t, 'unknown')
            if self.save_formats[t] == 'IEEE, big-endian':
                self.assertRaises(ValueError, float.__setformat__, t,
                    'IEEE, little-endian')
            elif self.save_formats[t] == 'IEEE, little-endian':
                self.assertRaises(ValueError, float.__setformat__, t,
                    'IEEE, big-endian')
            else:
                self.assertRaises(ValueError, float.__setformat__, t,
                    'IEEE, big-endian')
                self.assertRaises(ValueError, float.__setformat__, t,
                    'IEEE, little-endian')
            self.assertRaises(ValueError, float.__setformat__, t, 'chicken')
        self.assertRaises(ValueError, float.__setformat__, 'chicken', 'unknown'
            )


BE_DOUBLE_INF = b'\x7f\xf0\x00\x00\x00\x00\x00\x00'
LE_DOUBLE_INF = bytes(reversed(BE_DOUBLE_INF))
BE_DOUBLE_NAN = b'\x7f\xf8\x00\x00\x00\x00\x00\x00'
LE_DOUBLE_NAN = bytes(reversed(BE_DOUBLE_NAN))
BE_FLOAT_INF = b'\x7f\x80\x00\x00'
LE_FLOAT_INF = bytes(reversed(BE_FLOAT_INF))
BE_FLOAT_NAN = b'\x7f\xc0\x00\x00'
LE_FLOAT_NAN = bytes(reversed(BE_FLOAT_NAN))


@requires_setformat
class UnknownFormatTestCase(unittest.TestCase):

    def setUp(self):
        self.save_formats = {'double': float.__getformat__('double'),
            'float': float.__getformat__('float')}
        float.__setformat__('double', 'unknown')
        float.__setformat__('float', 'unknown')

    def tearDown(self):
        float.__setformat__('double', self.save_formats['double'])
        float.__setformat__('float', self.save_formats['float'])

    def test_double_specials_dont_unpack(self):
        for fmt, data in [('>d', BE_DOUBLE_INF), ('>d', BE_DOUBLE_NAN), (
            '<d', LE_DOUBLE_INF), ('<d', LE_DOUBLE_NAN)]:
            self.assertRaises(ValueError, struct.unpack, fmt, data)

    def test_float_specials_dont_unpack(self):
        for fmt, data in [('>f', BE_FLOAT_INF), ('>f', BE_FLOAT_NAN), ('<f',
            LE_FLOAT_INF), ('<f', LE_FLOAT_NAN)]:
            self.assertRaises(ValueError, struct.unpack, fmt, data)


class IEEEFormatTestCase(unittest.TestCase):

    @support.requires_IEEE_754
    def test_double_specials_do_unpack(self):
        for fmt, data in [('>d', BE_DOUBLE_INF), ('>d', BE_DOUBLE_NAN), (
            '<d', LE_DOUBLE_INF), ('<d', LE_DOUBLE_NAN)]:
            struct.unpack(fmt, data)

    @support.requires_IEEE_754
    def test_float_specials_do_unpack(self):
        for fmt, data in [('>f', BE_FLOAT_INF), ('>f', BE_FLOAT_NAN), ('<f',
            LE_FLOAT_INF), ('<f', LE_FLOAT_NAN)]:
            struct.unpack(fmt, data)


class FormatTestCase(unittest.TestCase):

    def test_format(self):
        self.assertEqual(format(0.0, 'f'), '0.000000')
        self.assertEqual(format(0.0, ''), '0.0')
        self.assertEqual(format(0.01, ''), '0.01')
        self.assertEqual(format(0.01, 'g'), '0.01')
        x = 100 / 7.0
        self.assertEqual(format(x, ''), str(x))
        self.assertEqual(format(x, '-'), str(x))
        self.assertEqual(format(x, '>'), str(x))
        self.assertEqual(format(x, '2'), str(x))
        self.assertEqual(format(1.0, 'f'), '1.000000')
        self.assertEqual(format(-1.0, 'f'), '-1.000000')
        self.assertEqual(format(1.0, ' f'), ' 1.000000')
        self.assertEqual(format(-1.0, ' f'), '-1.000000')
        self.assertEqual(format(1.0, '+f'), '+1.000000')
        self.assertEqual(format(-1.0, '+f'), '-1.000000')
        self.assertEqual(format(-1.0, '%'), '-100.000000%')
        self.assertRaises(ValueError, format, 3.0, 's')
        for format_spec in ([chr(x) for x in range(ord('a'), ord('z') + 1)] +
            [chr(x) for x in range(ord('A'), ord('Z') + 1)]):
            if not format_spec in 'eEfFgGn%':
                self.assertRaises(ValueError, format, 0.0, format_spec)
                self.assertRaises(ValueError, format, 1.0, format_spec)
                self.assertRaises(ValueError, format, -1.0, format_spec)
                self.assertRaises(ValueError, format, 1e+100, format_spec)
                self.assertRaises(ValueError, format, -1e+100, format_spec)
                self.assertRaises(ValueError, format, 1e-100, format_spec)
                self.assertRaises(ValueError, format, -1e-100, format_spec)
        self.assertEqual(format(NAN, 'f'), 'nan')
        self.assertEqual(format(NAN, 'F'), 'NAN')
        self.assertEqual(format(INF, 'f'), 'inf')
        self.assertEqual(format(INF, 'F'), 'INF')

    @support.requires_IEEE_754
    def test_format_testfile(self):
        with open(format_testfile) as testfile:
            for line in testfile:
                if line.startswith('--'):
                    continue
                line = line.strip()
                if not line:
                    continue
                lhs, rhs = map(str.strip, line.split('->'))
                fmt, arg = lhs.split()
                self.assertEqual(fmt % float(arg), rhs)
                self.assertEqual(fmt % -float(arg), '-' + rhs)

    def test_issue5864(self):
        self.assertEqual(format(123.456, '.4'), '123.5')
        self.assertEqual(format(1234.56, '.4'), '1.235e+03')
        self.assertEqual(format(12345.6, '.4'), '1.235e+04')


class ReprTestCase(unittest.TestCase):

    def test_repr(self):
        floats_file = open(os.path.join(os.path.split(__file__)[0],
            'floating_points.txt'))
        for line in floats_file:
            line = line.strip()
            if not line or line.startswith('#'):
                continue
            v = eval(line)
            self.assertEqual(v, eval(repr(v)))
        floats_file.close()

    @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
        'applies only when using short float repr style')
    def test_short_repr(self):
        test_strings = ['0.0', '1.0', '0.01', '0.02', '0.03', '0.04',
            '0.05', '1.23456789', '10.0', '100.0', '1000000000000000.0',
            '9999999999999990.0', '1e+16', '1e+17', '0.001', '0.001001',
            '0.00010000000000001', '0.0001', '9.999999999999e-05', '1e-05',
            '8.72293771110361e+25', '7.47005307342313e+26',
            '2.86438000439698e+28', '8.89142905246179e+28',
            '3.08578087079232e+35']
        for s in test_strings:
            negs = '-' + s
            self.assertEqual(s, repr(float(s)))
            self.assertEqual(negs, repr(float(negs)))
            self.assertEqual(repr(float(s)), str(float(s)))
            self.assertEqual(repr(float(negs)), str(float(negs)))


@support.requires_IEEE_754
class RoundTestCase(unittest.TestCase):

    def test_inf_nan(self):
        self.assertRaises(OverflowError, round, INF)
        self.assertRaises(OverflowError, round, -INF)
        self.assertRaises(ValueError, round, NAN)
        self.assertRaises(TypeError, round, INF, 0.0)
        self.assertRaises(TypeError, round, -INF, 1.0)
        self.assertRaises(TypeError, round, NAN, "ceci n'est pas un integer")
        self.assertRaises(TypeError, round, -0.0, 1j)

    def test_large_n(self):
        for n in [324, 325, 400, 2 ** 31 - 1, 2 ** 31, 2 ** 32, 2 ** 100]:
            self.assertEqual(round(123.456, n), 123.456)
            self.assertEqual(round(-123.456, n), -123.456)
            self.assertEqual(round(1e+300, n), 1e+300)
            self.assertEqual(round(1e-320, n), 1e-320)
        self.assertEqual(round(1e+150, 300), 1e+150)
        self.assertEqual(round(1e+300, 307), 1e+300)
        self.assertEqual(round(-3.1415, 308), -3.1415)
        self.assertEqual(round(1e+150, 309), 1e+150)
        self.assertEqual(round(1.4e-315, 315), 1e-315)

    def test_small_n(self):
        for n in [-308, -309, -400, 1 - 2 ** 31, -2 ** 31, -2 ** 31 - 1, -2 **
            100]:
            self.assertEqual(round(123.456, n), 0.0)
            self.assertEqual(round(-123.456, n), -0.0)
            self.assertEqual(round(1e+300, n), 0.0)
            self.assertEqual(round(1e-320, n), 0.0)

    def test_overflow(self):
        self.assertRaises(OverflowError, round, 1.6e+308, -308)
        self.assertRaises(OverflowError, round, -1.7e+308, -308)

    @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
        'applies only when using short float repr style')
    def test_previous_round_bugs(self):
        self.assertEqual(round(562949953421312.5, 1), 562949953421312.5)
        self.assertEqual(round(56294995342131.5, 3), 56294995342131.5)
        self.assertEqual(round(25.0, -1), 20.0)
        self.assertEqual(round(35.0, -1), 40.0)
        self.assertEqual(round(45.0, -1), 40.0)
        self.assertEqual(round(55.0, -1), 60.0)
        self.assertEqual(round(65.0, -1), 60.0)
        self.assertEqual(round(75.0, -1), 80.0)
        self.assertEqual(round(85.0, -1), 80.0)
        self.assertEqual(round(95.0, -1), 100.0)

    @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
        'applies only when using short float repr style')
    def test_matches_float_format(self):
        for i in range(500):
            x = i / 1000.0
            self.assertEqual(float(format(x, '.0f')), round(x, 0))
            self.assertEqual(float(format(x, '.1f')), round(x, 1))
            self.assertEqual(float(format(x, '.2f')), round(x, 2))
            self.assertEqual(float(format(x, '.3f')), round(x, 3))
        for i in range(5, 5000, 10):
            x = i / 1000.0
            self.assertEqual(float(format(x, '.0f')), round(x, 0))
            self.assertEqual(float(format(x, '.1f')), round(x, 1))
            self.assertEqual(float(format(x, '.2f')), round(x, 2))
            self.assertEqual(float(format(x, '.3f')), round(x, 3))
        for i in range(500):
            x = random.random()
            self.assertEqual(float(format(x, '.0f')), round(x, 0))
            self.assertEqual(float(format(x, '.1f')), round(x, 1))
            self.assertEqual(float(format(x, '.2f')), round(x, 2))
            self.assertEqual(float(format(x, '.3f')), round(x, 3))

    def test_format_specials(self):

        def test(fmt, value, expected):
            self.assertEqual(fmt % value, expected, fmt)
            fmt = fmt[1:]
            self.assertEqual(format(value, fmt), expected, fmt)
        for fmt in ['%e', '%f', '%g', '%.0e', '%.6f', '%.20g', '%#e', '%#f',
            '%#g', '%#.20e', '%#.15f', '%#.3g']:
            pfmt = '%+' + fmt[1:]
            sfmt = '% ' + fmt[1:]
            test(fmt, INF, 'inf')
            test(fmt, -INF, '-inf')
            test(fmt, NAN, 'nan')
            test(fmt, -NAN, 'nan')
            test(pfmt, INF, '+inf')
            test(pfmt, -INF, '-inf')
            test(pfmt, NAN, '+nan')
            test(pfmt, -NAN, '+nan')
            test(sfmt, INF, ' inf')
            test(sfmt, -INF, '-inf')
            test(sfmt, NAN, ' nan')
            test(sfmt, -NAN, ' nan')

    def test_None_ndigits(self):
        for x in (round(1.23), round(1.23, None), round(1.23, ndigits=None)):
            self.assertEqual(x, 1)
            self.assertIsInstance(x, int)
        for x in (round(1.78), round(1.78, None), round(1.78, ndigits=None)):
            self.assertEqual(x, 2)
            self.assertIsInstance(x, int)


class InfNanTest(unittest.TestCase):

    def test_inf_from_str(self):
        self.assertTrue(isinf(float('inf')))
        self.assertTrue(isinf(float('+inf')))
        self.assertTrue(isinf(float('-inf')))
        self.assertTrue(isinf(float('infinity')))
        self.assertTrue(isinf(float('+infinity')))
        self.assertTrue(isinf(float('-infinity')))
        self.assertEqual(repr(float('inf')), 'inf')
        self.assertEqual(repr(float('+inf')), 'inf')
        self.assertEqual(repr(float('-inf')), '-inf')
        self.assertEqual(repr(float('infinity')), 'inf')
        self.assertEqual(repr(float('+infinity')), 'inf')
        self.assertEqual(repr(float('-infinity')), '-inf')
        self.assertEqual(repr(float('INF')), 'inf')
        self.assertEqual(repr(float('+Inf')), 'inf')
        self.assertEqual(repr(float('-iNF')), '-inf')
        self.assertEqual(repr(float('Infinity')), 'inf')
        self.assertEqual(repr(float('+iNfInItY')), 'inf')
        self.assertEqual(repr(float('-INFINITY')), '-inf')
        self.assertEqual(str(float('inf')), 'inf')
        self.assertEqual(str(float('+inf')), 'inf')
        self.assertEqual(str(float('-inf')), '-inf')
        self.assertEqual(str(float('infinity')), 'inf')
        self.assertEqual(str(float('+infinity')), 'inf')
        self.assertEqual(str(float('-infinity')), '-inf')
        self.assertRaises(ValueError, float, 'info')
        self.assertRaises(ValueError, float, '+info')
        self.assertRaises(ValueError, float, '-info')
        self.assertRaises(ValueError, float, 'in')
        self.assertRaises(ValueError, float, '+in')
        self.assertRaises(ValueError, float, '-in')
        self.assertRaises(ValueError, float, 'infinit')
        self.assertRaises(ValueError, float, '+Infin')
        self.assertRaises(ValueError, float, '-INFI')
        self.assertRaises(ValueError, float, 'infinitys')
        self.assertRaises(ValueError, float, '++Inf')
        self.assertRaises(ValueError, float, '-+inf')
        self.assertRaises(ValueError, float, '+-infinity')
        self.assertRaises(ValueError, float, '--Infinity')

    def test_inf_as_str(self):
        self.assertEqual(repr(1e+300 * 1e+300), 'inf')
        self.assertEqual(repr(-1e+300 * 1e+300), '-inf')
        self.assertEqual(str(1e+300 * 1e+300), 'inf')
        self.assertEqual(str(-1e+300 * 1e+300), '-inf')

    def test_nan_from_str(self):
        self.assertTrue(isnan(float('nan')))
        self.assertTrue(isnan(float('+nan')))
        self.assertTrue(isnan(float('-nan')))
        self.assertEqual(repr(float('nan')), 'nan')
        self.assertEqual(repr(float('+nan')), 'nan')
        self.assertEqual(repr(float('-nan')), 'nan')
        self.assertEqual(repr(float('NAN')), 'nan')
        self.assertEqual(repr(float('+NAn')), 'nan')
        self.assertEqual(repr(float('-NaN')), 'nan')
        self.assertEqual(str(float('nan')), 'nan')
        self.assertEqual(str(float('+nan')), 'nan')
        self.assertEqual(str(float('-nan')), 'nan')
        self.assertRaises(ValueError, float, 'nana')
        self.assertRaises(ValueError, float, '+nana')
        self.assertRaises(ValueError, float, '-nana')
        self.assertRaises(ValueError, float, 'na')
        self.assertRaises(ValueError, float, '+na')
        self.assertRaises(ValueError, float, '-na')
        self.assertRaises(ValueError, float, '++nan')
        self.assertRaises(ValueError, float, '-+NAN')
        self.assertRaises(ValueError, float, '+-NaN')
        self.assertRaises(ValueError, float, '--nAn')

    def test_nan_as_str(self):
        self.assertEqual(repr(1e+300 * 1e+300 * 0), 'nan')
        self.assertEqual(repr(-1e+300 * 1e+300 * 0), 'nan')
        self.assertEqual(str(1e+300 * 1e+300 * 0), 'nan')
        self.assertEqual(str(-1e+300 * 1e+300 * 0), 'nan')

    def test_inf_signs(self):
        self.assertEqual(copysign(1.0, float('inf')), 1.0)
        self.assertEqual(copysign(1.0, float('-inf')), -1.0)

    @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
        'applies only when using short float repr style')
    def test_nan_signs(self):
        self.assertEqual(copysign(1.0, float('nan')), 1.0)
        self.assertEqual(copysign(1.0, float('-nan')), -1.0)


fromHex = float.fromhex
toHex = float.hex


class HexFloatTestCase(unittest.TestCase):
    MAX = fromHex('0x.fffffffffffff8p+1024')
    MIN = fromHex('0x1p-1022')
    TINY = fromHex('0x0.0000000000001p-1022')
    EPS = fromHex('0x0.0000000000001p0')

    def identical(self, x, y):
        if isnan(x) or isnan(y):
            if isnan(x) == isnan(y):
                return
        elif x == y and (x != 0.0 or copysign(1.0, x) == copysign(1.0, y)):
            return
        self.fail('%r not identical to %r' % (x, y))

    def test_ends(self):
        self.identical(self.MIN, ldexp(1.0, -1022))
        self.identical(self.TINY, ldexp(1.0, -1074))
        self.identical(self.EPS, ldexp(1.0, -52))
        self.identical(self.MAX, 2.0 * (ldexp(1.0, 1023) - ldexp(1.0, 970)))

    def test_invalid_inputs(self):
        invalid_inputs = ['infi', '-Infinit', '++inf', '-+Inf', '--nan',
            '+-NaN', 'snan', 'NaNs', 'nna', 'an', 'nf', 'nfinity', 'inity',
            'iinity', '0xnan', '', ' ', 'x1.0p0', '0xX1.0p0', '+ 0x1.0p0',
            '- 0x1.0p0', '0 x1.0p0', '0x 1.0p0', '0x1 2.0p0', '+0x1 .0p0',
            '0x1. 0p0', '-0x1.0 1p0', '-0x1.0 p0', '+0x1.0p +0',
            '0x1.0p -0', '0x1.0p 0', '+0x1.0p+ 0', '-0x1.0p- 0',
            '++0x1.0p-0', '--0x1.0p0', '+-0x1.0p+0', '-+0x1.0p0',
            '0x1.0p++0', '+0x1.0p+-0', '-0x1.0p-+0', '0x1.0p--0',
            '0x1.0.p0', '0x.p0', '0x1,p0', '0x1pa', '0x1p０', '０x1p0',
            '0x１p0', '0x1.０p0', '0x1p0 \n 0x2p0', '0x1p0\x00 0x1p0']
        for x in invalid_inputs:
            try:
                result = fromHex(x)
            except ValueError:
                pass
            else:
                self.fail(
                    'Expected float.fromhex(%r) to raise ValueError; got %r instead'
                     % (x, result))

    def test_whitespace(self):
        value_pairs = [('inf', INF), ('-Infinity', -INF), ('nan', NAN), (
            '1.0', 1.0), ('-0x.2', -0.125), ('-0.0', -0.0)]
        whitespace = ['', ' ', '\t', '\n', '\n \t', '\x0c', '\x0b', '\r']
        for inp, expected in value_pairs:
            for lead in whitespace:
                for trail in whitespace:
                    got = fromHex(lead + inp + trail)
                    self.identical(got, expected)

    def test_from_hex(self):
        MIN = self.MIN
        MAX = self.MAX
        TINY = self.TINY
        EPS = self.EPS
        self.identical(fromHex('inf'), INF)
        self.identical(fromHex('+Inf'), INF)
        self.identical(fromHex('-INF'), -INF)
        self.identical(fromHex('iNf'), INF)
        self.identical(fromHex('Infinity'), INF)
        self.identical(fromHex('+INFINITY'), INF)
        self.identical(fromHex('-infinity'), -INF)
        self.identical(fromHex('-iNFiNitY'), -INF)
        self.identical(fromHex('nan'), NAN)
        self.identical(fromHex('+NaN'), NAN)
        self.identical(fromHex('-NaN'), NAN)
        self.identical(fromHex('-nAN'), NAN)
        self.identical(fromHex('1'), 1.0)
        self.identical(fromHex('+1'), 1.0)
        self.identical(fromHex('1.'), 1.0)
        self.identical(fromHex('1.0'), 1.0)
        self.identical(fromHex('1.0p0'), 1.0)
        self.identical(fromHex('01'), 1.0)
        self.identical(fromHex('01.'), 1.0)
        self.identical(fromHex('0x1'), 1.0)
        self.identical(fromHex('0x1.'), 1.0)
        self.identical(fromHex('0x1.0'), 1.0)
        self.identical(fromHex('+0x1.0'), 1.0)
        self.identical(fromHex('0x1p0'), 1.0)
        self.identical(fromHex('0X1p0'), 1.0)
        self.identical(fromHex('0X1P0'), 1.0)
        self.identical(fromHex('0x1P0'), 1.0)
        self.identical(fromHex('0x1.p0'), 1.0)
        self.identical(fromHex('0x1.0p0'), 1.0)
        self.identical(fromHex('0x.1p4'), 1.0)
        self.identical(fromHex('0x.1p04'), 1.0)
        self.identical(fromHex('0x.1p004'), 1.0)
        self.identical(fromHex('0x1p+0'), 1.0)
        self.identical(fromHex('0x1P-0'), 1.0)
        self.identical(fromHex('+0x1p0'), 1.0)
        self.identical(fromHex('0x01p0'), 1.0)
        self.identical(fromHex('0x1p00'), 1.0)
        self.identical(fromHex(' 0x1p0 '), 1.0)
        self.identical(fromHex('\n 0x1p0'), 1.0)
        self.identical(fromHex('0x1p0 \t'), 1.0)
        self.identical(fromHex('0xap0'), 10.0)
        self.identical(fromHex('0xAp0'), 10.0)
        self.identical(fromHex('0xaP0'), 10.0)
        self.identical(fromHex('0xAP0'), 10.0)
        self.identical(fromHex('0xbep0'), 190.0)
        self.identical(fromHex('0xBep0'), 190.0)
        self.identical(fromHex('0xbEp0'), 190.0)
        self.identical(fromHex('0XBE0P-4'), 190.0)
        self.identical(fromHex('0xBEp0'), 190.0)
        self.identical(fromHex('0xB.Ep4'), 190.0)
        self.identical(fromHex('0x.BEp8'), 190.0)
        self.identical(fromHex('0x.0BEp12'), 190.0)
        pi = fromHex('0x1.921fb54442d18p1')
        self.identical(fromHex('0x.006487ed5110b46p11'), pi)
        self.identical(fromHex('0x.00c90fdaa22168cp10'), pi)
        self.identical(fromHex('0x.01921fb54442d18p9'), pi)
        self.identical(fromHex('0x.03243f6a8885a3p8'), pi)
        self.identical(fromHex('0x.06487ed5110b46p7'), pi)
        self.identical(fromHex('0x.0c90fdaa22168cp6'), pi)
        self.identical(fromHex('0x.1921fb54442d18p5'), pi)
        self.identical(fromHex('0x.3243f6a8885a3p4'), pi)
        self.identical(fromHex('0x.6487ed5110b46p3'), pi)
        self.identical(fromHex('0x.c90fdaa22168cp2'), pi)
        self.identical(fromHex('0x1.921fb54442d18p1'), pi)
        self.identical(fromHex('0x3.243f6a8885a3p0'), pi)
        self.identical(fromHex('0x6.487ed5110b46p-1'), pi)
        self.identical(fromHex('0xc.90fdaa22168cp-2'), pi)
        self.identical(fromHex('0x19.21fb54442d18p-3'), pi)
        self.identical(fromHex('0x32.43f6a8885a3p-4'), pi)
        self.identical(fromHex('0x64.87ed5110b46p-5'), pi)
        self.identical(fromHex('0xc9.0fdaa22168cp-6'), pi)
        self.identical(fromHex('0x192.1fb54442d18p-7'), pi)
        self.identical(fromHex('0x324.3f6a8885a3p-8'), pi)
        self.identical(fromHex('0x648.7ed5110b46p-9'), pi)
        self.identical(fromHex('0xc90.fdaa22168cp-10'), pi)
        self.identical(fromHex('0x1921.fb54442d18p-11'), pi)
        self.identical(fromHex('0x1921fb54442d1.8p-47'), pi)
        self.identical(fromHex('0x3243f6a8885a3p-48'), pi)
        self.identical(fromHex('0x6487ed5110b46p-49'), pi)
        self.identical(fromHex('0xc90fdaa22168cp-50'), pi)
        self.identical(fromHex('0x1921fb54442d18p-51'), pi)
        self.identical(fromHex('0x3243f6a8885a30p-52'), pi)
        self.identical(fromHex('0x6487ed5110b460p-53'), pi)
        self.identical(fromHex('0xc90fdaa22168c0p-54'), pi)
        self.identical(fromHex('0x1921fb54442d180p-55'), pi)
        self.assertRaises(OverflowError, fromHex, '-0x1p1024')
        self.assertRaises(OverflowError, fromHex, '0x1p+1025')
        self.assertRaises(OverflowError, fromHex, '+0X1p1030')
        self.assertRaises(OverflowError, fromHex, '-0x1p+1100')
        self.assertRaises(OverflowError, fromHex, '0X1p123456789123456789')
        self.assertRaises(OverflowError, fromHex, '+0X.8p+1025')
        self.assertRaises(OverflowError, fromHex, '+0x0.8p1025')
        self.assertRaises(OverflowError, fromHex, '-0x0.4p1026')
        self.assertRaises(OverflowError, fromHex, '0X2p+1023')
        self.assertRaises(OverflowError, fromHex, '0x2.p1023')
        self.assertRaises(OverflowError, fromHex, '-0x2.0p+1023')
        self.assertRaises(OverflowError, fromHex, '+0X4p+1022')
        self.assertRaises(OverflowError, fromHex, '0x1.ffffffffffffffp+1023')
        self.assertRaises(OverflowError, fromHex, '-0X1.fffffffffffff9p1023')
        self.assertRaises(OverflowError, fromHex, '0X1.fffffffffffff8p1023')
        self.assertRaises(OverflowError, fromHex, '+0x3.fffffffffffffp1022')
        self.assertRaises(OverflowError, fromHex, '0x3fffffffffffffp+970')
        self.assertRaises(OverflowError, fromHex, '0x10000000000000000p960')
        self.assertRaises(OverflowError, fromHex, '-0Xffffffffffffffffp960')
        self.identical(fromHex('+0x1.fffffffffffffp+1023'), MAX)
        self.identical(fromHex('-0X1.fffffffffffff7p1023'), -MAX)
        self.identical(fromHex('0X1.fffffffffffff7fffffffffffffp1023'), MAX)
        self.identical(fromHex('0x0p0'), 0.0)
        self.identical(fromHex('0x0p1000'), 0.0)
        self.identical(fromHex('-0x0p1023'), -0.0)
        self.identical(fromHex('0X0p1024'), 0.0)
        self.identical(fromHex('-0x0p1025'), -0.0)
        self.identical(fromHex('0X0p2000'), 0.0)
        self.identical(fromHex('0x0p123456789123456789'), 0.0)
        self.identical(fromHex('-0X0p-0'), -0.0)
        self.identical(fromHex('-0X0p-1000'), -0.0)
        self.identical(fromHex('0x0p-1023'), 0.0)
        self.identical(fromHex('-0X0p-1024'), -0.0)
        self.identical(fromHex('-0x0p-1025'), -0.0)
        self.identical(fromHex('-0x0p-1072'), -0.0)
        self.identical(fromHex('0X0p-1073'), 0.0)
        self.identical(fromHex('-0x0p-1074'), -0.0)
        self.identical(fromHex('0x0p-1075'), 0.0)
        self.identical(fromHex('0X0p-1076'), 0.0)
        self.identical(fromHex('-0X0p-2000'), -0.0)
        self.identical(fromHex('-0x0p-123456789123456789'), -0.0)
        self.identical(fromHex('0X1p-1075'), 0.0)
        self.identical(fromHex('-0X1p-1075'), -0.0)
        self.identical(fromHex('-0x1p-123456789123456789'), -0.0)
        self.identical(fromHex('0x1.00000000000000001p-1075'), TINY)
        self.identical(fromHex('-0x1.1p-1075'), -TINY)
        self.identical(fromHex('0x1.fffffffffffffffffp-1075'), TINY)
        self.identical(fromHex('0x1p-1076'), 0.0)
        self.identical(fromHex('0X2p-1076'), 0.0)
        self.identical(fromHex('0X3p-1076'), TINY)
        self.identical(fromHex('0x4p-1076'), TINY)
        self.identical(fromHex('0X5p-1076'), TINY)
        self.identical(fromHex('0X6p-1076'), 2 * TINY)
        self.identical(fromHex('0x7p-1076'), 2 * TINY)
        self.identical(fromHex('0X8p-1076'), 2 * TINY)
        self.identical(fromHex('0X9p-1076'), 2 * TINY)
        self.identical(fromHex('0xap-1076'), 2 * TINY)
        self.identical(fromHex('0Xbp-1076'), 3 * TINY)
        self.identical(fromHex('0xcp-1076'), 3 * TINY)
        self.identical(fromHex('0Xdp-1076'), 3 * TINY)
        self.identical(fromHex('0Xep-1076'), 4 * TINY)
        self.identical(fromHex('0xfp-1076'), 4 * TINY)
        self.identical(fromHex('0x10p-1076'), 4 * TINY)
        self.identical(fromHex('-0x1p-1076'), -0.0)
        self.identical(fromHex('-0X2p-1076'), -0.0)
        self.identical(fromHex('-0x3p-1076'), -TINY)
        self.identical(fromHex('-0X4p-1076'), -TINY)
        self.identical(fromHex('-0x5p-1076'), -TINY)
        self.identical(fromHex('-0x6p-1076'), -2 * TINY)
        self.identical(fromHex('-0X7p-1076'), -2 * TINY)
        self.identical(fromHex('-0X8p-1076'), -2 * TINY)
        self.identical(fromHex('-0X9p-1076'), -2 * TINY)
        self.identical(fromHex('-0Xap-1076'), -2 * TINY)
        self.identical(fromHex('-0xbp-1076'), -3 * TINY)
        self.identical(fromHex('-0xcp-1076'), -3 * TINY)
        self.identical(fromHex('-0Xdp-1076'), -3 * TINY)
        self.identical(fromHex('-0xep-1076'), -4 * TINY)
        self.identical(fromHex('-0Xfp-1076'), -4 * TINY)
        self.identical(fromHex('-0X10p-1076'), -4 * TINY)
        self.identical(fromHex('0x0.ffffffffffffd6p-1022'), MIN - 3 * TINY)
        self.identical(fromHex('0x0.ffffffffffffd8p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffdap-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffdcp-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffdep-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffe0p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffe2p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffe4p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffe6p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffe8p-1022'), MIN - 2 * TINY)
        self.identical(fromHex('0x0.ffffffffffffeap-1022'), MIN - TINY)
        self.identical(fromHex('0x0.ffffffffffffecp-1022'), MIN - TINY)
        self.identical(fromHex('0x0.ffffffffffffeep-1022'), MIN - TINY)
        self.identical(fromHex('0x0.fffffffffffff0p-1022'), MIN - TINY)
        self.identical(fromHex('0x0.fffffffffffff2p-1022'), MIN - TINY)
        self.identical(fromHex('0x0.fffffffffffff4p-1022'), MIN - TINY)
        self.identical(fromHex('0x0.fffffffffffff6p-1022'), MIN - TINY)
        self.identical(fromHex('0x0.fffffffffffff8p-1022'), MIN)
        self.identical(fromHex('0x0.fffffffffffffap-1022'), MIN)
        self.identical(fromHex('0x0.fffffffffffffcp-1022'), MIN)
        self.identical(fromHex('0x0.fffffffffffffep-1022'), MIN)
        self.identical(fromHex('0x1.00000000000000p-1022'), MIN)
        self.identical(fromHex('0x1.00000000000002p-1022'), MIN)
        self.identical(fromHex('0x1.00000000000004p-1022'), MIN)
        self.identical(fromHex('0x1.00000000000006p-1022'), MIN)
        self.identical(fromHex('0x1.00000000000008p-1022'), MIN)
        self.identical(fromHex('0x1.0000000000000ap-1022'), MIN + TINY)
        self.identical(fromHex('0x1.0000000000000cp-1022'), MIN + TINY)
        self.identical(fromHex('0x1.0000000000000ep-1022'), MIN + TINY)
        self.identical(fromHex('0x1.00000000000010p-1022'), MIN + TINY)
        self.identical(fromHex('0x1.00000000000012p-1022'), MIN + TINY)
        self.identical(fromHex('0x1.00000000000014p-1022'), MIN + TINY)
        self.identical(fromHex('0x1.00000000000016p-1022'), MIN + TINY)
        self.identical(fromHex('0x1.00000000000018p-1022'), MIN + 2 * TINY)
        self.identical(fromHex('0x0.fffffffffffff0p0'), 1.0 - EPS)
        self.identical(fromHex('0x0.fffffffffffff1p0'), 1.0 - EPS)
        self.identical(fromHex('0X0.fffffffffffff2p0'), 1.0 - EPS)
        self.identical(fromHex('0x0.fffffffffffff3p0'), 1.0 - EPS)
        self.identical(fromHex('0X0.fffffffffffff4p0'), 1.0 - EPS)
        self.identical(fromHex('0X0.fffffffffffff5p0'), 1.0 - EPS / 2)
        self.identical(fromHex('0X0.fffffffffffff6p0'), 1.0 - EPS / 2)
        self.identical(fromHex('0x0.fffffffffffff7p0'), 1.0 - EPS / 2)
        self.identical(fromHex('0x0.fffffffffffff8p0'), 1.0 - EPS / 2)
        self.identical(fromHex('0X0.fffffffffffff9p0'), 1.0 - EPS / 2)
        self.identical(fromHex('0X0.fffffffffffffap0'), 1.0 - EPS / 2)
        self.identical(fromHex('0x0.fffffffffffffbp0'), 1.0 - EPS / 2)
        self.identical(fromHex('0X0.fffffffffffffcp0'), 1.0)
        self.identical(fromHex('0x0.fffffffffffffdp0'), 1.0)
        self.identical(fromHex('0X0.fffffffffffffep0'), 1.0)
        self.identical(fromHex('0x0.ffffffffffffffp0'), 1.0)
        self.identical(fromHex('0X1.00000000000000p0'), 1.0)
        self.identical(fromHex('0X1.00000000000001p0'), 1.0)
        self.identical(fromHex('0x1.00000000000002p0'), 1.0)
        self.identical(fromHex('0X1.00000000000003p0'), 1.0)
        self.identical(fromHex('0x1.00000000000004p0'), 1.0)
        self.identical(fromHex('0X1.00000000000005p0'), 1.0)
        self.identical(fromHex('0X1.00000000000006p0'), 1.0)
        self.identical(fromHex('0X1.00000000000007p0'), 1.0)
        self.identical(fromHex('0x1.00000000000007ffffffffffffffffffffp0'), 1.0
            )
        self.identical(fromHex('0x1.00000000000008p0'), 1.0)
        self.identical(fromHex('0x1.00000000000008000000000000000001p0'), 1 +
            EPS)
        self.identical(fromHex('0X1.00000000000009p0'), 1.0 + EPS)
        self.identical(fromHex('0x1.0000000000000ap0'), 1.0 + EPS)
        self.identical(fromHex('0x1.0000000000000bp0'), 1.0 + EPS)
        self.identical(fromHex('0X1.0000000000000cp0'), 1.0 + EPS)
        self.identical(fromHex('0x1.0000000000000dp0'), 1.0 + EPS)
        self.identical(fromHex('0x1.0000000000000ep0'), 1.0 + EPS)
        self.identical(fromHex('0X1.0000000000000fp0'), 1.0 + EPS)
        self.identical(fromHex('0x1.00000000000010p0'), 1.0 + EPS)
        self.identical(fromHex('0X1.00000000000011p0'), 1.0 + EPS)
        self.identical(fromHex('0x1.00000000000012p0'), 1.0 + EPS)
        self.identical(fromHex('0X1.00000000000013p0'), 1.0 + EPS)
        self.identical(fromHex('0X1.00000000000014p0'), 1.0 + EPS)
        self.identical(fromHex('0x1.00000000000015p0'), 1.0 + EPS)
        self.identical(fromHex('0x1.00000000000016p0'), 1.0 + EPS)
        self.identical(fromHex('0X1.00000000000017p0'), 1.0 + EPS)
        self.identical(fromHex('0x1.00000000000017ffffffffffffffffffffp0'),
            1.0 + EPS)
        self.identical(fromHex('0x1.00000000000018p0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0X1.00000000000018000000000000000001p0'), 
            1.0 + 2 * EPS)
        self.identical(fromHex('0x1.00000000000019p0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0X1.0000000000001ap0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0X1.0000000000001bp0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0x1.0000000000001cp0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0x1.0000000000001dp0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0x1.0000000000001ep0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0X1.0000000000001fp0'), 1.0 + 2 * EPS)
        self.identical(fromHex('0x1.00000000000020p0'), 1.0 + 2 * EPS)

    def test_roundtrip(self):

        def roundtrip(x):
            return fromHex(toHex(x))
        for x in [NAN, INF, self.MAX, self.MIN, self.MIN - self.TINY, self.
            TINY, 0.0]:
            self.identical(x, roundtrip(x))
            self.identical(-x, roundtrip(-x))
        import random
        for i in range(10000):
            e = random.randrange(-1200, 1200)
            m = random.random()
            s = random.choice([1.0, -1.0])
            try:
                x = s * ldexp(m, e)
            except OverflowError:
                pass
            else:
                self.identical(x, fromHex(toHex(x)))

    def test_subclass(self):


        class F(float):

            def __new__(cls, value):
                return float.__new__(cls, value + 1)
        f = F.fromhex((1.5).hex())
        self.assertIs(type(f), F)
        self.assertEqual(f, 2.5)


        class F2(float):

            def __init__(self, value):
                self.foo = 'bar'
        f = F2.fromhex((1.5).hex())
        self.assertIs(type(f), F2)
        self.assertEqual(f, 1.5)
        self.assertEqual(getattr(f, 'foo', 'none'), 'bar')


if __name__ == '__main__':
    unittest.main()

#e', '%#f', #g', '%#.20e', '%#.15f', '%#.3g']: