From 987ad1218154fc9c287de5d2549a160dcf40e6cc Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Sun, 5 Mar 2023 21:47:42 +0900
Subject: [PATCH 1/2] relocate int-unrelated tests to proper files

---
 extra_tests/snippets/builtin_complex.py | 31 +++++++++++++++----------
 extra_tests/snippets/builtin_float.py   |  1 +
 extra_tests/snippets/builtin_int.py     | 10 --------
 3 files changed, 20 insertions(+), 22 deletions(-)

diff --git a/extra_tests/snippets/builtin_complex.py b/extra_tests/snippets/builtin_complex.py
index 61dc70712..f030db812 100644
--- a/extra_tests/snippets/builtin_complex.py
+++ b/extra_tests/snippets/builtin_complex.py
@@ -9,6 +9,7 @@ assert abs(complex(1.5, 2.5)) == 2.9154759474226504
 
 # __eq__
 
+assert 3+02j == 3+2j
 assert complex(1, -1) == complex(1, -1)
 assert complex(1, 0) == 1
 assert 1 == complex(1, 0)
@@ -212,16 +213,22 @@ assert complex('-1e-500j') == 0.0 - 0.0j
 assert complex('-1e-500+1e-500j') == -0.0 + 0.0j
 
 
-# __complex__
-def test__complex__():
-    z = 3 + 4j
-    assert z.__complex__() == z
-    assert type(z.__complex__()) == complex
-    
-    class complex_subclass(complex):
-        pass
-    z = complex_subclass(3 + 4j)
-    assert z.__complex__() == 3 + 4j
-    assert type(z.__complex__()) == complex
+# Invalid syntax:
+src = """
+b = 03 + 2j
+"""
 
-testutils.skip_if_unsupported(3, 11, test__complex__)
+with assert_raises(SyntaxError):
+    exec(src)
+
+
+# __complex__
+z = 3 + 4j
+assert z.__complex__() == z
+assert type(z.__complex__()) == complex
+
+class complex_subclass(complex):
+    pass
+z = complex_subclass(3 + 4j)
+assert z.__complex__() == 3 + 4j
+assert type(z.__complex__()) == complex
diff --git a/extra_tests/snippets/builtin_float.py b/extra_tests/snippets/builtin_float.py
index cf30a872d..e12b52ae1 100644
--- a/extra_tests/snippets/builtin_float.py
+++ b/extra_tests/snippets/builtin_float.py
@@ -116,6 +116,7 @@ assert hash(0.0) == hash(0)
 assert hash(0.0) == hash(False)
 assert hash(1.0) != hash(1.0000000001)
 
+assert 03.2 == 3.2
 assert 5.0 in {3, 4, 5}
 assert {-1: 2}[-1.0] == 2
 
diff --git a/extra_tests/snippets/builtin_int.py b/extra_tests/snippets/builtin_int.py
index 0fd4de801..c79f57ef9 100644
--- a/extra_tests/snippets/builtin_int.py
+++ b/extra_tests/snippets/builtin_int.py
@@ -301,22 +301,12 @@ assert_raises(TypeError, lambda: (1).__round__(0.0))
 
 assert 00 == 0
 assert 0_0 == 0
-assert 03.2 == 3.2
-assert 3+02j == 3+2j
 
 # Invalid syntax:
 src = """
 b = 02
 """
 
-with assert_raises(SyntaxError):
-    exec(src)
-
-# Invalid syntax:
-src = """
-b = 03 + 2j
-"""
-
 with assert_raises(SyntaxError):
     exec(src)
 

From 865c4984f66f6409292ded65077bd3dbca69f4a1 Mon Sep 17 00:00:00 2001
From: black formatter <>
Date: Sun, 5 Mar 2023 21:48:37 +0900
Subject: [PATCH 2/2] format tests with black

---
 extra_tests/snippets/builtin_complex.py | 106 +++---
 extra_tests/snippets/builtin_float.py   | 452 ++++++++++++------------
 extra_tests/snippets/builtin_int.py     | 169 +++++----
 3 files changed, 380 insertions(+), 347 deletions(-)

diff --git a/extra_tests/snippets/builtin_complex.py b/extra_tests/snippets/builtin_complex.py
index f030db812..2a2c2d375 100644
--- a/extra_tests/snippets/builtin_complex.py
+++ b/extra_tests/snippets/builtin_complex.py
@@ -9,7 +9,7 @@ assert abs(complex(1.5, 2.5)) == 2.9154759474226504
 
 # __eq__
 
-assert 3+02j == 3+2j
+assert 3 + 02j == 3 + 2j
 assert complex(1, -1) == complex(1, -1)
 assert complex(1, 0) == 1
 assert 1 == complex(1, 0)
@@ -23,9 +23,9 @@ assert complex(1, 0) != 1.5
 assert not 1.0 != complex(1, 0)
 assert bool(complex(1, 0))
 assert complex(1, 2) != complex(1, 1)
-assert complex(1, 2) != 'foo'
-assert complex(1, 2).__eq__('foo') == NotImplemented
-assert 1j != 10 ** 1000
+assert complex(1, 2) != "foo"
+assert complex(1, 2).__eq__("foo") == NotImplemented
+assert 1j != 10**1000
 
 # __mul__, __rmul__
 
@@ -82,7 +82,7 @@ assert bool(complex(1, 0)) is True
 assert hash(complex(1)) == hash(float(1)) == hash(int(1))
 assert hash(complex(-1)) == hash(float(-1)) == hash(int(-1))
 assert hash(complex(3.14)) == hash(float(3.14))
-assert hash(complex(-float('inf'))) == hash(-float('inf'))
+assert hash(complex(-float("inf"))) == hash(-float("inf"))
 assert hash(1j) != hash(1)
 
 # TODO: Find a way to test platform dependent values
@@ -120,28 +120,28 @@ assert 1j - 1 == complex(-1, 1)
 assert 2j - 1j == complex(0, 1)
 
 # type error addition
-assert_raises(TypeError, lambda: 1j + 'str')
-assert_raises(TypeError, lambda: 1j - 'str')
-assert_raises(TypeError, lambda: 'str' + 1j)
-assert_raises(TypeError, lambda: 'str' - 1j)
+assert_raises(TypeError, lambda: 1j + "str")
+assert_raises(TypeError, lambda: 1j - "str")
+assert_raises(TypeError, lambda: "str" + 1j)
+assert_raises(TypeError, lambda: "str" - 1j)
 
 # overflow
-assert_raises(OverflowError, lambda: complex(10 ** 1000, 0))
-assert_raises(OverflowError, lambda: complex(0, 10 ** 1000))
-assert_raises(OverflowError, lambda: 0j + 10 ** 1000)
+assert_raises(OverflowError, lambda: complex(10**1000, 0))
+assert_raises(OverflowError, lambda: complex(0, 10**1000))
+assert_raises(OverflowError, lambda: 0j + 10**1000)
 
 # str/repr
-assert '(1+1j)' == str(1+1j)
-assert '(1-1j)' == str(1-1j)
-assert '(1+1j)' == repr(1+1j)
-assert '(1-1j)' == repr(1-1j)
+assert "(1+1j)" == str(1 + 1j)
+assert "(1-1j)" == str(1 - 1j)
+assert "(1+1j)" == repr(1 + 1j)
+assert "(1-1j)" == repr(1 - 1j)
 
 # __getnewargs__
 assert (3 + 5j).__getnewargs__() == (3.0, 5.0)
 assert (5j).__getnewargs__() == (0.0, 5.0)
 
 
-class Complex():
+class Complex:
     def __init__(self, real, imag):
         self.real = real
         self.imag = imag
@@ -158,6 +158,7 @@ class Complex():
     def __eq__(self, other):
         return self.real == other.real and self.imag == other.imag
 
+
 assert Complex(4, 5) - 3 == Complex(1, 5)
 assert 7 - Complex(4, 5) == Complex(3, -5)
 
@@ -167,50 +168,50 @@ assert complex("-2j") == -2j
 assert_raises(TypeError, lambda: complex("5+2j", 1))
 assert_raises(ValueError, lambda: complex("abc"))
 
-assert complex("1+10j") == 1+10j
-assert complex(10) == 10+0j
-assert complex(10.0) == 10+0j
-assert complex(10) == 10+0j
-assert complex(10+0j) == 10+0j
-assert complex(1, 10) == 1+10j
-assert complex(1, 10) == 1+10j
-assert complex(1, 10.0) == 1+10j
-assert complex(1, 10) == 1+10j
-assert complex(1, 10) == 1+10j
-assert complex(1, 10.0) == 1+10j
-assert complex(1.0, 10) == 1+10j
-assert complex(1.0, 10) == 1+10j
-assert complex(1.0, 10.0) == 1+10j
-assert complex(3.14+0j) == 3.14+0j
-assert complex(3.14) == 3.14+0j
-assert complex(314) == 314.0+0j
-assert complex(314) == 314.0+0j
-assert complex(3.14+0j, 0j) == 3.14+0j
-assert complex(3.14, 0.0) == 3.14+0j
-assert complex(314, 0) == 314.0+0j
-assert complex(314, 0) == 314.0+0j
-assert complex(0j, 3.14j) == -3.14+0j
-assert complex(0.0, 3.14j) == -3.14+0j
+assert complex("1+10j") == 1 + 10j
+assert complex(10) == 10 + 0j
+assert complex(10.0) == 10 + 0j
+assert complex(10) == 10 + 0j
+assert complex(10 + 0j) == 10 + 0j
+assert complex(1, 10) == 1 + 10j
+assert complex(1, 10) == 1 + 10j
+assert complex(1, 10.0) == 1 + 10j
+assert complex(1, 10) == 1 + 10j
+assert complex(1, 10) == 1 + 10j
+assert complex(1, 10.0) == 1 + 10j
+assert complex(1.0, 10) == 1 + 10j
+assert complex(1.0, 10) == 1 + 10j
+assert complex(1.0, 10.0) == 1 + 10j
+assert complex(3.14 + 0j) == 3.14 + 0j
+assert complex(3.14) == 3.14 + 0j
+assert complex(314) == 314.0 + 0j
+assert complex(314) == 314.0 + 0j
+assert complex(3.14 + 0j, 0j) == 3.14 + 0j
+assert complex(3.14, 0.0) == 3.14 + 0j
+assert complex(314, 0) == 314.0 + 0j
+assert complex(314, 0) == 314.0 + 0j
+assert complex(0j, 3.14j) == -3.14 + 0j
+assert complex(0.0, 3.14j) == -3.14 + 0j
 assert complex(0j, 3.14) == 3.14j
 assert complex(0.0, 3.14) == 3.14j
-assert complex("1") == 1+0j
+assert complex("1") == 1 + 0j
 assert complex("1j") == 1j
 assert complex() == 0
 assert complex("-1") == -1
 assert complex("+1") == +1
-assert complex("(1+2j)") == 1+2j
-assert complex("(1.3+2.2j)") == 1.3+2.2j
-assert complex("3.14+1J") == 3.14+1j
-assert complex(" ( +3.14-6J )") == 3.14-6j
-assert complex(" ( +3.14-J )") == 3.14-1j
-assert complex(" ( +3.14+j )") == 3.14+1j
+assert complex("(1+2j)") == 1 + 2j
+assert complex("(1.3+2.2j)") == 1.3 + 2.2j
+assert complex("3.14+1J") == 3.14 + 1j
+assert complex(" ( +3.14-6J )") == 3.14 - 6j
+assert complex(" ( +3.14-J )") == 3.14 - 1j
+assert complex(" ( +3.14+j )") == 3.14 + 1j
 assert complex("J") == 1j
 assert complex("( j )") == 1j
 assert complex("+J") == 1j
 assert complex("( -j)") == -1j
-assert complex('1e-500') == 0.0 + 0.0j
-assert complex('-1e-500j') == 0.0 - 0.0j
-assert complex('-1e-500+1e-500j') == -0.0 + 0.0j
+assert complex("1e-500") == 0.0 + 0.0j
+assert complex("-1e-500j") == 0.0 - 0.0j
+assert complex("-1e-500+1e-500j") == -0.0 + 0.0j
 
 
 # Invalid syntax:
@@ -227,8 +228,11 @@ z = 3 + 4j
 assert z.__complex__() == z
 assert type(z.__complex__()) == complex
 
+
 class complex_subclass(complex):
     pass
+
+
 z = complex_subclass(3 + 4j)
 assert z.__complex__() == 3 + 4j
 assert type(z.__complex__()) == complex
diff --git a/extra_tests/snippets/builtin_float.py b/extra_tests/snippets/builtin_float.py
index e12b52ae1..fa5a734fd 100644
--- a/extra_tests/snippets/builtin_float.py
+++ b/extra_tests/snippets/builtin_float.py
@@ -2,9 +2,9 @@ import math
 
 from testutils import assert_raises
 
-NAN = float('nan')
-INF = float('inf')
-NINF = float('-inf')
+NAN = float("nan")
+INF = float("inf")
+NINF = float("-inf")
 
 1 + 1.1
 
@@ -12,7 +12,7 @@ a = 1.2
 b = 1.3
 c = 1.2
 z = 2
-ov = 10 ** 1000
+ov = 10**1000
 
 assert -a == -1.2
 
@@ -48,7 +48,7 @@ assert_raises(OverflowError, lambda: a * ov)
 assert_raises(OverflowError, lambda: a / ov)
 assert_raises(OverflowError, lambda: a // ov)
 assert_raises(OverflowError, lambda: a % ov)
-assert_raises(OverflowError, lambda: a ** ov)
+assert_raises(OverflowError, lambda: a**ov)
 assert_raises(OverflowError, lambda: ov + a)
 assert_raises(OverflowError, lambda: ov - a)
 assert_raises(OverflowError, lambda: ov * a)
@@ -62,46 +62,46 @@ assert a <= 5
 assert a < 5.5
 assert a <= 5.5
 try:
-    assert a < 'a'
+    assert a < "a"
 except TypeError:
     pass
 try:
-    assert a <= 'a'
+    assert a <= "a"
 except TypeError:
     pass
 assert a > 1
 assert a >= 1
 try:
-    assert a > 'a'
+    assert a > "a"
 except TypeError:
     pass
 try:
-    assert a >= 'a'
+    assert a >= "a"
 except TypeError:
     pass
 
-assert math.isnan(float('nan'))
-assert math.isnan(float('NaN'))
-assert math.isnan(float('+NaN'))
-assert math.isnan(float('-NaN'))
+assert math.isnan(float("nan"))
+assert math.isnan(float("NaN"))
+assert math.isnan(float("+NaN"))
+assert math.isnan(float("-NaN"))
 
-assert math.isinf(float('inf'))
-assert math.isinf(float('Inf'))
-assert math.isinf(float('+Inf'))
-assert math.isinf(float('-Inf'))
+assert math.isinf(float("inf"))
+assert math.isinf(float("Inf"))
+assert math.isinf(float("+Inf"))
+assert math.isinf(float("-Inf"))
 
 assert float() == 0
 
-assert float('+Inf') > 0
-assert float('-Inf') < 0
+assert float("+Inf") > 0
+assert float("-Inf") < 0
 
-assert float('3.14') == 3.14
-assert float('2.99e-23') == 2.99e-23
+assert float("3.14") == 3.14
+assert float("2.99e-23") == 2.99e-23
 
-assert float(b'3.14') == 3.14
-assert float(b'2.99e-23') == 2.99e-23
+assert float(b"3.14") == 3.14
+assert float(b"2.99e-23") == 2.99e-23
 
-assert_raises(ValueError, float, 'foo')
+assert_raises(ValueError, float, "foo")
 assert_raises(OverflowError, float, 2**10000)
 
 # check eq and hash for small numbers
@@ -122,25 +122,25 @@ assert {-1: 2}[-1.0] == 2
 
 # check that magic methods are implemented for ints and floats
 
-assert 1.0.__add__(1.0) == 2.0
-assert 1.0.__radd__(1.0) == 2.0
-assert 2.0.__sub__(1.0) == 1.0
-assert 2.0.__rmul__(1.0) == 2.0
-assert 1.0.__truediv__(2.0) == 0.5
-assert 1.0.__rtruediv__(2.0) == 2.0
-assert 2.5.__divmod__(2.0) == (1.0, 0.5)
-assert 2.0.__rdivmod__(2.5) == (1.0, 0.5)
+assert (1.0).__add__(1.0) == 2.0
+assert (1.0).__radd__(1.0) == 2.0
+assert (2.0).__sub__(1.0) == 1.0
+assert (2.0).__rmul__(1.0) == 2.0
+assert (1.0).__truediv__(2.0) == 0.5
+assert (1.0).__rtruediv__(2.0) == 2.0
+assert (2.5).__divmod__(2.0) == (1.0, 0.5)
+assert (2.0).__rdivmod__(2.5) == (1.0, 0.5)
 
-assert 1.0.__add__(1) == 2.0
-assert 1.0.__radd__(1) == 2.0
-assert 2.0.__sub__(1) == 1.0
-assert 2.0.__rmul__(1) == 2.0
-assert 1.0.__truediv__(2) == 0.5
-assert 1.0.__rtruediv__(2) == 2.0
-assert 2.0.__mul__(1) == 2.0
-assert 2.0.__rsub__(1) == -1.0
-assert 2.0.__mod__(2) == 0.0
-assert 2.0.__rmod__(2) == 0.0
+assert (1.0).__add__(1) == 2.0
+assert (1.0).__radd__(1) == 2.0
+assert (2.0).__sub__(1) == 1.0
+assert (2.0).__rmul__(1) == 2.0
+assert (1.0).__truediv__(2) == 0.5
+assert (1.0).__rtruediv__(2) == 2.0
+assert (2.0).__mul__(1) == 2.0
+assert (2.0).__rsub__(1) == -1.0
+assert (2.0).__mod__(2) == 0.0
+assert (2.0).__rmod__(2) == 0.0
 assert_raises(ZeroDivisionError, lambda: 2.0 / 0)
 assert_raises(ZeroDivisionError, lambda: 2.0 // 0)
 assert_raises(ZeroDivisionError, lambda: 2.0 % 0)
@@ -154,49 +154,49 @@ assert_raises(ZeroDivisionError, lambda: 2.0 // 0.0)
 assert_raises(ZeroDivisionError, lambda: 2.0 % 0.0)
 assert_raises(ZeroDivisionError, divmod, 2.0, 0.0)
 
-assert 1.2.__int__() == 1
-assert 1.2.__float__() == 1.2
-assert 1.2.__trunc__() == 1
+assert (1.2).__int__() == 1
+assert (1.2).__float__() == 1.2
+assert (1.2).__trunc__() == 1
 assert int(1.2) == 1
 assert float(1.2) == 1.2
 assert math.trunc(1.2) == 1
-assert_raises(OverflowError, float('inf').__trunc__)
-assert_raises(ValueError, float('nan').__trunc__)
-assert isinstance(0.5.__round__(), int)
-assert isinstance(1.5.__round__(), int)
-assert 0.5.__round__() == 0
-assert 1.5.__round__() == 2
-assert isinstance(0.5.__round__(0), float)
-assert isinstance(1.5.__round__(0), float)
-assert 0.5.__round__(0) == 0.0
-assert 1.5.__round__(0) == 2.0
-assert isinstance(0.5.__round__(None), int)
-assert isinstance(1.5.__round__(None), int)
-assert 0.5.__round__(None) == 0
-assert 1.5.__round__(None) == 2
-assert 1.234.__round__(1) == 1.2
-assert 1.23456.__round__(4) == 1.2346
-assert 1.00000000001.__round__(10) == 1.0
-assert 1234.5.__round__(-2) == 1200
-assert 1.234.__round__(-1) == 0
-assert 1.23456789.__round__(15) == 1.23456789
-assert 1.2e300.__round__(-500) == 0
-assert 1.234.__round__(500) == 1.234
-assert 1.2e-300.__round__(299) == 0
-assert_raises(TypeError, lambda: 0.5.__round__(0.0))
-assert_raises(TypeError, lambda: 1.5.__round__(0.0))
-assert_raises(OverflowError, float('inf').__round__)
-assert_raises(ValueError, float('nan').__round__)
+assert_raises(OverflowError, float("inf").__trunc__)
+assert_raises(ValueError, float("nan").__trunc__)
+assert isinstance((0.5).__round__(), int)
+assert isinstance((1.5).__round__(), int)
+assert (0.5).__round__() == 0
+assert (1.5).__round__() == 2
+assert isinstance((0.5).__round__(0), float)
+assert isinstance((1.5).__round__(0), float)
+assert (0.5).__round__(0) == 0.0
+assert (1.5).__round__(0) == 2.0
+assert isinstance((0.5).__round__(None), int)
+assert isinstance((1.5).__round__(None), int)
+assert (0.5).__round__(None) == 0
+assert (1.5).__round__(None) == 2
+assert (1.234).__round__(1) == 1.2
+assert (1.23456).__round__(4) == 1.2346
+assert (1.00000000001).__round__(10) == 1.0
+assert (1234.5).__round__(-2) == 1200
+assert (1.234).__round__(-1) == 0
+assert (1.23456789).__round__(15) == 1.23456789
+assert (1.2e300).__round__(-500) == 0
+assert (1.234).__round__(500) == 1.234
+assert (1.2e-300).__round__(299) == 0
+assert_raises(TypeError, lambda: (0.5).__round__(0.0))
+assert_raises(TypeError, lambda: (1.5).__round__(0.0))
+assert_raises(OverflowError, float("inf").__round__)
+assert_raises(ValueError, float("nan").__round__)
 
-assert 1.2 ** 2 == 1.44
-assert_raises(OverflowError, lambda: 1.2 ** (10 ** 1000))
-assert 3 ** 2.0 == 9.0
+assert 1.2**2 == 1.44
+assert_raises(OverflowError, lambda: 1.2 ** (10**1000))
+assert 3**2.0 == 9.0
 
 assert (1.7).real == 1.7
 assert (1.7).imag == 0.0
 assert (1.7).conjugate() == 1.7
 assert (1.3).is_integer() == False
-assert (1.0).is_integer()    == True
+assert (1.0).is_integer() == True
 
 assert (0.875).as_integer_ratio() == (7, 8)
 assert (-0.875).as_integer_ratio() == (-7, 8)
@@ -209,22 +209,28 @@ assert (2.1).as_integer_ratio() == (4728779608739021, 2251799813685248)
 assert (-2.1).as_integer_ratio() == (-4728779608739021, 2251799813685248)
 assert (-2100.0).as_integer_ratio() == (-2100, 1)
 assert (2.220446049250313e-16).as_integer_ratio() == (1, 4503599627370496)
-assert (1.7976931348623157e+308).as_integer_ratio() == (179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368, 1)
-assert (2.2250738585072014e-308).as_integer_ratio() == (1, 44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304)
+assert (1.7976931348623157e308).as_integer_ratio() == (
+    179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368,
+    1,
+)
+assert (2.2250738585072014e-308).as_integer_ratio() == (
+    1,
+    44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304,
+)
 
-assert_raises(OverflowError, float('inf').as_integer_ratio)
-assert_raises(OverflowError, float('-inf').as_integer_ratio)
-assert_raises(ValueError, float('nan').as_integer_ratio)
+assert_raises(OverflowError, float("inf").as_integer_ratio)
+assert_raises(OverflowError, float("-inf").as_integer_ratio)
+assert_raises(ValueError, float("nan").as_integer_ratio)
 
-assert str(1.0) == '1.0'
-assert str(0.0) == '0.0'
-assert str(-0.0) == '-0.0'
-assert str(1.123456789) == '1.123456789'
+assert str(1.0) == "1.0"
+assert str(0.0) == "0.0"
+assert str(-0.0) == "-0.0"
+assert str(1.123456789) == "1.123456789"
 
 # Test special case for lexer, float starts with a dot:
-a = .5
+a = 0.5
 assert a == 0.5
-assert 3.14 == float('3.14')
+assert 3.14 == float("3.14")
 src = """
 a = 3._14
 """
@@ -246,6 +252,8 @@ with assert_raises(SyntaxError):
     exec(src)
 
 fromHex = float.fromhex
+
+
 def identical(x, y):
     if math.isnan(x) or math.isnan(y):
         if math.isnan(x) == math.isnan(y):
@@ -254,6 +262,7 @@ def identical(x, y):
         return
     raise SyntaxError(f"{x} not identical to {y}")
 
+
 invalid_inputs = [
     "infi",  # misspelt infinities and nans
     "-Infinit",
@@ -319,16 +328,7 @@ value_pairs = [
     ("-0x.2", -0.125),
     ("-0.0", -0.0),
 ]
-whitespace = [
-    "",
-    " ",
-    "\t",
-    "\n",
-    "\n \t",
-    "\f",
-    "\v",
-    "\r"
-]
+whitespace = ["", " ", "\t", "\n", "\n \t", "\f", "\v", "\r"]
 
 for inp, expected in value_pairs:
     for lead in whitespace:
@@ -336,120 +336,120 @@ for inp, expected in value_pairs:
             got = fromHex(lead + inp + trail)
             identical(got, expected)
 
-MAX = fromHex('0x.fffffffffffff8p+1024')  # max normal
-MIN = fromHex('0x1p-1022')                # min normal
-TINY = fromHex('0x0.0000000000001p-1022') # min subnormal
-EPS = fromHex('0x0.0000000000001p0') # diff between 1.0 and next float up
+MAX = fromHex("0x.fffffffffffff8p+1024")  # max normal
+MIN = fromHex("0x1p-1022")  # min normal
+TINY = fromHex("0x0.0000000000001p-1022")  # min subnormal
+EPS = fromHex("0x0.0000000000001p0")  # diff between 1.0 and next float up
 
 # two spellings of infinity, with optional signs; case-insensitive
-identical(fromHex('inf'), INF)
-identical(fromHex('+Inf'), INF)
-identical(fromHex('-INF'), -INF)
-identical(fromHex('iNf'), INF)
-identical(fromHex('Infinity'), INF)
-identical(fromHex('+INFINITY'), INF)
-identical(fromHex('-infinity'), -INF)
-identical(fromHex('-iNFiNitY'), -INF)
+identical(fromHex("inf"), INF)
+identical(fromHex("+Inf"), INF)
+identical(fromHex("-INF"), -INF)
+identical(fromHex("iNf"), INF)
+identical(fromHex("Infinity"), INF)
+identical(fromHex("+INFINITY"), INF)
+identical(fromHex("-infinity"), -INF)
+identical(fromHex("-iNFiNitY"), -INF)
 
 # nans with optional sign; case insensitive
-identical(fromHex('nan'), NAN)
-identical(fromHex('+NaN'), NAN)
-identical(fromHex('-NaN'), NAN)
-identical(fromHex('-nAN'), NAN)
+identical(fromHex("nan"), NAN)
+identical(fromHex("+NaN"), NAN)
+identical(fromHex("-NaN"), NAN)
+identical(fromHex("-nAN"), NAN)
 
 # variations in input format
-identical(fromHex('1'), 1.0)
-identical(fromHex('+1'), 1.0)
-identical(fromHex('1.'), 1.0)
-identical(fromHex('1.0'), 1.0)
-identical(fromHex('1.0p0'), 1.0)
-identical(fromHex('01'), 1.0)
-identical(fromHex('01.'), 1.0)
-identical(fromHex('0x1'), 1.0)
-identical(fromHex('0x1.'), 1.0)
-identical(fromHex('0x1.0'), 1.0)
-identical(fromHex('+0x1.0'), 1.0)
-identical(fromHex('0x1p0'), 1.0)
-identical(fromHex('0X1p0'), 1.0)
-identical(fromHex('0X1P0'), 1.0)
-identical(fromHex('0x1P0'), 1.0)
-identical(fromHex('0x1.p0'), 1.0)
-identical(fromHex('0x1.0p0'), 1.0)
-identical(fromHex('0x.1p4'), 1.0)
-identical(fromHex('0x.1p04'), 1.0)
-identical(fromHex('0x.1p004'), 1.0)
-identical(fromHex('0x1p+0'), 1.0)
-identical(fromHex('0x1P-0'), 1.0)
-identical(fromHex('+0x1p0'), 1.0)
-identical(fromHex('0x01p0'), 1.0)
-identical(fromHex('0x1p00'), 1.0)
-identical(fromHex(' 0x1p0 '), 1.0)
-identical(fromHex('\n 0x1p0'), 1.0)
-identical(fromHex('0x1p0 \t'), 1.0)
-identical(fromHex('0xap0'), 10.0)
-identical(fromHex('0xAp0'), 10.0)
-identical(fromHex('0xaP0'), 10.0)
-identical(fromHex('0xAP0'), 10.0)
-identical(fromHex('0xbep0'), 190.0)
-identical(fromHex('0xBep0'), 190.0)
-identical(fromHex('0xbEp0'), 190.0)
-identical(fromHex('0XBE0P-4'), 190.0)
-identical(fromHex('0xBEp0'), 190.0)
-identical(fromHex('0xB.Ep4'), 190.0)
-identical(fromHex('0x.BEp8'), 190.0)
-identical(fromHex('0x.0BEp12'), 190.0)
+identical(fromHex("1"), 1.0)
+identical(fromHex("+1"), 1.0)
+identical(fromHex("1."), 1.0)
+identical(fromHex("1.0"), 1.0)
+identical(fromHex("1.0p0"), 1.0)
+identical(fromHex("01"), 1.0)
+identical(fromHex("01."), 1.0)
+identical(fromHex("0x1"), 1.0)
+identical(fromHex("0x1."), 1.0)
+identical(fromHex("0x1.0"), 1.0)
+identical(fromHex("+0x1.0"), 1.0)
+identical(fromHex("0x1p0"), 1.0)
+identical(fromHex("0X1p0"), 1.0)
+identical(fromHex("0X1P0"), 1.0)
+identical(fromHex("0x1P0"), 1.0)
+identical(fromHex("0x1.p0"), 1.0)
+identical(fromHex("0x1.0p0"), 1.0)
+identical(fromHex("0x.1p4"), 1.0)
+identical(fromHex("0x.1p04"), 1.0)
+identical(fromHex("0x.1p004"), 1.0)
+identical(fromHex("0x1p+0"), 1.0)
+identical(fromHex("0x1P-0"), 1.0)
+identical(fromHex("+0x1p0"), 1.0)
+identical(fromHex("0x01p0"), 1.0)
+identical(fromHex("0x1p00"), 1.0)
+identical(fromHex(" 0x1p0 "), 1.0)
+identical(fromHex("\n 0x1p0"), 1.0)
+identical(fromHex("0x1p0 \t"), 1.0)
+identical(fromHex("0xap0"), 10.0)
+identical(fromHex("0xAp0"), 10.0)
+identical(fromHex("0xaP0"), 10.0)
+identical(fromHex("0xAP0"), 10.0)
+identical(fromHex("0xbep0"), 190.0)
+identical(fromHex("0xBep0"), 190.0)
+identical(fromHex("0xbEp0"), 190.0)
+identical(fromHex("0XBE0P-4"), 190.0)
+identical(fromHex("0xBEp0"), 190.0)
+identical(fromHex("0xB.Ep4"), 190.0)
+identical(fromHex("0x.BEp8"), 190.0)
+identical(fromHex("0x.0BEp12"), 190.0)
 
 # moving the point around
-pi = fromHex('0x1.921fb54442d18p1')
-identical(fromHex('0x.006487ed5110b46p11'), pi)
-identical(fromHex('0x.00c90fdaa22168cp10'), pi)
-identical(fromHex('0x.01921fb54442d18p9'), pi)
-identical(fromHex('0x.03243f6a8885a3p8'), pi)
-identical(fromHex('0x.06487ed5110b46p7'), pi)
-identical(fromHex('0x.0c90fdaa22168cp6'), pi)
-identical(fromHex('0x.1921fb54442d18p5'), pi)
-identical(fromHex('0x.3243f6a8885a3p4'), pi)
-identical(fromHex('0x.6487ed5110b46p3'), pi)
-identical(fromHex('0x.c90fdaa22168cp2'), pi)
-identical(fromHex('0x1.921fb54442d18p1'), pi)
-identical(fromHex('0x3.243f6a8885a3p0'), pi)
-identical(fromHex('0x6.487ed5110b46p-1'), pi)
-identical(fromHex('0xc.90fdaa22168cp-2'), pi)
-identical(fromHex('0x19.21fb54442d18p-3'), pi)
-identical(fromHex('0x32.43f6a8885a3p-4'), pi)
-identical(fromHex('0x64.87ed5110b46p-5'), pi)
-identical(fromHex('0xc9.0fdaa22168cp-6'), pi)
-identical(fromHex('0x192.1fb54442d18p-7'), pi)
-identical(fromHex('0x324.3f6a8885a3p-8'), pi)
-identical(fromHex('0x648.7ed5110b46p-9'), pi)
-identical(fromHex('0xc90.fdaa22168cp-10'), pi)
-identical(fromHex('0x1921.fb54442d18p-11'), pi)
-identical(fromHex('0x1921fb54442d1.8p-47'), pi)
-identical(fromHex('0x3243f6a8885a3p-48'), pi)
-identical(fromHex('0x6487ed5110b46p-49'), pi)
-identical(fromHex('0xc90fdaa22168cp-50'), pi)
-identical(fromHex('0x1921fb54442d18p-51'), pi)
-identical(fromHex('0x3243f6a8885a30p-52'), pi)
-identical(fromHex('0x6487ed5110b460p-53'), pi)
-identical(fromHex('0xc90fdaa22168c0p-54'), pi)
-identical(fromHex('0x1921fb54442d180p-55'), pi)
+pi = fromHex("0x1.921fb54442d18p1")
+identical(fromHex("0x.006487ed5110b46p11"), pi)
+identical(fromHex("0x.00c90fdaa22168cp10"), pi)
+identical(fromHex("0x.01921fb54442d18p9"), pi)
+identical(fromHex("0x.03243f6a8885a3p8"), pi)
+identical(fromHex("0x.06487ed5110b46p7"), pi)
+identical(fromHex("0x.0c90fdaa22168cp6"), pi)
+identical(fromHex("0x.1921fb54442d18p5"), pi)
+identical(fromHex("0x.3243f6a8885a3p4"), pi)
+identical(fromHex("0x.6487ed5110b46p3"), pi)
+identical(fromHex("0x.c90fdaa22168cp2"), pi)
+identical(fromHex("0x1.921fb54442d18p1"), pi)
+identical(fromHex("0x3.243f6a8885a3p0"), pi)
+identical(fromHex("0x6.487ed5110b46p-1"), pi)
+identical(fromHex("0xc.90fdaa22168cp-2"), pi)
+identical(fromHex("0x19.21fb54442d18p-3"), pi)
+identical(fromHex("0x32.43f6a8885a3p-4"), pi)
+identical(fromHex("0x64.87ed5110b46p-5"), pi)
+identical(fromHex("0xc9.0fdaa22168cp-6"), pi)
+identical(fromHex("0x192.1fb54442d18p-7"), pi)
+identical(fromHex("0x324.3f6a8885a3p-8"), pi)
+identical(fromHex("0x648.7ed5110b46p-9"), pi)
+identical(fromHex("0xc90.fdaa22168cp-10"), pi)
+identical(fromHex("0x1921.fb54442d18p-11"), pi)
+identical(fromHex("0x1921fb54442d1.8p-47"), pi)
+identical(fromHex("0x3243f6a8885a3p-48"), pi)
+identical(fromHex("0x6487ed5110b46p-49"), pi)
+identical(fromHex("0xc90fdaa22168cp-50"), pi)
+identical(fromHex("0x1921fb54442d18p-51"), pi)
+identical(fromHex("0x3243f6a8885a30p-52"), pi)
+identical(fromHex("0x6487ed5110b460p-53"), pi)
+identical(fromHex("0xc90fdaa22168c0p-54"), pi)
+identical(fromHex("0x1921fb54442d180p-55"), pi)
 
-assert (0.0).hex() == '0x0.0p+0'
-assert (-0.0).hex() == '-0x0.0p+0'
-assert (1.0).hex() == '0x1.0000000000000p+0'
-assert (-1.5).hex() == '-0x1.8000000000000p+0'
-assert float('inf').hex() == 'inf'
-assert float('-inf').hex() == '-inf'
-assert float('nan').hex() == 'nan'
+assert (0.0).hex() == "0x0.0p+0"
+assert (-0.0).hex() == "-0x0.0p+0"
+assert (1.0).hex() == "0x1.0000000000000p+0"
+assert (-1.5).hex() == "-0x1.8000000000000p+0"
+assert float("inf").hex() == "inf"
+assert float("-inf").hex() == "-inf"
+assert float("nan").hex() == "nan"
 
 assert float(math.nan) is float(math.nan)
 
 # Test float exponent:
-assert 1 if 1else 0 == 1
+assert 1 if 1 else 0 == 1
 
-a = 3.
+a = 3.0
 assert a.__eq__(3) is True
-assert a.__eq__(3.) is True
+assert a.__eq__(3.0) is True
 assert a.__eq__(3.00000) is True
 assert a.__eq__(3.01) is False
 
@@ -458,26 +458,26 @@ assert pi.__eq__(3.14) is True
 assert pi.__ne__(3.14) is False
 assert pi.__eq__(3) is False
 assert pi.__ne__(3) is True
-assert pi.__eq__('pi') is NotImplemented
-assert pi.__ne__('pi') is NotImplemented
+assert pi.__eq__("pi") is NotImplemented
+assert pi.__ne__("pi") is NotImplemented
 
-assert pi.__eq__(float('inf')) is False
-assert pi.__ne__(float('inf')) is True
-assert float('inf').__eq__(pi) is False
-assert float('inf').__ne__(pi) is True
-assert float('inf').__eq__(float('inf')) is True
-assert float('inf').__ne__(float('inf')) is False
-assert float('inf').__eq__(float('nan')) is False
-assert float('inf').__ne__(float('nan')) is True
+assert pi.__eq__(float("inf")) is False
+assert pi.__ne__(float("inf")) is True
+assert float("inf").__eq__(pi) is False
+assert float("inf").__ne__(pi) is True
+assert float("inf").__eq__(float("inf")) is True
+assert float("inf").__ne__(float("inf")) is False
+assert float("inf").__eq__(float("nan")) is False
+assert float("inf").__ne__(float("nan")) is True
 
-assert pi.__eq__(float('nan')) is False
-assert pi.__ne__(float('nan')) is True
-assert float('nan').__eq__(pi) is False
-assert float('nan').__ne__(pi) is True
-assert float('nan').__eq__(float('nan')) is False
-assert float('nan').__ne__(float('nan')) is True
-assert float('nan').__eq__(float('inf')) is False
-assert float('nan').__ne__(float('inf')) is True
+assert pi.__eq__(float("nan")) is False
+assert pi.__ne__(float("nan")) is True
+assert float("nan").__eq__(pi) is False
+assert float("nan").__ne__(pi) is True
+assert float("nan").__eq__(float("nan")) is False
+assert float("nan").__ne__(float("nan")) is True
+assert float("nan").__eq__(float("inf")) is False
+assert float("nan").__ne__(float("inf")) is True
 
 assert float(1e15).__repr__() == "1000000000000000.0"
 assert float(1e16).__repr__() == "1e+16"
@@ -501,19 +501,19 @@ assert format(1e-4) == "0.0001"
 assert format(1.2345678901234567890) == "1.2345678901234567"
 assert format(1.2345678901234567890e308) == "1.2345678901234567e+308"
 
-assert float('0_0') == 0.0
-assert float('.0') == 0.0
-assert float('0.') == 0.0
-assert float('-.0') == 0.0
-assert float('+.0') == 0.0
+assert float("0_0") == 0.0
+assert float(".0") == 0.0
+assert float("0.") == 0.0
+assert float("-.0") == 0.0
+assert float("+.0") == 0.0
 
-assert_raises(ValueError, lambda: float('0._0'))
-assert_raises(ValueError, lambda: float('0_.0'))
-assert_raises(ValueError, lambda: float('._0'))
-assert_raises(ValueError, lambda: float('0_'))
-assert_raises(ValueError, lambda: float('0._'))
-assert_raises(ValueError, lambda: float('_.0'))
-assert_raises(ValueError, lambda: float('._0'))
+assert_raises(ValueError, lambda: float("0._0"))
+assert_raises(ValueError, lambda: float("0_.0"))
+assert_raises(ValueError, lambda: float("._0"))
+assert_raises(ValueError, lambda: float("0_"))
+assert_raises(ValueError, lambda: float("0._"))
+assert_raises(ValueError, lambda: float("_.0"))
+assert_raises(ValueError, lambda: float("._0"))
 
 assert 3.0 % -2.0 == -1.0
 assert -3.0 % 2.0 == 1.0
diff --git a/extra_tests/snippets/builtin_int.py b/extra_tests/snippets/builtin_int.py
index c79f57ef9..bc3cd5fd9 100644
--- a/extra_tests/snippets/builtin_int.py
+++ b/extra_tests/snippets/builtin_int.py
@@ -78,7 +78,7 @@ assert (10).denominator == 1
 assert (-10).numerator == -10
 assert (-10).denominator == 1
 
-assert_raises(OverflowError, lambda: 1 << 10 ** 100000)
+assert_raises(OverflowError, lambda: 1 << 10**100000)
 
 assert (1).__eq__(1.0) == NotImplemented
 assert (1).__ne__(1.0) == NotImplemented
@@ -110,34 +110,34 @@ assert int("101", 2) == 5
 assert int("101", base=2) == 5
 
 # implied base
-assert int('1', base=0) == 1
-assert int('123', base=0) == 123
-assert int('0b101', base=0) == 5
-assert int('0B101', base=0) == 5
-assert int('0o100', base=0) == 64
-assert int('0O100', base=0) == 64
-assert int('0xFF', base=0) == 255
-assert int('0XFF', base=0) == 255
+assert int("1", base=0) == 1
+assert int("123", base=0) == 123
+assert int("0b101", base=0) == 5
+assert int("0B101", base=0) == 5
+assert int("0o100", base=0) == 64
+assert int("0O100", base=0) == 64
+assert int("0xFF", base=0) == 255
+assert int("0XFF", base=0) == 255
 with assert_raises(ValueError):
-    int('0xFF', base=10)
+    int("0xFF", base=10)
 with assert_raises(ValueError):
-    int('0oFF', base=10)
+    int("0oFF", base=10)
 with assert_raises(ValueError):
-    int('0bFF', base=10)
+    int("0bFF", base=10)
 with assert_raises(ValueError):
-    int('0bFF', base=10)
+    int("0bFF", base=10)
 with assert_raises(ValueError):
     int(b"F\xc3\xb8\xc3\xb6\xbbB\xc3\xa5r")
 with assert_raises(ValueError):
     int(b"F\xc3\xb8\xc3\xb6\xbbB\xc3\xa5r")
 
 # string looks like radix
-assert int('0b1', base=12) == 133
-assert int('0o1', base=25) == 601
-assert int('0x1', base=34) == 1123
+assert int("0b1", base=12) == 133
+assert int("0o1", base=25) == 601
+assert int("0x1", base=34) == 1123
 
 # underscore
-assert int('0xFF_FF_FF', base=16) == 16_777_215
+assert int("0xFF_FF_FF", base=16) == 16_777_215
 with assert_raises(ValueError):
     int("_123_")
 with assert_raises(ValueError):
@@ -147,93 +147,105 @@ with assert_raises(ValueError):
 with assert_raises(ValueError):
     int("1__23")
 
-assert int('0x_10', base=0) == 16
+assert int("0x_10", base=0) == 16
 
 # signed
-assert int('-123') == -123
-assert int('+0b101', base=2) == +5
+assert int("-123") == -123
+assert int("+0b101", base=2) == +5
 
 # trailing spaces
-assert int(' 1') == 1
-assert int('1 ') == 1
-assert int(' 1 ') == 1
-assert int('10', base=0) == 10
+assert int(" 1") == 1
+assert int("1 ") == 1
+assert int(" 1 ") == 1
+assert int("10", base=0) == 10
 
 # type byte, signed, implied base
-assert int(b'     -0XFF ', base=0) == -255
+assert int(b"     -0XFF ", base=0) == -255
 
-assert int.from_bytes(b'\x00\x10', 'big') == 16
-assert int.from_bytes(b'\x00\x10', 'little') == 4096
-assert int.from_bytes(b'\x00\x10', byteorder='big') == 16
-assert int.from_bytes(b'\x00\x10', byteorder='little') == 4096
-assert int.from_bytes(bytes=b'\x00\x10', byteorder='big') == 16
-assert int.from_bytes(bytes=b'\x00\x10', byteorder='little') == 4096
+assert int.from_bytes(b"\x00\x10", "big") == 16
+assert int.from_bytes(b"\x00\x10", "little") == 4096
+assert int.from_bytes(b"\x00\x10", byteorder="big") == 16
+assert int.from_bytes(b"\x00\x10", byteorder="little") == 4096
+assert int.from_bytes(bytes=b"\x00\x10", byteorder="big") == 16
+assert int.from_bytes(bytes=b"\x00\x10", byteorder="little") == 4096
 
-assert int.from_bytes(b'\xfc\x00', 'big', signed=True) == -1024
-assert int.from_bytes(b'\xfc\x00', 'big', signed=False) == 64512
-assert int.from_bytes(b'\xfc\x00', byteorder='big', signed=True) == -1024
-assert int.from_bytes(b'\xfc\x00', byteorder='big', signed=False) == 64512
-assert int.from_bytes(bytes=b'\xfc\x00', byteorder='big', signed=True) == -1024
-assert int.from_bytes(bytes=b'\xfc\x00', byteorder='big', signed=False) == 64512
+assert int.from_bytes(b"\xfc\x00", "big", signed=True) == -1024
+assert int.from_bytes(b"\xfc\x00", "big", signed=False) == 64512
+assert int.from_bytes(b"\xfc\x00", byteorder="big", signed=True) == -1024
+assert int.from_bytes(b"\xfc\x00", byteorder="big", signed=False) == 64512
+assert int.from_bytes(bytes=b"\xfc\x00", byteorder="big", signed=True) == -1024
+assert int.from_bytes(bytes=b"\xfc\x00", byteorder="big", signed=False) == 64512
 
-assert int.from_bytes([255, 0, 0], 'big') == 16711680
-assert int.from_bytes([255, 0, 0], 'little') == 255
-assert int.from_bytes([255, 0, 0], 'big', signed=False) == 16711680
-assert int.from_bytes([255, 0, 0], 'big', signed=True) == -65536
+assert int.from_bytes([255, 0, 0], "big") == 16711680
+assert int.from_bytes([255, 0, 0], "little") == 255
+assert int.from_bytes([255, 0, 0], "big", signed=False) == 16711680
+assert int.from_bytes([255, 0, 0], "big", signed=True) == -65536
 
 with assert_raises(ValueError):
-    int.from_bytes(b'\x00\x10', 'something')
+    int.from_bytes(b"\x00\x10", "something")
 
 with assert_raises(ValueError):
-    int.from_bytes([256, 0, 0], 'big')
+    int.from_bytes([256, 0, 0], "big")
 
 with assert_raises(TypeError):
-    int.from_bytes(['something', 0, 0], 'big')
+    int.from_bytes(["something", 0, 0], "big")
 
-assert (1024).to_bytes(4, 'big') == b'\x00\x00\x04\x00'
-assert (1024).to_bytes(2, 'little') == b'\x00\x04'
-assert (1024).to_bytes(4, byteorder='big') == b'\x00\x00\x04\x00'
-assert (1024).to_bytes(2, byteorder='little') == b'\x00\x04'
-assert (1024).to_bytes(length=4, byteorder='big') == b'\x00\x00\x04\x00'
-assert (1024).to_bytes(length=2, byteorder='little') == b'\x00\x04'
+assert (1024).to_bytes(4, "big") == b"\x00\x00\x04\x00"
+assert (1024).to_bytes(2, "little") == b"\x00\x04"
+assert (1024).to_bytes(4, byteorder="big") == b"\x00\x00\x04\x00"
+assert (1024).to_bytes(2, byteorder="little") == b"\x00\x04"
+assert (1024).to_bytes(length=4, byteorder="big") == b"\x00\x00\x04\x00"
+assert (1024).to_bytes(length=2, byteorder="little") == b"\x00\x04"
 
-assert (-1024).to_bytes(4, 'big', signed=True) == b'\xff\xff\xfc\x00'
-assert (-1024).to_bytes(4, 'little', signed=True) == b'\x00\xfc\xff\xff'
+assert (-1024).to_bytes(4, "big", signed=True) == b"\xff\xff\xfc\x00"
+assert (-1024).to_bytes(4, "little", signed=True) == b"\x00\xfc\xff\xff"
 
-assert (2147483647).to_bytes(8, 'big', signed=False) == b'\x00\x00\x00\x00\x7f\xff\xff\xff'
-assert (-2147483648).to_bytes(8, 'little', signed=True) == b'\x00\x00\x00\x80\xff\xff\xff\xff'
-assert (2147483647).to_bytes(8, byteorder='big', signed=False) == b'\x00\x00\x00\x00\x7f\xff\xff\xff'
-assert (-2147483648).to_bytes(8, byteorder='little', signed=True) == b'\x00\x00\x00\x80\xff\xff\xff\xff'
-assert (2147483647).to_bytes(length=8, byteorder='big', signed=False) == b'\x00\x00\x00\x00\x7f\xff\xff\xff'
-assert (-2147483648).to_bytes(length=8, byteorder='little', signed=True) == b'\x00\x00\x00\x80\xff\xff\xff\xff'
+assert (2147483647).to_bytes(
+    8, "big", signed=False
+) == b"\x00\x00\x00\x00\x7f\xff\xff\xff"
+assert (-2147483648).to_bytes(
+    8, "little", signed=True
+) == b"\x00\x00\x00\x80\xff\xff\xff\xff"
+assert (2147483647).to_bytes(
+    8, byteorder="big", signed=False
+) == b"\x00\x00\x00\x00\x7f\xff\xff\xff"
+assert (-2147483648).to_bytes(
+    8, byteorder="little", signed=True
+) == b"\x00\x00\x00\x80\xff\xff\xff\xff"
+assert (2147483647).to_bytes(
+    length=8, byteorder="big", signed=False
+) == b"\x00\x00\x00\x00\x7f\xff\xff\xff"
+assert (-2147483648).to_bytes(
+    length=8, byteorder="little", signed=True
+) == b"\x00\x00\x00\x80\xff\xff\xff\xff"
 
 with assert_raises(ValueError):
-    (1024).to_bytes(4, 'something')
+    (1024).to_bytes(4, "something")
 
 with assert_raises(OverflowError):
-    (-1024).to_bytes(4, 'big')
+    (-1024).to_bytes(4, "big")
 
 with assert_raises(OverflowError):
-    (1024).to_bytes(10000000000000000000000, 'big')
+    (1024).to_bytes(10000000000000000000000, "big")
 
 with assert_raises(OverflowError):
-    (1024).to_bytes(1, 'big')
+    (1024).to_bytes(1, "big")
 
 with assert_raises(ValueError):
     # check base first
-    int(' 1 ', base=1)
+    int(" 1 ", base=1)
 
 with assert_raises(ValueError):
-    int(' 1 ', base=37)
+    int(" 1 ", base=37)
 
 with assert_raises(ValueError):
-    int(' 1 ', base=-1)
+    int(" 1 ", base=-1)
 
 with assert_raises(ValueError):
-    int(' 1 ', base=1000000000000000)
+    int(" 1 ", base=1000000000000000)
 
 with assert_raises(ValueError):
-    int(' 1 ', base=-1000000000000000)
+    int(" 1 ", base=-1000000000000000)
 
 with assert_raises(TypeError):
     int(base=2)
@@ -245,44 +257,56 @@ with assert_raises(TypeError):
     # check that first parameter is truly positional only
     int(val_options=1)
 
+
 class A(object):
     def __int__(self):
         return 10
 
+
 assert int(A()) == 10
 
+
 class B(object):
     pass
 
+
 b = B()
 b.__int__ = lambda: 20
 
 with assert_raises(TypeError):
     assert int(b) == 20
 
+
 class C(object):
     def __int__(self):
-        return 'str'
+        return "str"
+
 
 with assert_raises(TypeError):
     int(C())
 
+
 class I(int):
     def __int__(self):
         return 3
 
+
 assert int(I(1)) == 3
 
+
 class F(float):
     def __int__(self):
         return 3
 
+
 assert int(F(1.2)) == 3
 
+
 class BadInt(int):
     def __int__(self):
         return 42.0
 
+
 with assert_raises(TypeError):
     int(BadInt())
 
@@ -313,11 +337,12 @@ with assert_raises(SyntaxError):
 # Small int cache in [-5..256]
 assert 1 is 1  # noqa
 x = 6
-assert 5 is (x-1)  # noqa
+assert 5 is (x - 1)  # noqa
 
 
 # test issue3687
 import math
+
 big_int = 1000000
 small_int = 3
 assert big_int.real is big_int
@@ -331,8 +356,12 @@ assert math.trunc(small_int) is small_int
 assert math.floor(small_int) is small_int
 assert math.ceil(small_int) is small_int
 
+
 # test subclassing int
-class SubInt(int): pass
+class SubInt(int):
+    pass
+
+
 subint = int.__new__(SubInt, 11)
 assert subint.real is not subint
 assert type(subint.real) is int