tests: Format all Python code with black, except tests in basics subdir.

This adds the Python files in the tests/ directory to be formatted with
./tools/codeformat.py.  The basics/ subdirectory is excluded for now so we
aren't changing too much at once.

In a few places `# fmt: off`/`# fmt: on` was used where the code had
special formatting for readability or where the test was actually testing
the specific formatting.

27 files changed, 115 insertions, 44 deletions

diff --git a/tests/thread/mutate_bytearray.py b/tests/thread/mutate_bytearray.py
index f3276f1b2..67c01d91c 100644
--- a/tests/thread/mutate_bytearray.py
+++ b/tests/thread/mutate_bytearray.py
@@ -23,10 +23,11 @@ def th(n, lo, hi):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
-n_repeat = 4 # use 40 for more stressful test (uses more heap)
+n_repeat = 4  # use 40 for more stressful test (uses more heap)
 
 # spawn threads
 for i in range(n_thread):
@@ -42,4 +43,3 @@ count = [0 for _ in range(256)]
 for b in ba:
     count[b] += 1
 print(count)
-
diff --git a/tests/thread/mutate_dict.py b/tests/thread/mutate_dict.py
index c57d332d5..89c93f4ee 100644
--- a/tests/thread/mutate_dict.py
+++ b/tests/thread/mutate_dict.py
@@ -5,7 +5,7 @@
 import _thread
 
 # the shared dict
-di = {'a':'A', 'b':'B', 'c':'C', 'd':'D'}
+di = {"a": "A", "b": "B", "c": "C", "d": "D"}
 
 # main thread function
 def th(n, lo, hi):
@@ -26,6 +26,7 @@ def th(n, lo, hi):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
diff --git a/tests/thread/mutate_instance.py b/tests/thread/mutate_instance.py
index a1ae428b5..939a0b8ac 100644
--- a/tests/thread/mutate_instance.py
+++ b/tests/thread/mutate_instance.py
@@ -7,25 +7,28 @@ import _thread
 # the shared user class and instance
 class User:
     def __init__(self):
-        self.a = 'A'
-        self.b = 'B'
-        self.c = 'C'
+        self.a = "A"
+        self.b = "B"
+        self.c = "C"
+
+
 user = User()
 
 # main thread function
 def th(n, lo, hi):
     for repeat in range(n):
         for i in range(lo, hi):
-            setattr(user, 'attr_%u' % i, repeat + i)
-            assert getattr(user, 'attr_%u' % i) == repeat + i
+            setattr(user, "attr_%u" % i, repeat + i)
+            assert getattr(user, "attr_%u" % i) == repeat + i
 
     with lock:
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_repeat = 30
-n_range = 50 # 300 for stressful test (uses more heap)
+n_range = 50  # 300 for stressful test (uses more heap)
 n_thread = 4
 n_finished = 0
 
@@ -40,4 +43,4 @@ while n_finished < n_thread:
 # check user instance has correct contents
 print(user.a, user.b, user.c)
 for i in range(n_thread * n_range):
-    assert getattr(user, 'attr_%u' % i) == n_repeat - 1 + i
+    assert getattr(user, "attr_%u" % i) == n_repeat - 1 + i
diff --git a/tests/thread/mutate_list.py b/tests/thread/mutate_list.py
index 764a9bd99..c1849e672 100644
--- a/tests/thread/mutate_list.py
+++ b/tests/thread/mutate_list.py
@@ -27,6 +27,7 @@ def th(n, lo, hi):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
diff --git a/tests/thread/mutate_set.py b/tests/thread/mutate_set.py
index 5492d8631..924124611 100644
--- a/tests/thread/mutate_set.py
+++ b/tests/thread/mutate_set.py
@@ -21,6 +21,7 @@ def th(n, lo, hi):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
diff --git a/tests/thread/stress_aes.py b/tests/thread/stress_aes.py
index df75e616c..f73da557c 100644
--- a/tests/thread/stress_aes.py
+++ b/tests/thread/stress_aes.py
@@ -17,6 +17,7 @@
 # discrete arithmetic routines, mostly from a precomputed table
 
 # non-linear, invertible, substitution box
+# fmt: off
 aes_s_box_table = bytes((
     0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
     0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
@@ -35,31 +36,36 @@ aes_s_box_table = bytes((
     0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
     0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16,
 ))
+# fmt: on
 
 # multiplication of polynomials modulo x^8 + x^4 + x^3 + x + 1 = 0x11b
 def aes_gf8_mul_2(x):
     if x & 0x80:
-        return (x << 1) ^ 0x11b
+        return (x << 1) ^ 0x11B
     else:
         return x << 1
 
+
 def aes_gf8_mul_3(x):
     return x ^ aes_gf8_mul_2(x)
 
+
 # non-linear, invertible, substitution box
 def aes_s_box(a):
-    return aes_s_box_table[a & 0xff]
+    return aes_s_box_table[a & 0xFF]
+
 
 # return 0x02^(a-1) in GF(2^8)
 def aes_r_con(a):
     ans = 1
     while a > 1:
-        ans <<= 1;
+        ans <<= 1
         if ans & 0x100:
-            ans ^= 0x11b
+            ans ^= 0x11B
         a -= 1
     return ans
 
+
 ##################################################################
 # basic AES algorithm; see FIPS-197
 #
@@ -79,6 +85,7 @@ def aes_add_round_key(state, w):
     for i in range(16):
         state[i] ^= w[i]
 
+
 # combined sub_bytes, shift_rows, mix_columns, add_round_key
 # all inputs must be size 16
 def aes_sb_sr_mc_ark(state, w, w_idx, temp):
@@ -88,7 +95,7 @@ def aes_sb_sr_mc_ark(state, w, w_idx, temp):
         x1 = aes_s_box_table[state[1 + ((i + 1) & 3) * 4]]
         x2 = aes_s_box_table[state[2 + ((i + 2) & 3) * 4]]
         x3 = aes_s_box_table[state[3 + ((i + 3) & 3) * 4]]
-        temp[temp_idx]     = aes_gf8_mul_2(x0) ^ aes_gf8_mul_3(x1) ^ x2 ^ x3 ^ w[w_idx]
+        temp[temp_idx] = aes_gf8_mul_2(x0) ^ aes_gf8_mul_3(x1) ^ x2 ^ x3 ^ w[w_idx]
         temp[temp_idx + 1] = x0 ^ aes_gf8_mul_2(x1) ^ aes_gf8_mul_3(x2) ^ x3 ^ w[w_idx + 1]
         temp[temp_idx + 2] = x0 ^ x1 ^ aes_gf8_mul_2(x2) ^ aes_gf8_mul_3(x3) ^ w[w_idx + 2]
         temp[temp_idx + 3] = aes_gf8_mul_3(x0) ^ x1 ^ x2 ^ aes_gf8_mul_2(x3) ^ w[w_idx + 3]
@@ -97,6 +104,7 @@ def aes_sb_sr_mc_ark(state, w, w_idx, temp):
     for i in range(16):
         state[i] = temp[i]
 
+
 # combined sub_bytes, shift_rows, add_round_key
 # all inputs must be size 16
 def aes_sb_sr_ark(state, w, w_idx, temp):
@@ -106,7 +114,7 @@ def aes_sb_sr_ark(state, w, w_idx, temp):
         x1 = aes_s_box_table[state[1 + ((i + 1) & 3) * 4]]
         x2 = aes_s_box_table[state[2 + ((i + 2) & 3) * 4]]
         x3 = aes_s_box_table[state[3 + ((i + 3) & 3) * 4]]
-        temp[temp_idx]     = x0 ^ w[w_idx]
+        temp[temp_idx] = x0 ^ w[w_idx]
         temp[temp_idx + 1] = x1 ^ w[w_idx + 1]
         temp[temp_idx + 2] = x2 ^ w[w_idx + 2]
         temp[temp_idx + 3] = x3 ^ w[w_idx + 3]
@@ -115,6 +123,7 @@ def aes_sb_sr_ark(state, w, w_idx, temp):
     for i in range(16):
         state[i] = temp[i]
 
+
 # take state as input and change it to the next state in the sequence
 # state and temp have size 16, w has size 16 * (Nr + 1), Nr >= 1
 def aes_state(state, w, temp, nr):
@@ -125,6 +134,7 @@ def aes_state(state, w, temp, nr):
         w_idx += 16
     aes_sb_sr_ark(state, w, w_idx, temp)
 
+
 # expand 'key' to 'w' for use with aes_state
 # key has size 4 * Nk, w has size 16 * (Nr + 1), temp has size 16
 def aes_key_expansion(key, w, temp, nk, nr):
@@ -148,9 +158,11 @@ def aes_key_expansion(key, w, temp, nk, nr):
         for j in range(4):
             w[w_idx + j] = w[w_idx + j - 4 * nk] ^ t[t_idx + j]
 
+
 ##################################################################
 # simple use of AES algorithm, using output feedback (OFB) mode
 
+
 class AES:
     def __init__(self, keysize):
         if keysize == 128:
@@ -176,7 +188,7 @@ class AES:
     def set_iv(self, iv):
         for i in range(16):
             self.state[i] = iv[i]
-        self.state_pos = 16;
+        self.state_pos = 16
 
     def get_some_state(self, n_needed):
         if self.state_pos >= 16:
@@ -198,6 +210,7 @@ class AES:
             idx += ln
             self.state_pos += n
 
+
 ##################################################################
 # test code
 
@@ -207,6 +220,7 @@ except ImportError:
     import time
 import _thread
 
+
 class LockedCounter:
     def __init__(self):
         self.lock = _thread.allocate_lock()
@@ -217,8 +231,10 @@ class LockedCounter:
         self.value += val
         self.lock.release()
 
+
 count = LockedCounter()
 
+
 def thread_entry():
     global count
 
@@ -247,7 +263,8 @@ def thread_entry():
 
     count.add(1)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     n_thread = 20
     for i in range(n_thread):
         _thread.start_new_thread(thread_entry, ())
diff --git a/tests/thread/stress_create.py b/tests/thread/stress_create.py
index 2399746cc..eda768fa7 100644
--- a/tests/thread/stress_create.py
+++ b/tests/thread/stress_create.py
@@ -6,9 +6,11 @@ except ImportError:
     import time
 import _thread
 
+
 def thread_entry(n):
     pass
 
+
 thread_num = 0
 while thread_num < 500:
     try:
@@ -19,4 +21,4 @@ while thread_num < 500:
 
 # wait for the last threads to terminate
 time.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/stress_heap.py b/tests/thread/stress_heap.py
index 5482a9ac6..2ad91ae14 100644
--- a/tests/thread/stress_heap.py
+++ b/tests/thread/stress_heap.py
@@ -9,9 +9,11 @@ except ImportError:
     import time
 import _thread
 
+
 def last(l):
     return l[-1]
 
+
 def thread_entry(n):
     # allocate a bytearray and fill it
     data = bytearray(i for i in range(256))
@@ -33,6 +35,7 @@ def thread_entry(n):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 10
 n_finished = 0
diff --git a/tests/thread/stress_recurse.py b/tests/thread/stress_recurse.py
index 68367c4dd..73b3a40f3 100644
--- a/tests/thread/stress_recurse.py
+++ b/tests/thread/stress_recurse.py
@@ -4,17 +4,20 @@
 
 import _thread
 
+
 def foo():
     foo()
 
+
 def thread_entry():
     try:
         foo()
     except RuntimeError:
-        print('RuntimeError')
+        print("RuntimeError")
     global finished
     finished = True
 
+
 finished = False
 
 _thread.start_new_thread(thread_entry, ())
@@ -22,4 +25,4 @@ _thread.start_new_thread(thread_entry, ())
 # busy wait for thread to finish
 while not finished:
     pass
-print('done')
+print("done")
diff --git a/tests/thread/thread_exc1.py b/tests/thread/thread_exc1.py
index 10fb94b4f..16483d777 100644
--- a/tests/thread/thread_exc1.py
+++ b/tests/thread/thread_exc1.py
@@ -4,9 +4,11 @@
 
 import _thread
 
+
 def foo():
     raise ValueError
 
+
 def thread_entry():
     try:
         foo()
@@ -16,6 +18,7 @@ def thread_entry():
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
@@ -27,4 +30,4 @@ for i in range(n_thread):
 # busy wait for threads to finish
 while n_finished < n_thread:
     pass
-print('done')
+print("done")
diff --git a/tests/thread/thread_exc2.py b/tests/thread/thread_exc2.py
index 35cb32441..2863e1dec 100644
--- a/tests/thread/thread_exc2.py
+++ b/tests/thread/thread_exc2.py
@@ -2,9 +2,11 @@
 import utime
 import _thread
 
+
 def thread_entry():
     raise ValueError
 
+
 _thread.start_new_thread(thread_entry, ())
 utime.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/thread_exc2.py.exp b/tests/thread/thread_exc2.py.exp
index cc7a20aa2..469516dac 100644
--- a/tests/thread/thread_exc2.py.exp
+++ b/tests/thread/thread_exc2.py.exp
@@ -1,5 +1,5 @@
 Unhandled exception in thread started by <function thread_entry at 0x\[0-9a-f\]\+>
 Traceback (most recent call last):
-  File \.\+, line 6, in thread_entry
+  File \.\+, line 7, in thread_entry
 ValueError: 
 done
diff --git a/tests/thread/thread_exit1.py b/tests/thread/thread_exit1.py
index 88cdd165c..c4a93c45a 100644
--- a/tests/thread/thread_exit1.py
+++ b/tests/thread/thread_exit1.py
@@ -8,12 +8,14 @@ except ImportError:
     import time
 import _thread
 
+
 def thread_entry():
     _thread.exit()
 
+
 _thread.start_new_thread(thread_entry, ())
 _thread.start_new_thread(thread_entry, ())
 
 # wait for threads to finish
 time.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/thread_exit2.py b/tests/thread/thread_exit2.py
index 368a11bba..0cd80e690 100644
--- a/tests/thread/thread_exit2.py
+++ b/tests/thread/thread_exit2.py
@@ -8,12 +8,14 @@ except ImportError:
     import time
 import _thread
 
+
 def thread_entry():
     raise SystemExit
 
+
 _thread.start_new_thread(thread_entry, ())
 _thread.start_new_thread(thread_entry, ())
 
 # wait for threads to finish
 time.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/thread_gc1.py b/tests/thread/thread_gc1.py
index 8dcbf7e07..dd1e64d89 100644
--- a/tests/thread/thread_gc1.py
+++ b/tests/thread/thread_gc1.py
@@ -5,6 +5,7 @@
 import gc
 import _thread
 
+
 def thread_entry(n):
     # allocate a bytearray and fill it
     data = bytearray(i for i in range(256))
@@ -21,6 +22,7 @@ def thread_entry(n):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
diff --git a/tests/thread/thread_ident1.py b/tests/thread/thread_ident1.py
index 217fce73b..390193acc 100644
--- a/tests/thread/thread_ident1.py
+++ b/tests/thread/thread_ident1.py
@@ -4,18 +4,20 @@
 
 import _thread
 
+
 def thread_entry():
     tid = _thread.get_ident()
-    print('thread', type(tid) == int, tid != 0, tid != tid_main)
+    print("thread", type(tid) == int, tid != 0, tid != tid_main)
     global finished
     finished = True
 
+
 tid_main = _thread.get_ident()
-print('main', type(tid_main) == int, tid_main != 0)
+print("main", type(tid_main) == int, tid_main != 0)
 
 finished = False
 _thread.start_new_thread(thread_entry, ())
 
 while not finished:
     pass
-print('done')
+print("done")
diff --git a/tests/thread/thread_lock1.py b/tests/thread/thread_lock1.py
index ba5c7dff0..342c554f4 100644
--- a/tests/thread/thread_lock1.py
+++ b/tests/thread/thread_lock1.py
@@ -36,11 +36,11 @@ try:
         print(lock.locked())
         raise KeyError
 except KeyError:
-    print('KeyError')
+    print("KeyError")
     print(lock.locked())
 
 # test that we can't release an unlocked lock
 try:
     lock.release()
 except RuntimeError:
-    print('RuntimeError')
+    print("RuntimeError")
diff --git a/tests/thread/thread_lock2.py b/tests/thread/thread_lock2.py
index 405f10b0b..b842f69c9 100644
--- a/tests/thread/thread_lock2.py
+++ b/tests/thread/thread_lock2.py
@@ -10,15 +10,17 @@ import _thread
 
 lock = _thread.allocate_lock()
 
+
 def thread_entry():
     lock.acquire()
-    print('have it')
+    print("have it")
     lock.release()
 
+
 # spawn the threads
 for i in range(4):
     _thread.start_new_thread(thread_entry, ())
 
 # wait for threads to finish
 time.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/thread_lock3.py b/tests/thread/thread_lock3.py
index 607898dad..a927dc682 100644
--- a/tests/thread/thread_lock3.py
+++ b/tests/thread/thread_lock3.py
@@ -8,16 +8,18 @@ lock = _thread.allocate_lock()
 n_thread = 10
 n_finished = 0
 
+
 def thread_entry(idx):
     global n_finished
     while True:
         with lock:
             if n_finished == idx:
                 break
-    print('my turn:', idx)
+    print("my turn:", idx)
     with lock:
         n_finished += 1
 
+
 # spawn threads
 for i in range(n_thread):
     _thread.start_new_thread(thread_entry, (i,))
diff --git a/tests/thread/thread_lock4.py b/tests/thread/thread_lock4.py
index 2f9d42d6b..bbf904399 100644
--- a/tests/thread/thread_lock4.py
+++ b/tests/thread/thread_lock4.py
@@ -8,12 +8,14 @@ except ImportError:
     import time
 import _thread
 
+
 def fac(n):
     x = 1
     for i in range(1, n + 1):
         x *= i
     return x
 
+
 def thread_entry():
     while True:
         with jobs_lock:
@@ -25,6 +27,7 @@ def thread_entry():
         with output_lock:
             output.append((arg, ans))
 
+
 # create a list of jobs
 jobs = [(fac, i) for i in range(20, 80)]
 jobs_lock = _thread.allocate_lock()
diff --git a/tests/thread/thread_qstr1.py b/tests/thread/thread_qstr1.py
index f4136d964..40ee2910c 100644
--- a/tests/thread/thread_qstr1.py
+++ b/tests/thread/thread_qstr1.py
@@ -13,6 +13,7 @@ def check(s, val):
     assert type(s) == str
     assert int(s) == val
 
+
 # main thread function
 def th(base, n):
     for i in range(n):
@@ -23,10 +24,11 @@ def th(base, n):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
-n_qstr_per_thread = 100 # make 1000 for a more stressful test (uses more heap)
+n_qstr_per_thread = 100  # make 1000 for a more stressful test (uses more heap)
 
 # spawn threads
 for i in range(n_thread):
@@ -36,4 +38,4 @@ for i in range(n_thread):
 while n_finished < n_thread:
     time.sleep(1)
 
-print('pass')
+print("pass")
diff --git a/tests/thread/thread_shared1.py b/tests/thread/thread_shared1.py
index 13c6651cc..582b01fc3 100644
--- a/tests/thread/thread_shared1.py
+++ b/tests/thread/thread_shared1.py
@@ -4,9 +4,11 @@
 
 import _thread
 
+
 def foo(i):
     pass
 
+
 def thread_entry(n, tup):
     for i in tup:
         foo(i)
@@ -14,6 +16,7 @@ def thread_entry(n, tup):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 2
 n_finished = 0
diff --git a/tests/thread/thread_shared2.py b/tests/thread/thread_shared2.py
index e4bfe7802..a1223c2b9 100644
--- a/tests/thread/thread_shared2.py
+++ b/tests/thread/thread_shared2.py
@@ -5,9 +5,11 @@
 
 import _thread
 
+
 def foo(lst, i):
     lst[i] += 1
 
+
 def thread_entry(n, lst, idx):
     for i in range(n):
         foo(lst, idx)
@@ -15,6 +17,7 @@ def thread_entry(n, lst, idx):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 2
 n_finished = 0
diff --git a/tests/thread/thread_sleep1.py b/tests/thread/thread_sleep1.py
index 032ec1754..18fa4e05a 100644
--- a/tests/thread/thread_sleep1.py
+++ b/tests/thread/thread_sleep1.py
@@ -4,9 +4,11 @@
 
 try:
     import utime
+
     sleep_ms = utime.sleep_ms
 except ImportError:
     import time
+
     sleep_ms = lambda t: time.sleep(t / 1000)
 
 import _thread
@@ -15,6 +17,7 @@ lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
 
+
 def thread_entry(t):
     global n_finished
     sleep_ms(t)
@@ -22,10 +25,11 @@ def thread_entry(t):
     with lock:
         n_finished += 1
 
+
 for i in range(n_thread):
     _thread.start_new_thread(thread_entry, (10 * i,))
 
 # wait for threads to finish
 while n_finished < n_thread:
     sleep_ms(100)
-print('done', n_thread)
+print("done", n_thread)
diff --git a/tests/thread/thread_stacksize1.py b/tests/thread/thread_stacksize1.py
index 62b6e5e40..39fe235b2 100644
--- a/tests/thread/thread_stacksize1.py
+++ b/tests/thread/thread_stacksize1.py
@@ -6,20 +6,23 @@ import sys
 import _thread
 
 # different implementations have different minimum sizes
-if sys.implementation.name == 'micropython':
+if sys.implementation.name == "micropython":
     sz = 2 * 1024
 else:
     sz = 32 * 1024
 
+
 def foo():
     pass
 
+
 def thread_entry():
     foo()
     with lock:
         global n_finished
         n_finished += 1
 
+
 # reset stack size to default
 _thread.stack_size()
 
@@ -44,4 +47,4 @@ _thread.stack_size()
 # busy wait for threads to finish
 while n_finished < n_thread:
     pass
-print('done')
+print("done")
diff --git a/tests/thread/thread_start1.py b/tests/thread/thread_start1.py
index d23a74aa2..f0e696840 100644
--- a/tests/thread/thread_start1.py
+++ b/tests/thread/thread_start1.py
@@ -8,16 +8,19 @@ except ImportError:
     import time
 import _thread
 
+
 def foo():
     pass
 
+
 def thread_entry(n):
     for i in range(n):
         foo()
 
+
 _thread.start_new_thread(thread_entry, (10,))
 _thread.start_new_thread(thread_entry, (20,))
 
 # wait for threads to finish
 time.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/thread_start2.py b/tests/thread/thread_start2.py
index d0913e37c..d68ea9432 100644
--- a/tests/thread/thread_start2.py
+++ b/tests/thread/thread_start2.py
@@ -8,11 +8,13 @@ except ImportError:
     import time
 import _thread
 
+
 def thread_entry(a0, a1, a2, a3):
-    print('thread', a0, a1, a2, a3)
+    print("thread", a0, a1, a2, a3)
+
 
 # spawn thread using kw args
-_thread.start_new_thread(thread_entry, (10, 20), {'a2': 0, 'a3': 1})
+_thread.start_new_thread(thread_entry, (10, 20), {"a2": 0, "a3": 1})
 
 # wait for thread to finish
 time.sleep(1)
@@ -21,6 +23,6 @@ time.sleep(1)
 try:
     _thread.start_new_thread(thread_entry, (), ())
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
-print('done')
+print("done")