From 75c0d70236d8d3513818e356d0513b2fc8f1b306 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Sat, 14 Dec 2024 18:07:45 +0100
Subject: [PATCH] tool.ruff.format.exclude = ["test/test_browser.py"]

---
 pyproject.toml       |    4 +-
 test/test_browser.py | 4254 ++++++++++++------------------------------
 2 files changed, 1237 insertions(+), 3021 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index e91ded85fa2ca..825e5e34451ce 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -11,7 +11,9 @@ exclude = [
   "./tools/scons/",
   ".git",
 ]
-
+format.exclude = [
+  "./test/test_browser.py",
+]
 format.quote-style = "preserve"
 indent-width = 2
 line-length = 120
diff --git a/test/test_browser.py b/test/test_browser.py
index d6f423a2b30c1..04d3353faf1bc 100644
--- a/test/test_browser.py
+++ b/test/test_browser.py
@@ -69,7 +69,7 @@ def do_GET(s):
         end = min(len(data) - 1, end)
         length = end - start + 1
         s.sendheaders([], length)
-        s.wfile.write(data[start : end + 1])
+        s.wfile.write(data[start:end + 1])
 
   # CORS preflight makes OPTIONS requests which we need to account for.
   expectedConns = 22
@@ -92,7 +92,8 @@ def metafunc(self, wasmfs, *args, **kwargs):
     else:
       f(self, *args, **kwargs)
 
-  parameterize(metafunc, {'': (False,), 'wasmfs': (True,)})
+  parameterize(metafunc, {'': (False,),
+                          'wasmfs': (True,)})
 
   return metafunc
 
@@ -107,7 +108,8 @@ def metafunc(self, proxied, *args, **kwargs):
     self.proxied = proxied
     f(self, *args, **kwargs)
 
-  parameterize(metafunc, {'': (False,), 'proxied': (True,)})
+  parameterize(metafunc, {'': (False,),
+                          'proxied': (True,)})
   return metafunc
 
 
@@ -139,9 +141,7 @@ def decorator(f):
     def decorated(self, *args, **kwargs):
       self.set_setting('WASMFS', 0)
       f(self, *args, **kwargs)
-
     return decorated
-
   return decorator
 
 
@@ -198,7 +198,8 @@ def decorated(self, threads, *args, **kwargs):
       self.emcc_args += ['-pthread']
     f(self, *args, **kwargs)
 
-  parameterize(decorated, {'': (False,), 'pthreads': (True,)})
+  parameterize(decorated, {'': (False,),
+                           'pthreads': (True,)})
 
   return decorated
 
@@ -218,14 +219,10 @@ def decorated(self, *args, **kwargs):
   return decorator
 
 
-requires_graphics_hardware = skipExecIf(
-  os.getenv('EMTEST_LACKS_GRAPHICS_HARDWARE'), 'This test requires graphics hardware'
-)
+requires_graphics_hardware = skipExecIf(os.getenv('EMTEST_LACKS_GRAPHICS_HARDWARE'), 'This test requires graphics hardware')
 requires_webgpu = unittest.skipIf(os.getenv('EMTEST_LACKS_WEBGPU'), "This test requires WebGPU to be available")
 requires_sound_hardware = skipExecIf(os.getenv('EMTEST_LACKS_SOUND_HARDWARE'), 'This test requires sound hardware')
-requires_offscreen_canvas = skipExecIf(
-  os.getenv('EMTEST_LACKS_OFFSCREEN_CANVAS'), 'This test requires a browser with OffscreenCanvas'
-)
+requires_offscreen_canvas = skipExecIf(os.getenv('EMTEST_LACKS_OFFSCREEN_CANVAS'), 'This test requires a browser with OffscreenCanvas')
 
 
 class browser(BrowserCore):
@@ -248,18 +245,14 @@ def setUp(self):
 
   def require_jspi(self):
     if not is_chrome():
-      self.skipTest(
-        f'Current browser ({EMTEST_BROWSER}) does not support JSPI. Only chromium-based browsers ({CHROMIUM_BASED_BROWSERS}) support JSPI today.'
-      )
+      self.skipTest(f'Current browser ({EMTEST_BROWSER}) does not support JSPI. Only chromium-based browsers ({CHROMIUM_BASED_BROWSERS}) support JSPI today.')
     super(browser, self).require_jspi()
 
   def post_manual_reftest(self):
     assert os.path.exists('reftest.js')
     shutil.copy(test_file('browser_reporting.js'), '.')
     html = read_file('test.html')
-    html = html.replace(
-      '</body>',
-      '''
+    html = html.replace('</body>', '''
 <script src="browser_reporting.js"></script>
 <script src="reftest.js"></script>
 <script>
@@ -272,24 +265,20 @@ def post_manual_reftest(self):
   }, 1000);
 };
 </script>
-</body>''',
-    )
+</body>''')
     create_file('test.html', html)
 
   def make_reftest(self, expected):
     # make sure the pngs used here have no color correction, using e.g.
     #   pngcrush -rem gAMA -rem cHRM -rem iCCP -rem sRGB infile outfile
     shutil.copy(expected, 'expected.png')
-    create_file(
-      'reftest.js',
-      f'''
+    create_file('reftest.js', f'''
       const reftestRebaseline = {common.EMTEST_REBASELINE};
-    '''
-      + read_file(test_file('reftest.js')),
-    )
+    ''' + read_file(test_file('reftest.js')))
 
   def reftest(self, filename, reference, reference_slack=0, *args, **kwargs):
-    """Special case of `btest` that uses reference image"""
+    """Special case of `btest` that uses reference image
+    """
     reference = find_browser_test_file(reference)
     assert 'expected' not in kwargs
     expected = [str(i) for i in range(0, reference_slack + 1)]
@@ -319,7 +308,7 @@ def test_sdl1_in_emscripten_nonstrict_mode(self):
 
   def test_sdl1(self):
     self.reftest('hello_world_sdl.c', 'htmltest.png', args=['-lSDL', '-lGL'])
-    self.reftest('hello_world_sdl.c', 'htmltest.png', args=['-sUSE_SDL', '-lGL'])  # is the default anyhow
+    self.reftest('hello_world_sdl.c', 'htmltest.png', args=['-sUSE_SDL', '-lGL']) # is the default anyhow
 
   def test_sdl1_es6(self):
     self.reftest('hello_world_sdl.c', 'htmltest.png', args=['-sUSE_SDL', '-lGL', '-sEXPORT_ES6'])
@@ -335,9 +324,7 @@ def test_zzz_html_source_map(self):
     # multiple mapped lines. in other words, if the program consists of a
     # single 'throw' statement, browsers may just map any thrown exception to
     # that line, because it will be the only mapped line.
-    create_file(
-      'src.cpp',
-      r'''
+    create_file('src.cpp', r'''
       #include <cstdio>
 
       int main() {
@@ -348,8 +335,7 @@ def test_zzz_html_source_map(self):
         printf("done\n");
         return 0;
       }
-      ''',
-    )
+      ''')
     # use relative paths when calling emcc, because file:// URIs can only load
     # sourceContent when the maps are relative paths
     self.compile_btest('src.cpp', ['-o', 'src.html', '-gsource-map'])
@@ -366,10 +352,8 @@ def test_zzz_html_source_map(self):
 ''')
 
   def test_emscripten_log(self):
-    self.btest_exit(
-      'emscripten_log/emscripten_log.cpp',
-      args=['-Wno-deprecated-pragma', '--pre-js', path_from_root('src/emscripten-source-map.min.js'), '-gsource-map'],
-    )
+    self.btest_exit('emscripten_log/emscripten_log.cpp',
+                    args=['-Wno-deprecated-pragma', '--pre-js', path_from_root('src/emscripten-source-map.min.js'), '-gsource-map'])
 
   @also_with_wasmfs
   def test_preload_file(self):
@@ -381,13 +365,11 @@ def test_preload_file(self):
 
     def make_main(path):
       print('make main at', path)
-      path = path.replace('\\', '\\\\').replace('"', '\\"')  # Escape tricky path name for use inside a C string.
+      path = path.replace('\\', '\\\\').replace('"', '\\"') # Escape tricky path name for use inside a C string.
       # TODO: change this when wasmfs supports relative paths.
       if self.get_setting('WASMFS'):
         path = "/" + path
-      create_file(
-        'main.c',
-        r'''
+      create_file('main.c', r'''
         #include <assert.h>
         #include <stdio.h>
         #include <string.h>
@@ -403,9 +385,7 @@ def make_main(path):
           assert(strcmp("load me right before", buf) == 0);
           return 0;
         }
-        '''
-        % path,
-      )
+        ''' % path)
 
     test_cases = [
       # (source preload-file string, file on target FS to load)
@@ -424,8 +404,7 @@ def make_main(path):
       ("somefile.txt@/directory/file.txt", "directory/file.txt"),
       (absolute_src_path + "@/directory/file.txt", "directory/file.txt"),
       ("some@@file.txt@other.txt", "other.txt"),
-      ("some@@file.txt@some@@otherfile.txt", "some@otherfile.txt"),
-    ]
+      ("some@@file.txt@some@@otherfile.txt", "some@otherfile.txt")]
 
     for srcpath, dstpath in test_cases:
       print('Testing', srcpath, dstpath)
@@ -449,13 +428,13 @@ def make_main(path):
 
     # By absolute path
 
-    make_main('somefile.txt')  # absolute becomes relative
+    make_main('somefile.txt') # absolute becomes relative
     self.btest_exit('main.c', args=['--preload-file', absolute_src_path])
 
     # Test subdirectory handling with asset packaging.
     delete_dir('assets')
     ensure_dir('assets/sub/asset1')
-    ensure_dir('assets/sub/asset1/.git')  # Test adding directory that shouldn't exist.
+    ensure_dir('assets/sub/asset1/.git') # Test adding directory that shouldn't exist.
     ensure_dir('assets/sub/asset2')
     create_file('assets/sub/asset1/file1.txt', '''load me right before running the code please''')
     create_file('assets/sub/asset1/.git/shouldnt_be_embedded.txt', '''this file should not get embedded''')
@@ -463,9 +442,7 @@ def make_main(path):
     absolute_assets_src_path = 'assets'
 
     def make_main_two_files(path1, path2, nonexistingpath):
-      create_file(
-        'main.c',
-        r'''
+      create_file('main.c', r'''
         #include <stdio.h>
         #include <assert.h>
         #include <string.h>
@@ -489,40 +466,17 @@ def make_main_two_files(path1, path2, nonexistingpath):
 
           return 0;
         }
-      '''
-        % (path1, path2, nonexistingpath),
-      )
+      ''' % (path1, path2, nonexistingpath))
 
     test_cases = [
       # (source directory to embed, file1 on target FS to load, file2 on target FS to load, name of a file that *shouldn't* exist on VFS)
-      (
-        "assets",
-        "assets/sub/asset1/file1.txt",
-        "assets/sub/asset2/file2.txt",
-        "assets/sub/asset1/.git/shouldnt_be_embedded.txt",
-      ),
-      (
-        "assets/",
-        "assets/sub/asset1/file1.txt",
-        "assets/sub/asset2/file2.txt",
-        "assets/sub/asset1/.git/shouldnt_be_embedded.txt",
-      ),
+      ("assets", "assets/sub/asset1/file1.txt", "assets/sub/asset2/file2.txt", "assets/sub/asset1/.git/shouldnt_be_embedded.txt"),
+      ("assets/", "assets/sub/asset1/file1.txt", "assets/sub/asset2/file2.txt", "assets/sub/asset1/.git/shouldnt_be_embedded.txt"),
       ("assets@/", "/sub/asset1/file1.txt", "/sub/asset2/file2.txt", "/sub/asset1/.git/shouldnt_be_embedded.txt"),
       ("assets/@/", "/sub/asset1/file1.txt", "/sub/asset2/file2.txt", "/sub/asset1/.git/shouldnt_be_embedded.txt"),
       ("assets@./", "/sub/asset1/file1.txt", "/sub/asset2/file2.txt", "/sub/asset1/.git/shouldnt_be_embedded.txt"),
-      (
-        absolute_assets_src_path + "@/",
-        "/sub/asset1/file1.txt",
-        "/sub/asset2/file2.txt",
-        "/sub/asset1/.git/shouldnt_be_embedded.txt",
-      ),
-      (
-        absolute_assets_src_path + "@/assets",
-        "/assets/sub/asset1/file1.txt",
-        "/assets/sub/asset2/file2.txt",
-        "assets/sub/asset1/.git/shouldnt_be_embedded.txt",
-      ),
-    ]
+      (absolute_assets_src_path + "@/", "/sub/asset1/file1.txt", "/sub/asset2/file2.txt", "/sub/asset1/.git/shouldnt_be_embedded.txt"),
+      (absolute_assets_src_path + "@/assets", "/assets/sub/asset1/file1.txt", "/assets/sub/asset2/file2.txt", "assets/sub/asset1/.git/shouldnt_be_embedded.txt")]
 
     for test in test_cases:
       (srcpath, dstpath1, dstpath2, nonexistingpath) = test
@@ -532,39 +486,29 @@ def make_main_two_files(path1, path2, nonexistingpath):
 
     # Should still work with -o subdir/..
 
-    make_main('somefile.txt')  # absolute becomes relative
+    make_main('somefile.txt') # absolute becomes relative
     ensure_dir('dirrey')
-    self.compile_btest(
-      'main.c', ['--preload-file', absolute_src_path, '-o', 'dirrey/page.html'], reporting=Reporting.JS_ONLY
-    )
+    self.compile_btest('main.c', ['--preload-file', absolute_src_path, '-o', 'dirrey/page.html'], reporting=Reporting.JS_ONLY)
     self.run_browser('dirrey/page.html', '/report_result?exit:0')
 
     # With FS.preloadFile
 
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       // we need --use-preload-plugins for this.
       Module.preRun = () => FS.createPreloadedFile('/', 'someotherfile.txt', 'somefile.txt', true, false);
-    ''',
-    )
+    ''')
     make_main('someotherfile.txt')
     self.btest_exit('main.c', args=['--pre-js', 'pre.js', '--use-preload-plugins'])
 
   # Tests that user .html shell files can manually download .data files created with --preload-file cmdline.
-  @parameterized(
-    {
-      '': ([],),
-      'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME'],),
+  })
   def test_preload_file_with_manual_data_download(self, args):
     create_file('file.txt', 'Hello!')
 
-    self.compile_btest(
-      'browser/test_manual_download_data.c',
-      ['-sEXIT_RUNTIME', '-o', 'out.js', '--preload-file', 'file.txt@/file.txt'] + args,
-    )
+    self.compile_btest('browser/test_manual_download_data.c', ['-sEXIT_RUNTIME', '-o', 'out.js', '--preload-file', 'file.txt@/file.txt'] + args)
     shutil.copy(test_file('browser/test_manual_download_data.html'), '.')
 
     # Move .data file out of server root to ensure that getPreloadedPackage is actually used
@@ -578,9 +522,7 @@ def test_preload_file_with_manual_data_download(self, args):
   # correctly escaping the names.
   def test_output_file_escaping(self):
     self.set_setting('EXIT_RUNTIME')
-    tricky_part = (
-      '\'' if WINDOWS else '\' and "'
-    )  # On Windows, files/directories may not contain a double quote character. On non-Windowses they can, so test that.
+    tricky_part = '\'' if WINDOWS else '\' and \"' # On Windows, files/directories may not contain a double quote character. On non-Windowses they can, so test that.
 
     d = 'dir with ' + tricky_part
     abs_d = os.path.abspath(d)
@@ -589,9 +531,7 @@ def test_output_file_escaping(self):
     create_file(os.path.join(d, txt), 'load me right before')
 
     src = os.path.join(d, 'file with ' + tricky_part + '.c')
-    create_file(
-      src,
-      r'''
+    create_file(src, r'''
       #include <assert.h>
       #include <stdio.h>
       #include <string.h>
@@ -606,44 +546,26 @@ def test_output_file_escaping(self):
         assert(strcmp("load me right before", buf) == 0);
         return 0;
       }
-    '''
-      % (txt.replace('\'', '\\\'').replace('"', '\\"')),
-    )
+    ''' % (txt.replace('\'', '\\\'').replace('\"', '\\"')))
 
     data_file = os.path.join(abs_d, 'file with ' + tricky_part + '.data')
     data_js_file = os.path.join(abs_d, 'file with ' + tricky_part + '.js')
     abs_txt = os.path.join(abs_d, txt)
-    self.run_process(
-      [
-        FILE_PACKAGER,
-        data_file,
-        '--use-preload-cache',
-        '--indexedDB-name=testdb',
-        '--preload',
-        abs_txt + '@' + txt,
-        '--js-output=' + data_js_file,
-      ]
-    )
+    self.run_process([FILE_PACKAGER, data_file, '--use-preload-cache', '--indexedDB-name=testdb', '--preload', abs_txt + '@' + txt, '--js-output=' + data_js_file])
     page_file = os.path.join(d, 'file with ' + tricky_part + '.html')
     abs_page_file = os.path.abspath(page_file)
-    self.compile_btest(
-      src, ['--pre-js', data_js_file, '-o', abs_page_file, '-sFORCE_FILESYSTEM'], reporting=Reporting.JS_ONLY
-    )
+    self.compile_btest(src, ['--pre-js', data_js_file, '-o', abs_page_file, '-sFORCE_FILESYSTEM'], reporting=Reporting.JS_ONLY)
     self.run_browser(page_file, '/report_result?exit:0')
 
-  @parameterized(
-    {
-      '0': (0,),
-      '1mb': (1 * 1024 * 1024,),
-      '100mb': (100 * 1024 * 1024,),
-      '150mb': (150 * 1024 * 1024,),
-    }
-  )
+  @parameterized({
+    '0': (0,),
+    '1mb': (1 * 1024 * 1024,),
+    '100mb': (100 * 1024 * 1024,),
+    '150mb': (150 * 1024 * 1024,),
+  })
   def test_preload_caching(self, extra_size):
     self.set_setting('EXIT_RUNTIME')
-    create_file(
-      'main.c',
-      r'''
+    create_file('main.c', r'''
       #include <assert.h>
       #include <stdio.h>
       #include <string.h>
@@ -662,13 +584,9 @@ def test_preload_caching(self, extra_size):
         assert(strcmp("load me right before", buf) == 0);
         return checkPreloadResults();
       }
-    '''
-      % 'somefile.txt',
-    )
+    ''' % 'somefile.txt')
 
-    create_file(
-      'test.js',
-      '''
+    create_file('test.js', '''
       addToLibrary({
         checkPreloadResults: function() {
           var cached = 0;
@@ -681,8 +599,7 @@ def test_preload_caching(self, extra_size):
           return cached;
         }
       });
-    ''',
-    )
+    ''')
 
     # test caching of various sizes, including sizes higher than 128MB which is
     # chrome's limit on IndexedDB item sizes, see
@@ -692,20 +609,7 @@ def test_preload_caching(self, extra_size):
       self.skipTest('chrome bug')
     create_file('somefile.txt', '''load me right before running the code please''' + ('_' * extra_size))
     print('size:', os.path.getsize('somefile.txt'))
-    self.compile_btest(
-      'main.c',
-      [
-        '--use-preload-cache',
-        '--js-library',
-        'test.js',
-        '--preload-file',
-        'somefile.txt',
-        '-o',
-        'page.html',
-        '-sALLOW_MEMORY_GROWTH',
-      ],
-      reporting=Reporting.JS_ONLY,
-    )
+    self.compile_btest('main.c', ['--use-preload-cache', '--js-library', 'test.js', '--preload-file', 'somefile.txt', '-o', 'page.html', '-sALLOW_MEMORY_GROWTH'], reporting=Reporting.JS_ONLY)
     self.run_browser('page.html', '/report_result?exit:0')
     self.run_browser('page.html', '/report_result?exit:1')
 
@@ -715,9 +619,7 @@ def test_preload_caching_indexeddb_name(self):
 
     def make_main(path):
       print(path)
-      create_file(
-        'main.c',
-        r'''
+      create_file('main.c', r'''
         #include <assert.h>
         #include <stdio.h>
         #include <string.h>
@@ -738,13 +640,9 @@ def make_main(path):
           assert(strcmp("load me right before", buf) == 0);
           return checkPreloadResults();
         }
-      '''
-        % path,
-      )
+      ''' % path)
 
-    create_file(
-      'test.js',
-      '''
+    create_file('test.js', '''
       addToLibrary({
         checkPreloadResults: function() {
           var cached = 0;
@@ -757,26 +655,11 @@ def make_main(path):
           return cached;
         }
       });
-    ''',
-    )
+    ''')
 
     make_main('somefile.txt')
-    self.run_process(
-      [
-        FILE_PACKAGER,
-        'somefile.data',
-        '--use-preload-cache',
-        '--indexedDB-name=testdb',
-        '--preload',
-        'somefile.txt',
-        '--js-output=' + 'somefile.js',
-      ]
-    )
-    self.compile_btest(
-      'main.c',
-      ['--js-library', 'test.js', '--pre-js', 'somefile.js', '-o', 'page.html', '-sFORCE_FILESYSTEM'],
-      reporting=Reporting.JS_ONLY,
-    )
+    self.run_process([FILE_PACKAGER, 'somefile.data', '--use-preload-cache', '--indexedDB-name=testdb', '--preload', 'somefile.txt', '--js-output=' + 'somefile.js'])
+    self.compile_btest('main.c', ['--js-library', 'test.js', '--pre-js', 'somefile.js', '-o', 'page.html', '-sFORCE_FILESYSTEM'], reporting=Reporting.JS_ONLY)
     self.run_browser('page.html', '/report_result?exit:0')
     self.run_browser('page.html', '/report_result?exit:1')
 
@@ -785,9 +668,7 @@ def test_multifile(self):
     ensure_dir('subdirr/moar')
     create_file('subdirr/data1.txt', '1214141516171819')
     create_file('subdirr/moar/data2.txt', '3.14159265358979')
-    create_file(
-      'main.c',
-      r'''
+    create_file('main.c', r'''
       #include <assert.h>
       #include <stdio.h>
       #include <string.h>
@@ -811,8 +692,7 @@ def test_multifile(self):
 
         return 0;
       }
-    ''',
-    )
+    ''')
 
     # by individual files
     self.btest_exit('main.c', args=['--preload-file', 'subdirr/data1.txt', '--preload-file', 'subdirr/moar/data2.txt'])
@@ -832,11 +712,7 @@ def test_custom_file_package_url(self):
     # you would add this in your own custom html file etc., and not by
     # modifying the existing shell in this manner
     default_shell = read_file(path_from_root('src/shell.html'))
-    create_file(
-      'shell.html',
-      default_shell.replace(
-        'var Module = {',
-        '''
+    create_file('shell.html', default_shell.replace('var Module = {', '''
     var Module = {
       locateFile: function(path, prefix) {
         if (path.endsWith(".wasm")) {
@@ -845,12 +721,8 @@ def test_custom_file_package_url(self):
            return "cdn/" + path;
         }
       },
-    ''',
-      ),
-    )
-    create_file(
-      'main.c',
-      r'''
+    '''))
+    create_file('main.c', r'''
       #include <assert.h>
       #include <stdio.h>
       #include <string.h>
@@ -867,15 +739,10 @@ def test_custom_file_package_url(self):
 
         return 0;
       }
-    ''',
-    )
+    ''')
 
     self.set_setting('EXIT_RUNTIME')
-    self.compile_btest(
-      'main.c',
-      ['--shell-file', 'shell.html', '--preload-file', 'subdirr/data1.txt', '-o', 'test.html'],
-      reporting=Reporting.JS_ONLY,
-    )
+    self.compile_btest('main.c', ['--shell-file', 'shell.html', '--preload-file', 'subdirr/data1.txt', '-o', 'test.html'], reporting=Reporting.JS_ONLY)
     shutil.move('test.data', Path('cdn/test.data'))
     self.run_browser('test.html', '/report_result?exit:0')
 
@@ -883,9 +750,7 @@ def test_missing_data_throws_error(self):
     def setup(assetLocalization):
       self.clear()
       create_file('data.txt', 'data')
-      create_file(
-        'main.c',
-        r'''
+      create_file('main.c', r'''
         #include <stdio.h>
         #include <string.h>
         #include <emscripten.h>
@@ -893,11 +758,8 @@ def setup(assetLocalization):
           // This code should never be executed in terms of missing required dependency file.
           return 0;
         }
-      ''',
-      )
-      create_file(
-        'on_window_error_shell.html',
-        r'''
+      ''')
+      create_file('on_window_error_shell.html', r'''
       <html>
           <center><canvas id='canvas' width='256' height='256'></canvas></center>
           <hr><div id='output'></div><hr>
@@ -914,9 +776,7 @@ def setup(assetLocalization):
             window.addEventListener('error', handler);
             window.addEventListener('unhandledrejection', handler);
             var Module = {
-              locateFile: function (path, prefix) {if (path.endsWith(".wasm")) {return prefix + path;} else {return "'''
-        + assetLocalization
-        + r'''" + path;}},
+              locateFile: function (path, prefix) {if (path.endsWith(".wasm")) {return prefix + path;} else {return "''' + assetLocalization + r'''" + path;}},
               print: (function() {
                 var element = document.getElementById('output');
                 return function(text) { element.innerHTML += text.replace('\n', '<br>', 'g') + '<br>';};
@@ -926,30 +786,23 @@ def setup(assetLocalization):
           </script>
           {{{ SCRIPT }}}
         </body>
-      </html>''',
-      )
+      </html>''')
 
     def test():
       # test test missing file should run xhr.onload with status different than 200, 304 or 206
       setup("")
-      self.compile_btest(
-        'main.c', ['--shell-file', 'on_window_error_shell.html', '--preload-file', 'data.txt', '-o', 'test.html']
-      )
+      self.compile_btest('main.c', ['--shell-file', 'on_window_error_shell.html', '--preload-file', 'data.txt', '-o', 'test.html'])
       shutil.move('test.data', 'missing.data')
       self.run_browser('test.html', '/report_result?1')
 
       # test unknown protocol should go through xhr.onerror
       setup("unknown_protocol://")
-      self.compile_btest(
-        'main.c', ['--shell-file', 'on_window_error_shell.html', '--preload-file', 'data.txt', '-o', 'test.html']
-      )
+      self.compile_btest('main.c', ['--shell-file', 'on_window_error_shell.html', '--preload-file', 'data.txt', '-o', 'test.html'])
       self.run_browser('test.html', '/report_result?1')
 
       # test wrong protocol and port
       setup("https://localhost:8800/")
-      self.compile_btest(
-        'main.c', ['--shell-file', 'on_window_error_shell.html', '--preload-file', 'data.txt', '-o', 'test.html']
-      )
+      self.compile_btest('main.c', ['--shell-file', 'on_window_error_shell.html', '--preload-file', 'data.txt', '-o', 'test.html'])
       self.run_browser('test.html', '/report_result?1')
 
     test()
@@ -974,175 +827,105 @@ def test_sdl_image(self):
     # load an image file, get pixel data. Also O2 coverage for --preload-file
     shutil.copy(test_file('screenshot.jpg'), '.')
     src = test_file('browser/test_sdl_image.c')
-    for dest, dirname, basename in [
-      ('screenshot.jpg', '/', 'screenshot.jpg'),
-      ('screenshot.jpg@/assets/screenshot.jpg', '/assets', 'screenshot.jpg'),
-    ]:
-      self.btest_exit(
-        src,
-        args=[
-          '-O2',
-          '-lSDL',
-          '-lGL',
-          '--preload-file',
-          dest,
-          '-DSCREENSHOT_DIRNAME="' + dirname + '"',
-          '-DSCREENSHOT_BASENAME="' + basename + '"',
-          '--use-preload-plugins',
-        ],
-      )
+    for dest, dirname, basename in [('screenshot.jpg', '/', 'screenshot.jpg'),
+                                    ('screenshot.jpg@/assets/screenshot.jpg', '/assets', 'screenshot.jpg')]:
+      self.btest_exit(src, args=[
+        '-O2', '-lSDL', '-lGL',
+        '--preload-file', dest, '-DSCREENSHOT_DIRNAME="' + dirname + '"', '-DSCREENSHOT_BASENAME="' + basename + '"', '--use-preload-plugins'
+      ])
 
   @also_with_wasmfs
   def test_sdl_image_jpeg(self):
     shutil.copy(test_file('screenshot.jpg'), 'screenshot.jpeg')
-    self.btest_exit(
-      'test_sdl_image.c',
-      args=[
-        '--preload-file',
-        'screenshot.jpeg',
-        '-DSCREENSHOT_DIRNAME="/"',
-        '-DSCREENSHOT_BASENAME="screenshot.jpeg"',
-        '--use-preload-plugins',
-        '-lSDL',
-        '-lGL',
-      ],
-    )
+    self.btest_exit('test_sdl_image.c', args=[
+      '--preload-file', 'screenshot.jpeg',
+      '-DSCREENSHOT_DIRNAME="/"', '-DSCREENSHOT_BASENAME="screenshot.jpeg"', '--use-preload-plugins',
+      '-lSDL', '-lGL',
+    ])
 
   def test_sdl_image_webp(self):
     shutil.copy(test_file('screenshot.webp'), '.')
-    self.btest_exit(
-      'test_sdl_image.c',
-      args=[
-        '--preload-file',
-        'screenshot.webp',
-        '-DSCREENSHOT_DIRNAME="/"',
-        '-DSCREENSHOT_BASENAME="screenshot.webp"',
-        '--use-preload-plugins',
-        '-lSDL',
-        '-lGL',
-      ],
-    )
+    self.btest_exit('test_sdl_image.c', args=[
+      '--preload-file', 'screenshot.webp',
+      '-DSCREENSHOT_DIRNAME="/"', '-DSCREENSHOT_BASENAME="screenshot.webp"', '--use-preload-plugins',
+      '-lSDL', '-lGL',
+    ])
 
   @also_with_wasmfs
   @also_with_proxying
   def test_sdl_image_prepare(self):
     # load an image file, get pixel data.
     shutil.copy(test_file('screenshot.jpg'), 'screenshot.not')
-    self.reftest(
-      'test_sdl_image_prepare.c', 'screenshot.jpg', args=['--preload-file', 'screenshot.not', '-lSDL', '-lGL']
-    )
-
-  @parameterized(
-    {
-      '': ([],),
-      # add testing for closure on preloaded files + ENVIRONMENT=web (we must not
-      # emit any node.js code here, see
-      # https://github.com/emscripten-core/emscripten/issues/14486
-      'closure_webonly': (['--closure', '1', '-sENVIRONMENT=web'],),
-    }
-  )
+    self.reftest('test_sdl_image_prepare.c', 'screenshot.jpg', args=['--preload-file', 'screenshot.not', '-lSDL', '-lGL'])
+
+  @parameterized({
+    '': ([],),
+    # add testing for closure on preloaded files + ENVIRONMENT=web (we must not
+    # emit any node.js code here, see
+    # https://github.com/emscripten-core/emscripten/issues/14486
+    'closure_webonly': (['--closure', '1', '-sENVIRONMENT=web'],)
+  })
   def test_sdl_image_prepare_data(self, args):
     # load an image file, get pixel data.
     shutil.copy(test_file('screenshot.jpg'), 'screenshot.not')
-    self.reftest(
-      'test_sdl_image_prepare_data.c',
-      'screenshot.jpg',
-      args=['--preload-file', 'screenshot.not', '-lSDL', '-lGL'] + args,
-    )
+    self.reftest('test_sdl_image_prepare_data.c', 'screenshot.jpg', args=['--preload-file', 'screenshot.not', '-lSDL', '-lGL'] + args)
 
   def test_sdl_image_must_prepare(self):
     # load an image file, get pixel data.
     shutil.copy(test_file('screenshot.jpg'), 'screenshot.jpg')
-    self.reftest(
-      'test_sdl_image_must_prepare.c', 'screenshot.jpg', args=['--preload-file', 'screenshot.jpg', '-lSDL', '-lGL']
-    )
+    self.reftest('test_sdl_image_must_prepare.c', 'screenshot.jpg', args=['--preload-file', 'screenshot.jpg', '-lSDL', '-lGL'])
 
   def test_sdl_stb_image(self):
     # load an image file, get pixel data.
     shutil.copy(test_file('screenshot.jpg'), 'screenshot.not')
-    self.reftest(
-      'test_sdl_stb_image.c',
-      'screenshot.jpg',
-      args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_stb_image.c', 'screenshot.jpg', args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'])
 
   def test_sdl_stb_image_bpp(self):
     # load grayscale image without alpha
     shutil.copy(test_file('browser/test_sdl-stb-bpp1.png'), 'screenshot.not')
-    self.reftest(
-      'test_sdl_stb_image.c',
-      'test_sdl-stb-bpp1.png',
-      args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_stb_image.c', 'test_sdl-stb-bpp1.png', args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'])
 
     # load grayscale image with alpha
     self.clear()
     shutil.copy(test_file('browser/test_sdl-stb-bpp2.png'), 'screenshot.not')
-    self.reftest(
-      'test_sdl_stb_image.c',
-      'test_sdl-stb-bpp2.png',
-      args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_stb_image.c', 'test_sdl-stb-bpp2.png', args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'])
 
     # load RGB image
     self.clear()
     shutil.copy(test_file('browser/test_sdl-stb-bpp3.png'), 'screenshot.not')
-    self.reftest(
-      'test_sdl_stb_image.c',
-      'test_sdl-stb-bpp3.png',
-      args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_stb_image.c', 'test_sdl-stb-bpp3.png', args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'])
 
     # load RGBA image
     self.clear()
     shutil.copy(test_file('browser/test_sdl-stb-bpp4.png'), 'screenshot.not')
-    self.reftest(
-      'test_sdl_stb_image.c',
-      'test_sdl-stb-bpp4.png',
-      args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_stb_image.c', 'test_sdl-stb-bpp4.png', args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'])
 
   def test_sdl_stb_image_data(self):
     # load an image file, get pixel data.
     shutil.copy(test_file('screenshot.jpg'), 'screenshot.not')
-    self.reftest(
-      'test_sdl_stb_image_data.c',
-      'screenshot.jpg',
-      args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_stb_image_data.c', 'screenshot.jpg', args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL'])
 
   def test_sdl_stb_image_cleanup(self):
     shutil.copy(test_file('screenshot.jpg'), 'screenshot.not')
-    self.btest_exit(
-      'test_sdl_stb_image_cleanup.c',
-      args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL', '--memoryprofiler'],
-    )
-
-  @parameterized(
-    {
-      '': ([],),
-      'safe_heap': (['-sSAFE_HEAP'],),
-      'safe_heap_O2': (['-sSAFE_HEAP', '-O2'],),
-    }
-  )
+    self.btest_exit('test_sdl_stb_image_cleanup.c', args=['-sSTB_IMAGE', '--preload-file', 'screenshot.not', '-lSDL', '-lGL', '--memoryprofiler'])
+
+  @parameterized({
+    '': ([],),
+    'safe_heap': (['-sSAFE_HEAP'],),
+    'safe_heap_O2': (['-sSAFE_HEAP', '-O2'],),
+  })
   def test_sdl_canvas(self, args):
     self.btest_exit('test_sdl_canvas.c', args=['-sLEGACY_GL_EMULATION', '-lSDL', '-lGL'] + args)
 
   @proxied
   def test_sdl_canvas_proxy(self):
     create_file('data.txt', 'datum')
-    self.reftest(
-      'test_sdl_canvas_proxy.c',
-      'test_sdl_canvas_proxy.png',
-      args=['--proxy-to-worker', '--preload-file', 'data.txt', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_canvas_proxy.c', 'test_sdl_canvas_proxy.png', args=['--proxy-to-worker', '--preload-file', 'data.txt', '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_glgears_proxy_jstarget(self):
     # test .js target with --proxy-worker; emits 2 js files, client and worker
-    self.compile_btest(
-      'hello_world_gles_proxy.c', ['-o', 'test.js', '--proxy-to-worker', '-sGL_TESTING', '-lGL', '-lglut']
-    )
+    self.compile_btest('hello_world_gles_proxy.c', ['-o', 'test.js', '--proxy-to-worker', '-sGL_TESTING', '-lGL', '-lglut'])
     shell_with_script('shell_minimal.html', 'test.html', '<script src="test.js"></script>')
     self.make_reftest(test_file('gears.png'))
     self.post_manual_reftest()
@@ -1154,26 +937,20 @@ def test_sdl_canvas_alpha(self):
     create_file('flag_0.js', "Module['arguments'] = ['-0'];")
 
     self.reftest('test_sdl_canvas_alpha.c', 'test_sdl_canvas_alpha.png', args=['-lSDL', '-lGL'], reference_slack=12)
-    self.reftest(
-      'test_sdl_canvas_alpha.c',
-      'test_sdl_canvas_alpha_flag_0.png',
-      args=['--pre-js', 'flag_0.js', '-lSDL', '-lGL'],
-      reference_slack=12,
-    )
-
-  @parameterized(
-    {
-      '': ([],),
-      'eventhandler': (['-DTEST_EMSCRIPTEN_SDL_SETEVENTHANDLER'],),
-    }
-  )
-  @parameterized(
-    {
-      '': ([],),
-      'asyncify': (['-DTEST_SLEEP', '-sASSERTIONS', '-sSAFE_HEAP', '-sASYNCIFY'],),
-    }
-  )
-  @parameterized({'': (False,), 'delay': (True,)})
+    self.reftest('test_sdl_canvas_alpha.c', 'test_sdl_canvas_alpha_flag_0.png', args=['--pre-js', 'flag_0.js', '-lSDL', '-lGL'], reference_slack=12)
+
+  @parameterized({
+    '': ([],),
+    'eventhandler': (['-DTEST_EMSCRIPTEN_SDL_SETEVENTHANDLER'],),
+  })
+  @parameterized({
+    '': ([],),
+    'asyncify': (['-DTEST_SLEEP', '-sASSERTIONS', '-sSAFE_HEAP', '-sASYNCIFY'],),
+  })
+  @parameterized({
+    '': (False,),
+    'delay': (True,)
+  })
   def test_sdl_key(self, defines, async_, delay):
     if delay:
       settimeout_start = 'setTimeout(function() {'
@@ -1181,9 +958,7 @@ def test_sdl_key(self, defines, async_, delay):
     else:
       settimeout_start = ''
       settimeout_end = ''
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       function keydown(c) {
        %s
         simulateKeyDown(c);
@@ -1195,20 +970,12 @@ def test_sdl_key(self, defines, async_, delay):
         simulateKeyUp(c);
        %s
       }
-    '''
-      % (settimeout_start, settimeout_end, settimeout_start, settimeout_end),
-    )
-    self.btest_exit(
-      'test_sdl_key.c',
-      223092870,
-      args=defines + async_ + ['--pre-js', test_file('browser/fake_events.js'), '--pre-js=pre.js', '-lSDL', '-lGL'],
-    )
+    ''' % (settimeout_start, settimeout_end, settimeout_start, settimeout_end))
+    self.btest_exit('test_sdl_key.c', 223092870, args=defines + async_ + ['--pre-js', test_file('browser/fake_events.js'), '--pre-js=pre.js', '-lSDL', '-lGL'])
 
   def test_sdl_key_proxy(self):
     shutil.copy(test_file('browser/fake_events.js'), '.')
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       Module.postRun = () => {
         function doOne() {
           Module._one();
@@ -1216,14 +983,11 @@ def test_sdl_key_proxy(self):
         }
         setTimeout(doOne, 1000/60);
       }
-    ''',
-    )
+    ''')
 
     def post():
       html = read_file('test.html')
-      html = html.replace(
-        '</body>',
-        '''
+      html = html.replace('</body>', '''
 <script src='fake_events.js'></script>
 <script>
 simulateKeyDown(18);simulateKeyDown(38);simulateKeyUp(38);simulateKeyUp(18); // alt, up
@@ -1234,16 +998,10 @@ def post():
 simulateKeyDown(66);simulateKeyUp(66); // b
 simulateKeyDown(100);simulateKeyUp(100); // trigger the end
 </script>
-</body>''',
-      )
+</body>''')
       create_file('test.html', html)
 
-    self.btest_exit(
-      'test_sdl_key_proxy.c',
-      223092870,
-      args=['--proxy-to-worker', '--pre-js', 'pre.js', '-lSDL', '-lGL', '-sRUNTIME_DEBUG'],
-      post_build=post,
-    )
+    self.btest_exit('test_sdl_key_proxy.c', 223092870, args=['--proxy-to-worker', '--pre-js', 'pre.js', '-lSDL', '-lGL', '-sRUNTIME_DEBUG'], post_build=post)
 
   def test_canvas_focus(self):
     self.btest_exit('test_canvas_focus.c', args=['--pre-js', test_file('browser/fake_events.js')])
@@ -1251,9 +1009,7 @@ def test_canvas_focus(self):
   def test_keydown_preventdefault_proxy(self):
     def post():
       html = read_file('test.html')
-      html = html.replace(
-        '</body>',
-        '''
+      html = html.replace('</body>', '''
 <script src='fake_events.js'></script>
 <script>
 // Send 'A'.  The corresonding keypress event will not be prevented.
@@ -1267,8 +1023,7 @@ def post():
 simulateKeyDown(100, undefined, 'Numpad4');
 simulateKeyUp(100, undefined, 'Numpad4');
 </script>
-</body>''',
-      )
+</body>''')
 
       create_file('test.html', html)
 
@@ -1276,9 +1031,7 @@ def post():
     self.btest_exit('browser/test_keydown_preventdefault_proxy.c', 300, args=['--proxy-to-worker'], post_build=post)
 
   def test_sdl_text(self):
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       Module.postRun = () => {
         function doOne() {
           Module._one();
@@ -1286,22 +1039,15 @@ def test_sdl_text(self):
         }
         setTimeout(doOne, 1000/60);
       }
-    ''',
-    )
+    ''')
 
-    self.btest_exit(
-      'test_sdl_text.c', args=['--pre-js', 'pre.js', '--pre-js', test_file('browser/fake_events.js'), '-lSDL', '-lGL']
-    )
+    self.btest_exit('test_sdl_text.c', args=['--pre-js', 'pre.js', '--pre-js', test_file('browser/fake_events.js'), '-lSDL', '-lGL'])
 
   def test_sdl_mouse(self):
-    self.btest_exit(
-      'test_sdl_mouse.c', args=['-O2', '--minify=0', '--pre-js', test_file('browser/fake_events.js'), '-lSDL', '-lGL']
-    )
+    self.btest_exit('test_sdl_mouse.c', args=['-O2', '--minify=0', '--pre-js', test_file('browser/fake_events.js'), '-lSDL', '-lGL'])
 
   def test_sdl_mouse_offsets(self):
-    create_file(
-      'page.html',
-      '''
+    create_file('page.html', '''
       <html>
         <head>
           <style type="text/css">
@@ -1345,24 +1091,9 @@ def test_sdl_mouse_offsets(self):
           <script type="text/javascript" src="sdl_mouse.js"></script>
         </body>
       </html>
-    ''',
-    )
+    ''')
 
-    self.compile_btest(
-      'browser/test_sdl_mouse.c',
-      [
-        '-DTEST_SDL_MOUSE_OFFSETS',
-        '-O2',
-        '--minify=0',
-        '-o',
-        'sdl_mouse.js',
-        '--pre-js',
-        test_file('browser/fake_events.js'),
-        '-lSDL',
-        '-lGL',
-        '-sEXIT_RUNTIME',
-      ],
-    )
+    self.compile_btest('browser/test_sdl_mouse.c', ['-DTEST_SDL_MOUSE_OFFSETS', '-O2', '--minify=0', '-o', 'sdl_mouse.js', '--pre-js', test_file('browser/fake_events.js'), '-lSDL', '-lGL', '-sEXIT_RUNTIME'])
     self.run_browser('page.html', '', '/report_result?exit:0')
 
   def test_glut_touchevents(self):
@@ -1374,25 +1105,18 @@ def test_glut_wheelevents(self):
   @requires_graphics_hardware
   def test_glut_glutget_no_antialias(self):
     self.btest_exit('glut_glutget.c', args=['-lglut', '-lGL'])
-    self.btest_exit(
-      'glut_glutget.c', args=['-lglut', '-lGL', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED', '-DALPHA_ACTIVATED']
-    )
+    self.btest_exit('glut_glutget.c', args=['-lglut', '-lGL', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED', '-DALPHA_ACTIVATED'])
 
   # This test supersedes the one above, but it's skipped in the CI because anti-aliasing is not well supported by the Mesa software renderer.
   @requires_graphics_hardware
   def test_glut_glutget(self):
     self.btest_exit('glut_glutget.c', args=['-lglut', '-lGL'])
-    self.btest_exit(
-      'glut_glutget.c',
-      args=['-lglut', '-lGL', '-DAA_ACTIVATED', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED', '-DALPHA_ACTIVATED'],
-    )
+    self.btest_exit('glut_glutget.c', args=['-lglut', '-lGL', '-DAA_ACTIVATED', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED', '-DALPHA_ACTIVATED'])
 
   def test_sdl_joystick_1(self):
     # Generates events corresponding to the Working Draft of the HTML5 Gamepad API.
     # http://www.w3.org/TR/2012/WD-gamepad-20120529/#gamepad-interface
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       var gamepads = [];
       // Spoof this function.
       navigator['getGamepads'] = () => gamepads;
@@ -1417,19 +1141,14 @@ def test_sdl_joystick_1(self):
       window['simulateAxisMotion'] = (index, axis, value) => {
         gamepads[index].axes[axis] = value;
       };
-    ''',
-    )
+    ''')
 
-    self.btest_exit(
-      'test_sdl_joystick.c', args=['-O2', '--minify=0', '-o', 'page.html', '--pre-js', 'pre.js', '-lSDL', '-lGL']
-    )
+    self.btest_exit('test_sdl_joystick.c', args=['-O2', '--minify=0', '-o', 'page.html', '--pre-js', 'pre.js', '-lSDL', '-lGL'])
 
   def test_sdl_joystick_2(self):
     # Generates events corresponding to the Editor's Draft of the HTML5 Gamepad API.
     # https://dvcs.w3.org/hg/gamepad/raw-file/default/gamepad.html#idl-def-Gamepad
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       var gamepads = [];
       // Spoof this function.
       navigator['getGamepads'] = () => gamepads;
@@ -1458,8 +1177,7 @@ def test_sdl_joystick_2(self):
       window['simulateAxisMotion'] = (index, axis, value) => {
         gamepads[index].axes[axis] = value;
       };
-    ''',
-    )
+    ''')
 
     self.btest_exit('test_sdl_joystick.c', args=['-O2', '--minify=0', '--pre-js', 'pre.js', '-lSDL', '-lGL'])
 
@@ -1467,9 +1185,7 @@ def test_sdl_joystick_2(self):
   def test_glfw_joystick(self):
     # Generates events corresponding to the Editor's Draft of the HTML5 Gamepad API.
     # https://dvcs.w3.org/hg/gamepad/raw-file/default/gamepad.html#idl-def-Gamepad
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       var gamepads = [];
       // Spoof this function.
       navigator['getGamepads'] = () => gamepads;
@@ -1504,22 +1220,16 @@ def test_glfw_joystick(self):
       window['simulateAxisMotion'] = (index, axis, value) => {
         gamepads[index].axes[axis] = value;
       };
-    ''',
-    )
+    ''')
 
-    self.btest_exit(
-      'test_glfw_joystick.c',
-      args=['-O2', '--minify=0', '-o', 'page.html', '--pre-js', 'pre.js', '-lGL', '-lglfw3', '-sUSE_GLFW=3'],
-    )
+    self.btest_exit('test_glfw_joystick.c', args=['-O2', '--minify=0', '-o', 'page.html', '--pre-js', 'pre.js', '-lGL', '-lglfw3', '-sUSE_GLFW=3'])
 
   @requires_graphics_hardware
   def test_webgl_context_attributes(self):
     # Javascript code to check the attributes support we want to test in the WebGL implementation
     # (request the attribute, create a context and check its value afterwards in the context attributes).
     # Tests will succeed when an attribute is not supported.
-    create_file(
-      'check_webgl_attributes_support.js',
-      '''
+    create_file('check_webgl_attributes_support.js', '''
       addToLibrary({
         webglAntialiasSupported: function() {
           canvas = document.createElement('canvas');
@@ -1546,8 +1256,7 @@ def test_webgl_context_attributes(self):
           return attributes.alpha;
         }
       });
-    ''',
-    )
+    ''')
 
     # Copy common code file to temporary directory
     filepath = test_file('browser/test_webgl_context_attributes_common.c')
@@ -1558,78 +1267,16 @@ def test_webgl_context_attributes(self):
     self.set_setting('STACK_SIZE', '1MB')
 
     # perform tests with attributes activated
-    self.btest_exit(
-      'test_webgl_context_attributes_glut.c',
-      args=[
-        '--js-library',
-        'check_webgl_attributes_support.js',
-        '-DAA_ACTIVATED',
-        '-DDEPTH_ACTIVATED',
-        '-DSTENCIL_ACTIVATED',
-        '-DALPHA_ACTIVATED',
-        '-lGL',
-        '-lglut',
-        '-lGLEW',
-      ],
-    )
-    self.btest_exit(
-      'test_webgl_context_attributes_sdl.c',
-      args=[
-        '--js-library',
-        'check_webgl_attributes_support.js',
-        '-DAA_ACTIVATED',
-        '-DDEPTH_ACTIVATED',
-        '-DSTENCIL_ACTIVATED',
-        '-DALPHA_ACTIVATED',
-        '-lGL',
-        '-lSDL',
-        '-lGLEW',
-      ],
-    )
+    self.btest_exit('test_webgl_context_attributes_glut.c', args=['--js-library', 'check_webgl_attributes_support.js', '-DAA_ACTIVATED', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED', '-DALPHA_ACTIVATED', '-lGL', '-lglut', '-lGLEW'])
+    self.btest_exit('test_webgl_context_attributes_sdl.c', args=['--js-library', 'check_webgl_attributes_support.js', '-DAA_ACTIVATED', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED', '-DALPHA_ACTIVATED', '-lGL', '-lSDL', '-lGLEW'])
     if not self.is_wasm64():
-      self.btest_exit(
-        'test_webgl_context_attributes_sdl2.c',
-        args=[
-          '--js-library',
-          'check_webgl_attributes_support.js',
-          '-DAA_ACTIVATED',
-          '-DDEPTH_ACTIVATED',
-          '-DSTENCIL_ACTIVATED',
-          '-DALPHA_ACTIVATED',
-          '-lGL',
-          '-sUSE_SDL=2',
-          '-lGLEW',
-          '-sGL_ENABLE_GET_PROC_ADDRESS=1',
-        ],
-      )
-    self.btest_exit(
-      'test_webgl_context_attributes_glfw.c',
-      args=[
-        '--js-library',
-        'check_webgl_attributes_support.js',
-        '-DAA_ACTIVATED',
-        '-DDEPTH_ACTIVATED',
-        '-DSTENCIL_ACTIVATED',
-        '-DALPHA_ACTIVATED',
-        '-lGL',
-        '-lglfw',
-        '-lGLEW',
-      ],
-    )
+      self.btest_exit('test_webgl_context_attributes_sdl2.c', args=['--js-library', 'check_webgl_attributes_support.js', '-DAA_ACTIVATED', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED', '-DALPHA_ACTIVATED', '-lGL', '-sUSE_SDL=2', '-lGLEW', '-sGL_ENABLE_GET_PROC_ADDRESS=1'])
+    self.btest_exit('test_webgl_context_attributes_glfw.c', args=['--js-library', 'check_webgl_attributes_support.js', '-DAA_ACTIVATED', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED', '-DALPHA_ACTIVATED', '-lGL', '-lglfw', '-lGLEW'])
 
     # perform tests with attributes desactivated
-    self.btest_exit(
-      'test_webgl_context_attributes_glut.c',
-      args=['--js-library', 'check_webgl_attributes_support.js', '-lGL', '-lglut', '-lGLEW'],
-    )
-    self.btest_exit(
-      'test_webgl_context_attributes_sdl.c',
-      args=['--js-library', 'check_webgl_attributes_support.js', '-lGL', '-lSDL', '-lGLEW'],
-    )
-    self.btest_exit(
-      'test_webgl_context_attributes_glfw.c',
-      args=['--js-library', 'check_webgl_attributes_support.js', '-lGL', '-lglfw', '-lGLEW'],
-    )
+    self.btest_exit('test_webgl_context_attributes_glut.c', args=['--js-library', 'check_webgl_attributes_support.js', '-lGL', '-lglut', '-lGLEW'])
+    self.btest_exit('test_webgl_context_attributes_sdl.c', args=['--js-library', 'check_webgl_attributes_support.js', '-lGL', '-lSDL', '-lGLEW'])
+    self.btest_exit('test_webgl_context_attributes_glfw.c', args=['--js-library', 'check_webgl_attributes_support.js', '-lGL', '-lglfw', '-lGLEW'])
 
   @requires_graphics_hardware
   def test_webgl_no_double_error(self):
@@ -1641,9 +1288,7 @@ def test_webgl_parallel_shader_compile(self):
 
   @requires_graphics_hardware
   def test_webgl_explicit_uniform_location(self):
-    self.btest_exit(
-      'webgl_explicit_uniform_location.c', args=['-sGL_EXPLICIT_UNIFORM_LOCATION', '-sMIN_WEBGL_VERSION=2']
-    )
+    self.btest_exit('webgl_explicit_uniform_location.c', args=['-sGL_EXPLICIT_UNIFORM_LOCATION', '-sMIN_WEBGL_VERSION=2'])
 
   @requires_graphics_hardware
   def test_webgl_sampler_layout_binding(self):
@@ -1656,18 +1301,13 @@ def test_webgl2_ubo_layout_binding(self):
   # Test that -sGL_PREINITIALIZED_CONTEXT works and allows user to set Module['preinitializedWebGLContext'] to a preinitialized WebGL context.
   @requires_graphics_hardware
   def test_preinitialized_webgl_context(self):
-    self.btest_exit(
-      'preinitialized_webgl_context.cpp',
-      args=['-sGL_PREINITIALIZED_CONTEXT', '--shell-file', test_file('preinitialized_webgl_context.html')],
-    )
-
-  @parameterized(
-    {
-      '': ([],),
-      'threads': (['-pthread'],),
-      'closure': (['-sENVIRONMENT=web', '-O2', '--closure=1'],),
-    }
-  )
+    self.btest_exit('preinitialized_webgl_context.cpp', args=['-sGL_PREINITIALIZED_CONTEXT', '--shell-file', test_file('preinitialized_webgl_context.html')])
+
+  @parameterized({
+    '': ([],),
+    'threads': (['-pthread'],),
+    'closure': (['-sENVIRONMENT=web', '-O2', '--closure=1'],),
+  })
   def test_emscripten_get_now(self, args):
     self.btest_exit('test_emscripten_get_now.c', args=args)
 
@@ -1675,44 +1315,24 @@ def test_write_file_in_environment_web(self):
     self.btest_exit('write_file.c', args=['-sENVIRONMENT=web', '-Os', '--closure=1'])
 
   def test_fflush(self):
-    self.btest(
-      'test_fflush.cpp',
-      '0',
-      args=['-sEXIT_RUNTIME', '--shell-file', test_file('test_fflush.html')],
-      reporting=Reporting.NONE,
-    )
-
-  @parameterized(
-    {
-      '': ([],),
-      'extra': (['-DEXTRA_WORK'],),
-      'autopersist': (['-DIDBFS_AUTO_PERSIST'],),
-      'force_exit': (['-sEXIT_RUNTIME', '-DFORCE_EXIT'],),
-    }
-  )
+    self.btest('test_fflush.cpp', '0', args=['-sEXIT_RUNTIME', '--shell-file', test_file('test_fflush.html')], reporting=Reporting.NONE)
+
+  @parameterized({
+    '': ([],),
+    'extra': (['-DEXTRA_WORK'],),
+    'autopersist': (['-DIDBFS_AUTO_PERSIST'],),
+    'force_exit': (['-sEXIT_RUNTIME', '-DFORCE_EXIT'],),
+  })
   def test_fs_idbfs_sync(self, args):
     self.set_setting('DEFAULT_LIBRARY_FUNCS_TO_INCLUDE', '$ccall')
     secret = str(time.time())
-    self.btest(
-      'fs/test_idbfs_sync.c',
-      '1',
-      args=['-lidbfs.js', f'-DSECRET="{secret}"', '-sEXPORTED_FUNCTIONS=_main,_test,_report_result', '-lidbfs.js']
-      + args
-      + ['-DFIRST'],
-    )
-    self.btest(
-      'fs/test_idbfs_sync.c',
-      '1',
-      args=['-lidbfs.js', f'-DSECRET="{secret}"', '-sEXPORTED_FUNCTIONS=_main,_test,_report_result', '-lidbfs.js']
-      + args,
-    )
+    self.btest('fs/test_idbfs_sync.c', '1', args=['-lidbfs.js', f'-DSECRET="{secret}"', '-sEXPORTED_FUNCTIONS=_main,_test,_report_result', '-lidbfs.js'] + args + ['-DFIRST'])
+    self.btest('fs/test_idbfs_sync.c', '1', args=['-lidbfs.js', f'-DSECRET="{secret}"', '-sEXPORTED_FUNCTIONS=_main,_test,_report_result', '-lidbfs.js'] + args)
 
   def test_fs_idbfs_fsync(self):
     # sync from persisted state into memory before main()
     self.set_setting('DEFAULT_LIBRARY_FUNCS_TO_INCLUDE', '$ccall')
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       Module.preRun = () => {
         addRunDependency('syncfs');
 
@@ -1723,8 +1343,7 @@ def test_fs_idbfs_fsync(self):
           removeRunDependency('syncfs');
         });
       };
-    ''',
-    )
+    ''')
 
     args = ['--pre-js', 'pre.js', '-lidbfs.js', '-sEXIT_RUNTIME', '-sASYNCIFY']
     secret = str(time.time())
@@ -1739,9 +1358,7 @@ def test_fs_memfs_fsync(self):
   def test_fs_workerfs_read(self):
     secret = 'a' * 10
     secret2 = 'b' * 10
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       Module.preRun = () => {
         var blob = new Blob(['%s']);
         var file = new File(['%s'], 'file.txt');
@@ -1751,38 +1368,15 @@ def test_fs_workerfs_read(self):
           files: [file],
         }, '/work');
       };
-    '''
-      % (secret, secret2),
-    )
-    self.btest_exit(
-      'fs/test_workerfs_read.c',
-      args=[
-        '-lworkerfs.js',
-        '--pre-js',
-        'pre.js',
-        f'-DSECRET="{secret }"',
-        f'-DSECRET2="{secret2}"',
-        '--proxy-to-worker',
-        '-lworkerfs.js',
-      ],
-    )
+    ''' % (secret, secret2))
+    self.btest_exit('fs/test_workerfs_read.c', args=['-lworkerfs.js', '--pre-js', 'pre.js', f'-DSECRET="{secret }"', f'-DSECRET2="{secret2}"', '--proxy-to-worker', '-lworkerfs.js'])
 
   def test_fs_workerfs_package(self):
     self.set_setting('DEFAULT_LIBRARY_FUNCS_TO_INCLUDE', '$ccall')
     create_file('file1.txt', 'first')
     ensure_dir('sub')
     create_file('sub/file2.txt', 'second')
-    self.run_process(
-      [
-        FILE_PACKAGER,
-        'files.data',
-        '--preload',
-        'file1.txt',
-        Path('sub/file2.txt'),
-        '--separate-metadata',
-        '--js-output=files.js',
-      ]
-    )
+    self.run_process([FILE_PACKAGER, 'files.data', '--preload', 'file1.txt', Path('sub/file2.txt'), '--separate-metadata', '--js-output=files.js'])
     self.btest(Path('fs/test_workerfs_package.cpp'), '1', args=['-lworkerfs.js', '--proxy-to-worker', '-lworkerfs.js'])
 
   def test_fs_lz4fs_package(self):
@@ -1797,87 +1391,39 @@ def test_fs_lz4fs_package(self):
     # compress in emcc, -sLZ4 tells it to tell the file packager
     print('emcc-normal')
     self.set_setting('DEFAULT_LIBRARY_FUNCS_TO_INCLUDE', '$ccall')
-    self.btest_exit(
-      Path('fs/test_lz4fs.cpp'),
-      2,
-      args=[
-        '-sLZ4',
-        '--preload-file',
-        'file1.txt',
-        '--preload-file',
-        'subdir/file2.txt',
-        '--preload-file',
-        'file3.txt',
-      ],
-    )
-    assert (
-      os.path.getsize('file1.txt') + os.path.getsize(Path('subdir/file2.txt')) + os.path.getsize('file3.txt')
-      == 3 * 1024 * 128 * 10 + 1
-    )
+    self.btest_exit(Path('fs/test_lz4fs.cpp'), 2, args=['-sLZ4', '--preload-file', 'file1.txt', '--preload-file', 'subdir/file2.txt', '--preload-file', 'file3.txt'])
+    assert os.path.getsize('file1.txt') + os.path.getsize(Path('subdir/file2.txt')) + os.path.getsize('file3.txt') == 3 * 1024 * 128 * 10 + 1
     assert os.path.getsize('test.data') < (3 * 1024 * 128 * 10) / 2  # over half is gone
     print('    emcc-opts')
-    self.btest_exit(
-      Path('fs/test_lz4fs.cpp'),
-      2,
-      args=[
-        '-sLZ4',
-        '--preload-file',
-        'file1.txt',
-        '--preload-file',
-        'subdir/file2.txt',
-        '--preload-file',
-        'file3.txt',
-        '-O2',
-      ],
-    )
+    self.btest_exit(Path('fs/test_lz4fs.cpp'), 2, args=['-sLZ4', '--preload-file', 'file1.txt', '--preload-file', 'subdir/file2.txt', '--preload-file', 'file3.txt', '-O2'])
 
     # compress in the file packager, on the server. the client receives compressed data and can just use it. this is typical usage
     print('normal')
-    out = subprocess.check_output(
-      [FILE_PACKAGER, 'files.data', '--preload', 'file1.txt', 'subdir/file2.txt', 'file3.txt', '--lz4']
-    )
+    out = subprocess.check_output([FILE_PACKAGER, 'files.data', '--preload', 'file1.txt', 'subdir/file2.txt', 'file3.txt', '--lz4'])
     create_file('files.js', out, binary=True)
     self.btest_exit('fs/test_lz4fs.cpp', 2, args=['--pre-js', 'files.js', '-sLZ4', '-sFORCE_FILESYSTEM'])
     print('    opts')
     self.btest_exit('fs/test_lz4fs.cpp', 2, args=['--pre-js', 'files.js', '-sLZ4', '-sFORCE_FILESYSTEM', '-O2'])
     print('    modularize')
-    self.compile_btest(
-      'fs/test_lz4fs.cpp', ['--pre-js', 'files.js', '-sLZ4', '-sFORCE_FILESYSTEM', '-sMODULARIZE', '-sEXIT_RUNTIME']
-    )
-    create_file(
-      'a.html',
-      '''
+    self.compile_btest('fs/test_lz4fs.cpp', ['--pre-js', 'files.js', '-sLZ4', '-sFORCE_FILESYSTEM', '-sMODULARIZE', '-sEXIT_RUNTIME'])
+    create_file('a.html', '''
       <script src="a.out.js"></script>
       <script>
         Module()
       </script>
-    ''',
-    )
+    ''')
     self.run_browser('a.html', '/report_result?exit:2')
 
     # load the data into LZ4FS manually at runtime. This means we compress on the client. This is generally not recommended
     print('manual')
-    subprocess.check_output(
-      [
-        FILE_PACKAGER,
-        'files.data',
-        '--preload',
-        'file1.txt',
-        'subdir/file2.txt',
-        'file3.txt',
-        '--separate-metadata',
-        '--js-output=files.js',
-      ]
-    )
+    subprocess.check_output([FILE_PACKAGER, 'files.data', '--preload', 'file1.txt', 'subdir/file2.txt', 'file3.txt', '--separate-metadata', '--js-output=files.js'])
     self.btest_exit('fs/test_lz4fs.cpp', 1, args=['-DLOAD_MANUALLY', '-sLZ4', '-sFORCE_FILESYSTEM'])
     print('    opts')
     self.btest_exit('fs/test_lz4fs.cpp', 1, args=['-DLOAD_MANUALLY', '-sLZ4', '-sFORCE_FILESYSTEM', '-O2'])
     print('    opts+closure')
-    self.btest_exit(
-      'fs/test_lz4fs.cpp',
-      1,
-      args=['-DLOAD_MANUALLY', '-sLZ4', '-sFORCE_FILESYSTEM', '-O2', '--closure=1', '-g1', '-Wno-closure'],
-    )
+    self.btest_exit('fs/test_lz4fs.cpp', 1, args=['-DLOAD_MANUALLY', '-sLZ4',
+                                                  '-sFORCE_FILESYSTEM', '-O2',
+                                                  '--closure=1', '-g1', '-Wno-closure'])
 
     '''# non-lz4 for comparison
     try:
@@ -1896,44 +1442,30 @@ def test_separate_metadata_later(self):
     # the main program, and when we are run later
 
     create_file('data.dat', ' ')
-    self.run_process(
-      [FILE_PACKAGER, 'more.data', '--preload', 'data.dat', '--separate-metadata', '--js-output=more.js']
-    )
+    self.run_process([FILE_PACKAGER, 'more.data', '--preload', 'data.dat', '--separate-metadata', '--js-output=more.js'])
     self.btest(Path('browser/separate_metadata_later.cpp'), '1', args=['-sFORCE_FILESYSTEM'])
 
   def test_idbstore(self):
     secret = str(time.time())
     for stage in (0, 1, 2, 3, 0, 1, 2, 0, 0, 1, 4, 2, 5, 0, 4, 6, 5):
       print(stage)
-      self.btest_exit(
-        'test_idbstore.c',
-        args=['-lidbstore.js', f'-DSTAGE={stage}', f'-DSECRET="{secret}"'],
-        output_basename=f'idbstore_{stage}',
-      )
-
-  @parameterized(
-    {
-      'asyncify': (1,),
-      'jspi': (2,),
-    }
-  )
+      self.btest_exit('test_idbstore.c',
+                      args=['-lidbstore.js', f'-DSTAGE={stage}', f'-DSECRET="{secret}"'],
+                      output_basename=f'idbstore_{stage}')
+
+  @parameterized({
+    'asyncify': (1,),
+    'jspi': (2,),
+  })
   def test_idbstore_sync(self, asyncify):
     if asyncify == 2:
       self.require_jspi()
     secret = str(time.time())
-    self.btest(
-      'test_idbstore_sync.c',
-      '8',
-      args=['-lidbstore.js', f'-DSECRET="{secret}"', '-O3', '-g2', f'-sASYNCIFY={asyncify}'],
-    )
+    self.btest('test_idbstore_sync.c', '8', args=['-lidbstore.js', f'-DSECRET="{secret}"', '-O3', '-g2', f'-sASYNCIFY={asyncify}'])
 
   def test_idbstore_sync_worker(self):
     secret = str(time.time())
-    self.btest(
-      'test_idbstore_sync_worker.c',
-      expected='0',
-      args=['-lidbstore.js', f'-DSECRET="{secret}"', '-O3', '-g2', '--proxy-to-worker', '-sASYNCIFY'],
-    )
+    self.btest('test_idbstore_sync_worker.c', expected='0', args=['-lidbstore.js', f'-DSECRET="{secret}"', '-O3', '-g2', '--proxy-to-worker', '-sASYNCIFY'])
 
   def test_force_exit(self):
     self.btest_exit('force_exit.c', assert_returncode=10)
@@ -1943,10 +1475,9 @@ def test_sdl_pumpevents(self):
     self.btest_exit('test_sdl_pumpevents.c', args=['--pre-js', test_file('browser/fake_events.js'), '-lSDL', '-lGL'])
 
   def test_sdl_canvas_size(self):
-    self.btest_exit(
-      'test_sdl_canvas_size.c',
-      args=['-O2', '--minify=0', '--shell-file', test_file('browser/test_sdl_canvas_size.html'), '-lSDL', '-lGL'],
-    )
+    self.btest_exit('test_sdl_canvas_size.c',
+                    args=['-O2', '--minify=0', '--shell-file',
+                          test_file('browser/test_sdl_canvas_size.html'), '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_sdl_gl_extensions(self):
@@ -1964,161 +1495,72 @@ def test_sdl_gl_mapbuffers(self):
   @requires_graphics_hardware
   def test_sdl_ogl(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_ogl.c',
-      'screenshot-gray-purple.png',
-      reference_slack=1,
-      args=[
-        '-O2',
-        '--minify=0',
-        '--preload-file',
-        'screenshot.png',
-        '-sLEGACY_GL_EMULATION',
-        '--use-preload-plugins',
-        '-lSDL',
-        '-lGL',
-      ],
-    )
+    self.reftest('test_sdl_ogl.c', 'screenshot-gray-purple.png', reference_slack=1,
+                 args=['-O2', '--minify=0', '--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_sdl_ogl_regal(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_ogl.c',
-      'screenshot-gray-purple.png',
-      reference_slack=1,
-      args=[
-        '-O2',
-        '--minify=0',
-        '--preload-file',
-        'screenshot.png',
-        '-sUSE_REGAL',
-        '-DUSE_REGAL',
-        '--use-preload-plugins',
-        '-lSDL',
-        '-lGL',
-        '-lc++',
-        '-lc++abi',
-      ],
-    )
+    self.reftest('test_sdl_ogl.c', 'screenshot-gray-purple.png', reference_slack=1,
+                 args=['-O2', '--minify=0', '--preload-file', 'screenshot.png', '-sUSE_REGAL', '-DUSE_REGAL', '--use-preload-plugins', '-lSDL', '-lGL', '-lc++', '-lc++abi'])
 
   @requires_graphics_hardware
   def test_sdl_ogl_defaultmatrixmode(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_ogl_defaultMatrixMode.c',
-      'screenshot-gray-purple.png',
-      reference_slack=1,
-      args=[
-        '--minify=0',
-        '--preload-file',
-        'screenshot.png',
-        '-sLEGACY_GL_EMULATION',
-        '--use-preload-plugins',
-        '-lSDL',
-        '-lGL',
-      ],
-    )
+    self.reftest('test_sdl_ogl_defaultMatrixMode.c', 'screenshot-gray-purple.png', reference_slack=1,
+                 args=['--minify=0', '--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_sdl_ogl_p(self):
     # Immediate mode with pointers
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_ogl_p.c',
-      'screenshot-gray.png',
-      reference_slack=1,
-      args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_ogl_p.c', 'screenshot-gray.png', reference_slack=1,
+                 args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_sdl_ogl_proc_alias(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_ogl_proc_alias.c',
-      'screenshot-gray-purple.png',
-      reference_slack=1,
-      args=[
-        '-O2',
-        '-g2',
-        '-sINLINING_LIMIT',
-        '--preload-file',
-        'screenshot.png',
-        '-sLEGACY_GL_EMULATION',
-        '-sGL_ENABLE_GET_PROC_ADDRESS',
-        '--use-preload-plugins',
-        '-lSDL',
-        '-lGL',
-      ],
-    )
+    self.reftest('test_sdl_ogl_proc_alias.c', 'screenshot-gray-purple.png', reference_slack=1,
+                 args=['-O2', '-g2', '-sINLINING_LIMIT', '--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-sGL_ENABLE_GET_PROC_ADDRESS', '--use-preload-plugins', '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_sdl_fog_simple(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_fog_simple.c',
-      'screenshot-fog-simple.png',
-      args=[
-        '-O2',
-        '--minify=0',
-        '--preload-file',
-        'screenshot.png',
-        '-sLEGACY_GL_EMULATION',
-        '--use-preload-plugins',
-        '-lSDL',
-        '-lGL',
-      ],
-    )
+    self.reftest('test_sdl_fog_simple.c', 'screenshot-fog-simple.png',
+                 args=['-O2', '--minify=0', '--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_sdl_fog_negative(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_fog_negative.c',
-      'screenshot-fog-negative.png',
-      args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_fog_negative.c', 'screenshot-fog-negative.png',
+                 args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_sdl_fog_density(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_fog_density.c',
-      'screenshot-fog-density.png',
-      args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_fog_density.c', 'screenshot-fog-density.png',
+                 args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_sdl_fog_exp2(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_fog_exp2.c',
-      'screenshot-fog-exp2.png',
-      args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_fog_exp2.c', 'screenshot-fog-exp2.png',
+                 args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_sdl_fog_linear(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_fog_linear.c',
-      'screenshot-fog-linear.png',
-      reference_slack=1,
-      args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'],
-    )
+    self.reftest('test_sdl_fog_linear.c', 'screenshot-fog-linear.png', reference_slack=1,
+                 args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins', '-lSDL', '-lGL'])
 
   @requires_graphics_hardware
   def test_glfw(self):
     # Using only the `-l` flag
     self.btest_exit('test_glfw.c', args=['-sLEGACY_GL_EMULATION', '-lglfw', '-lGL', '-sGL_ENABLE_GET_PROC_ADDRESS'])
     # Using only the `-s` flag
-    self.btest_exit(
-      'test_glfw.c', args=['-sLEGACY_GL_EMULATION', '-sUSE_GLFW=2', '-lGL', '-sGL_ENABLE_GET_PROC_ADDRESS']
-    )
+    self.btest_exit('test_glfw.c', args=['-sLEGACY_GL_EMULATION', '-sUSE_GLFW=2', '-lGL', '-sGL_ENABLE_GET_PROC_ADDRESS'])
     # Using both `-s` and `-l` flags
-    self.btest_exit(
-      'test_glfw.c', args=['-sLEGACY_GL_EMULATION', '-sUSE_GLFW=2', '-lglfw', '-lGL', '-sGL_ENABLE_GET_PROC_ADDRESS']
-    )
+    self.btest_exit('test_glfw.c', args=['-sLEGACY_GL_EMULATION', '-sUSE_GLFW=2', '-lglfw', '-lGL', '-sGL_ENABLE_GET_PROC_ADDRESS'])
 
   def test_glfw_minimal(self):
     self.btest_exit('test_glfw_minimal.c', args=['-lglfw', '-lGL'])
@@ -2127,22 +1569,18 @@ def test_glfw_minimal(self):
   def test_glfw_time(self):
     self.btest_exit('test_glfw_time.c', args=['-sUSE_GLFW=3', '-lglfw', '-lGL'])
 
-  @parameterized(
-    {
-      '': ([],),
-      'proxy_to_pthread': (['-pthread', '-sPROXY_TO_PTHREAD', '-sOFFSCREEN_FRAMEBUFFER'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'proxy_to_pthread': (['-pthread', '-sPROXY_TO_PTHREAD', '-sOFFSCREEN_FRAMEBUFFER'],),
+  })
   @requires_graphics_hardware
   def test_egl(self, args):
     self.btest_exit('test_egl.c', args=['-O2', '-lEGL', '-lGL', '-sGL_ENABLE_GET_PROC_ADDRESS'] + args)
 
-  @parameterized(
-    {
-      '': ([],),
-      'proxy_to_pthread': (['-pthread', '-sPROXY_TO_PTHREAD'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'proxy_to_pthread': (['-pthread', '-sPROXY_TO_PTHREAD'],),
+  })
   def test_egl_width_height(self, args):
     self.btest_exit('test_egl_width_height.c', args=['-O2', '-lEGL', '-lGL'] + args)
 
@@ -2150,18 +1588,14 @@ def test_egl_width_height(self, args):
   def test_egl_createcontext_error(self):
     self.btest_exit('test_egl_createcontext_error.c', args=['-lEGL', '-lGL'])
 
-  @parameterized(
-    {
-      '': ([False],),
-      'preload': ([True],),
-    }
-  )
+  @parameterized({
+    '': ([False],),
+    'preload': ([True],),
+  })
   def test_hello_world_worker(self, file_data):
     # Test running in a web worker
     create_file('file.dat', 'data for worker')
-    create_file(
-      'main.html',
-      '''
+    create_file('main.html', '''
       <html>
       <body>
         Worker Test
@@ -2174,9 +1608,7 @@ def test_hello_world_worker(self, file_data):
         </script>
       </body>
       </html>
-    '''
-      % self.PORT,
-    )
+    ''' % self.PORT)
 
     cmd = [EMCC, test_file('hello_world_worker.c'), '-o', 'worker.js'] + self.get_emcc_args()
     if file_data:
@@ -2194,14 +1626,11 @@ def test_hello_world_worker(self, file_data):
   @no_wasmfs('https://github.com/emscripten-core/emscripten/issues/19608')
   def test_mmap_lazyfile(self):
     create_file('lazydata.dat', 'hello world')
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       Module["preInit"] = () => {
         FS.createLazyFile('/', "lazy.txt", "lazydata.dat", true, false);
       }
-    ''',
-    )
+    ''')
     self.emcc_args += ['--pre-js=pre.js', '--proxy-to-worker']
     self.btest_exit('test_mmap_lazyfile.c')
 
@@ -2211,9 +1640,7 @@ def test_chunked_synchronous_xhr(self):
     main = 'chunked_sync_xhr.html'
     worker_filename = "download_and_checksum_worker.js"
 
-    create_file(
-      main,
-      r"""
+    create_file(main, r"""
       <!doctype html>
       <html>
       <head><meta charset="utf-8"><title>Chunked XHR</title></head>
@@ -2244,13 +1671,9 @@ def test_chunked_synchronous_xhr(self):
         </script>
       </body>
       </html>
-    """
-      % (worker_filename, self.PORT),
-    )
+    """ % (worker_filename, self.PORT))
 
-    create_file(
-      'worker_prejs.js',
-      r"""
+    create_file('worker_prejs.js', r"""
       Module.arguments = ["/bigfile"];
       Module.preInit = () => {
         FS.createLazyFile('/', "bigfile", "http://localhost:11111/bogus_file_path", true, false);
@@ -2258,18 +1681,14 @@ def test_chunked_synchronous_xhr(self):
       var doTrace = true;
       Module.print = (s) => self.postMessage({channel: "stdout", line: s});
       Module.printErr = (s) => { self.postMessage({channel: "stderr", char: s, trace: ((doTrace && s === 10) ? new Error().stack : null)}); doTrace = false; };
-    """,
-    )
-    self.compile_btest(
-      'checksummer.c', ['-g', '-sSMALL_XHR_CHUNKS', '-o', worker_filename, '--pre-js', 'worker_prejs.js']
-    )
+    """)
+    self.compile_btest('checksummer.c', ['-g', '-sSMALL_XHR_CHUNKS', '-o', worker_filename,
+                                         '--pre-js', 'worker_prejs.js'])
     chunkSize = 1024
-    data = os.urandom(10 * chunkSize + 1)  # 10 full chunks and one 1 byte chunk
-    checksum = zlib.adler32(data) & 0xFFFFFFFF  # Python 2 compatibility: force bigint
+    data = os.urandom(10 * chunkSize + 1) # 10 full chunks and one 1 byte chunk
+    checksum = zlib.adler32(data) & 0xffffffff # Python 2 compatibility: force bigint
 
-    server = multiprocessing.Process(
-      target=test_chunked_synchronous_xhr_server, args=(True, chunkSize, data, checksum, self.PORT)
-    )
+    server = multiprocessing.Process(target=test_chunked_synchronous_xhr_server, args=(True, chunkSize, data, checksum, self.PORT))
     server.start()
 
     # block until the server is actually ready
@@ -2294,12 +1713,8 @@ def test_chunked_synchronous_xhr(self):
 
   @requires_graphics_hardware
   def test_glgears(self, extra_args=[]):  # noqa
-    self.reftest(
-      'hello_world_gles.c',
-      'gears.png',
-      reference_slack=3,
-      args=['-DHAVE_BUILTIN_SINCOS', '-lGL', '-lglut'] + extra_args,
-    )
+    self.reftest('hello_world_gles.c', 'gears.png', reference_slack=3,
+                 args=['-DHAVE_BUILTIN_SINCOS', '-lGL', '-lglut'] + extra_args)
 
   @requires_graphics_hardware
   def test_glgears_pthreads(self, extra_args=[]):  # noqa
@@ -2308,37 +1723,26 @@ def test_glgears_pthreads(self, extra_args=[]):  # noqa
     self.test_glgears(['-pthread'])
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ([],),
-      # Enabling FULL_ES3 also enables ES2 automatically
-      'proxy': (['--proxy-to-worker'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    # Enabling FULL_ES3 also enables ES2 automatically
+    'proxy': (['--proxy-to-worker'],)
+  })
   def test_glgears_long(self, args):
     args += ['-DHAVE_BUILTIN_SINCOS', '-DLONGTEST', '-lGL', '-lglut', '-DANIMATE']
     self.btest('hello_world_gles.c', expected='0', args=args)
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ('hello_world_gles.c',),
-      'full': ('hello_world_gles_full.c',),
-      'full_944': ('hello_world_gles_full_944.c',),
-    }
-  )
+  @parameterized({
+    '': ('hello_world_gles.c',),
+    'full': ('hello_world_gles_full.c',),
+    'full_944': ('hello_world_gles_full_944.c',),
+  })
   def test_glgears_animation(self, filename):
     shutil.copy(test_file('browser/fake_events.js'), '.')
-    args = [
-      '-o',
-      'something.html',
-      '-DHAVE_BUILTIN_SINCOS',
-      '-sGL_TESTING',
-      '-lGL',
-      '-lglut',
-      '--shell-file',
-      test_file('hello_world_gles_shell.html'),
-    ]
+    args = ['-o', 'something.html',
+            '-DHAVE_BUILTIN_SINCOS', '-sGL_TESTING', '-lGL', '-lglut',
+            '--shell-file', test_file('hello_world_gles_shell.html')]
     if 'full' in filename:
       args += ['-sFULL_ES2']
     self.compile_btest(filename, args)
@@ -2346,44 +1750,27 @@ def test_glgears_animation(self, filename):
 
   @requires_graphics_hardware
   def test_fulles2_sdlproc(self):
-    self.btest_exit(
-      'full_es2_sdlproc.c',
-      assert_returncode=1,
-      args=[
-        '-sGL_TESTING',
-        '-DHAVE_BUILTIN_SINCOS',
-        '-sFULL_ES2',
-        '-lGL',
-        '-lSDL',
-        '-lglut',
-        '-sGL_ENABLE_GET_PROC_ADDRESS',
-      ],
-    )
+    self.btest_exit('full_es2_sdlproc.c', assert_returncode=1, args=['-sGL_TESTING', '-DHAVE_BUILTIN_SINCOS', '-sFULL_ES2', '-lGL', '-lSDL', '-lglut', '-sGL_ENABLE_GET_PROC_ADDRESS'])
 
   @requires_graphics_hardware
   def test_glgears_deriv(self):
-    self.reftest(
-      'hello_world_gles_deriv.c', 'gears.png', reference_slack=2, args=['-DHAVE_BUILTIN_SINCOS', '-lGL', '-lglut']
-    )
+    self.reftest('hello_world_gles_deriv.c', 'gears.png', reference_slack=2,
+                 args=['-DHAVE_BUILTIN_SINCOS', '-lGL', '-lglut'])
     assert 'gl-matrix' not in read_file('test.html'), 'Should not include glMatrix when not needed'
 
   @requires_graphics_hardware
   def test_glbook(self):
     self.emcc_args.append('-Wno-int-conversion')
     self.emcc_args.append('-Wno-pointer-sign')
-    programs = self.get_library(
-      'third_party/glbook',
-      [
-        'Chapter_2/Hello_Triangle/CH02_HelloTriangle.o',
-        'Chapter_8/Simple_VertexShader/CH08_SimpleVertexShader.o',
-        'Chapter_9/Simple_Texture2D/CH09_SimpleTexture2D.o',
-        'Chapter_9/Simple_TextureCubemap/CH09_TextureCubemap.o',
-        'Chapter_9/TextureWrap/CH09_TextureWrap.o',
-        'Chapter_10/MultiTexture/CH10_MultiTexture.o',
-        'Chapter_13/ParticleSystem/CH13_ParticleSystem.o',
-      ],
-      configure=None,
-    )
+    programs = self.get_library('third_party/glbook', [
+      'Chapter_2/Hello_Triangle/CH02_HelloTriangle.o',
+      'Chapter_8/Simple_VertexShader/CH08_SimpleVertexShader.o',
+      'Chapter_9/Simple_Texture2D/CH09_SimpleTexture2D.o',
+      'Chapter_9/Simple_TextureCubemap/CH09_TextureCubemap.o',
+      'Chapter_9/TextureWrap/CH09_TextureWrap.o',
+      'Chapter_10/MultiTexture/CH10_MultiTexture.o',
+      'Chapter_13/ParticleSystem/CH13_ParticleSystem.o',
+    ], configure=None)
 
     def book_path(path):
       return test_file('third_party/glbook', path)
@@ -2398,69 +1785,43 @@ def book_path(path):
         args += ['--preload-file', 'basemap.tga', '--preload-file', 'lightmap.tga']
       elif basename == 'CH13_ParticleSystem.o':
         shutil.copy(book_path('Chapter_13/ParticleSystem/smoke.tga'), '.')
-        args += ['--preload-file', 'smoke.tga', '-O2']  # test optimizations and closure here as well for more coverage
+        args += ['--preload-file', 'smoke.tga', '-O2'] # test optimizations and closure here as well for more coverage
 
       self.reftest(program, book_path(basename.replace('.o', '.png')), args=args)
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      'normal': (['-sFULL_ES2'],),
-      # Enabling FULL_ES3 also enables ES2 automatically
-      'full_es3': (['-sFULL_ES3'],),
-    }
-  )
+  @parameterized({
+    'normal': (['-sFULL_ES2'],),
+    # Enabling FULL_ES3 also enables ES2 automatically
+    'full_es3': (['-sFULL_ES3'],)
+  })
   def test_gles2_emulation(self, args):
     shutil.copy(test_file('third_party/glbook/Chapter_10/MultiTexture/basemap.tga'), '.')
     shutil.copy(test_file('third_party/glbook/Chapter_10/MultiTexture/lightmap.tga'), '.')
     shutil.copy(test_file('third_party/glbook/Chapter_13/ParticleSystem/smoke.tga'), '.')
 
     for source, reference in [
-      (
-        'third_party/glbook/Chapter_2/Hello_Triangle/Hello_Triangle_orig.c',
-        'third_party/glbook/CH02_HelloTriangle.png',
-      ),
+      ('third_party/glbook/Chapter_2/Hello_Triangle/Hello_Triangle_orig.c', 'third_party/glbook/CH02_HelloTriangle.png'),
       # ('third_party/glbook/Chapter_8/Simple_VertexShader/Simple_VertexShader_orig.c', 'third_party/glbook/CH08_SimpleVertexShader.png'), # XXX needs INT extension in WebGL
       ('third_party/glbook/Chapter_9/TextureWrap/TextureWrap_orig.c', 'third_party/glbook/CH09_TextureWrap.png'),
       # ('third_party/glbook/Chapter_9/Simple_TextureCubemap/Simple_TextureCubemap_orig.c', 'third_party/glbook/CH09_TextureCubemap.png'), # XXX needs INT extension in WebGL
-      (
-        'third_party/glbook/Chapter_9/Simple_Texture2D/Simple_Texture2D_orig.c',
-        'third_party/glbook/CH09_SimpleTexture2D.png',
-      ),
+      ('third_party/glbook/Chapter_9/Simple_Texture2D/Simple_Texture2D_orig.c', 'third_party/glbook/CH09_SimpleTexture2D.png'),
       ('third_party/glbook/Chapter_10/MultiTexture/MultiTexture_orig.c', 'third_party/glbook/CH10_MultiTexture.png'),
-      (
-        'third_party/glbook/Chapter_13/ParticleSystem/ParticleSystem_orig.c',
-        'third_party/glbook/CH13_ParticleSystem.png',
-      ),
+      ('third_party/glbook/Chapter_13/ParticleSystem/ParticleSystem_orig.c', 'third_party/glbook/CH13_ParticleSystem.png'),
     ]:
       print(source)
-      self.reftest(
-        source,
-        reference,
-        args=[
-          '-I' + test_file('third_party/glbook/Common'),
-          test_file('third_party/glbook/Common/esUtil.c'),
-          test_file('third_party/glbook/Common/esShader.c'),
-          test_file('third_party/glbook/Common/esShapes.c'),
-          test_file('third_party/glbook/Common/esTransform.c'),
-          '-lGL',
-          '-lEGL',
-          '-lX11',
-          '--preload-file',
-          'basemap.tga',
-          '--preload-file',
-          'lightmap.tga',
-          '--preload-file',
-          'smoke.tga',
-        ]
-        + args,
-      )
+      self.reftest(source, reference,
+                   args=['-I' + test_file('third_party/glbook/Common'),
+                         test_file('third_party/glbook/Common/esUtil.c'),
+                         test_file('third_party/glbook/Common/esShader.c'),
+                         test_file('third_party/glbook/Common/esShapes.c'),
+                         test_file('third_party/glbook/Common/esTransform.c'),
+                         '-lGL', '-lEGL', '-lX11',
+                         '--preload-file', 'basemap.tga', '--preload-file', 'lightmap.tga', '--preload-file', 'smoke.tga'] + args)
 
   @requires_graphics_hardware
   def test_clientside_vertex_arrays_es3(self):
-    self.reftest(
-      'clientside_vertex_arrays_es3.c', 'gl_triangle.png', args=['-sFULL_ES3', '-sUSE_GLFW=3', '-lglfw', '-lGLESv2']
-    )
+    self.reftest('clientside_vertex_arrays_es3.c', 'gl_triangle.png', args=['-sFULL_ES3', '-sUSE_GLFW=3', '-lglfw', '-lGLESv2'])
 
   def test_emscripten_api(self):
     self.btest_exit('emscripten_api_browser.c', args=['-lSDL'])
@@ -2468,28 +1829,21 @@ def test_emscripten_api(self):
   @also_with_wasmfs
   def test_emscripten_async_load_script(self):
     def setup():
-      create_file(
-        'script1.js',
-        '''
+      create_file('script1.js', '''
         Module._set(456);
-      ''',
-      )
+      ''')
       create_file('file1.txt', 'first')
       create_file('file2.txt', 'second')
 
     setup()
-    self.run_process(
-      [FILE_PACKAGER, 'test.data', '--preload', 'file1.txt', 'file2.txt'], stdout=open('script2.js', 'w')
-    )
+    self.run_process([FILE_PACKAGER, 'test.data', '--preload', 'file1.txt', 'file2.txt'], stdout=open('script2.js', 'w'))
     self.btest_exit('test_emscripten_async_load_script.c', args=['-sFORCE_FILESYSTEM'])
 
     # check using file packager to another dir
     self.clear()
     setup()
     ensure_dir('sub')
-    self.run_process(
-      [FILE_PACKAGER, 'sub/test.data', '--preload', 'file1.txt', 'file2.txt'], stdout=open('script2.js', 'w')
-    )
+    self.run_process([FILE_PACKAGER, 'sub/test.data', '--preload', 'file1.txt', 'file2.txt'], stdout=open('script2.js', 'w'))
     shutil.copy(Path('sub/test.data'), '.')
     self.btest_exit('test_emscripten_async_load_script.c', args=['-sFORCE_FILESYSTEM'])
 
@@ -2498,38 +1852,32 @@ def test_emscripten_api_infloop(self):
 
   @also_with_wasmfs
   def test_emscripten_fs_api(self):
-    shutil.copy(test_file('screenshot.png'), '.')  # preloaded *after* run
+    shutil.copy(test_file('screenshot.png'), '.') # preloaded *after* run
     self.btest_exit('emscripten_fs_api_browser.c', assert_returncode=1, args=['-lSDL'])
 
   def test_emscripten_fs_api2(self):
     self.btest_exit('emscripten_fs_api_browser2.c', assert_returncode=1, args=['-sASSERTIONS=0'])
     self.btest_exit('emscripten_fs_api_browser2.c', assert_returncode=1, args=['-sASSERTIONS=1'])
 
-  @parameterized(
-    {
-      '': ([],),
-      'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME'],),
+  })
   def test_emscripten_main_loop(self, args):
     self.btest_exit('test_emscripten_main_loop.c', args=args)
 
-  @parameterized(
-    {
-      '': ([],),
-      # test pthreads + AUTO_JS_LIBRARIES mode as well
-      'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sAUTO_JS_LIBRARIES=0'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    # test pthreads + AUTO_JS_LIBRARIES mode as well
+    'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sAUTO_JS_LIBRARIES=0'],),
+  })
   def test_emscripten_main_loop_settimeout(self, args):
     self.btest_exit('test_emscripten_main_loop_settimeout.c', args=args)
 
-  @parameterized(
-    {
-      '': ([],),
-      'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD'],),
+  })
   def test_emscripten_main_loop_and_blocker(self, args):
     self.btest_exit('test_emscripten_main_loop_and_blocker.c', args=args)
 
@@ -2538,23 +1886,19 @@ def test_emscripten_main_loop_and_blocker_exit(self):
     # app should still stay alive until the loop ends
     self.btest_exit('test_emscripten_main_loop_and_blocker.c')
 
-  @parameterized(
-    {
-      '': ([],),
-      'worker': (['--proxy-to-worker'],),
-      'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD'],),
-      'strict': (['-sSTRICT'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'worker': (['--proxy-to-worker'],),
+    'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD'],),
+    'strict': (['-sSTRICT'],),
+  })
   def test_emscripten_main_loop_setimmediate(self, args):
     self.btest_exit('test_emscripten_main_loop_setimmediate.c', args=args)
 
-  @parameterized(
-    {
-      '': ([],),
-      'O1': (['-O1'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'O1': (['-O1'],),
+  })
   def test_fs_after_main(self, args):
     self.btest_exit('test_fs_after_main.c', args=args)
 
@@ -2580,29 +1924,21 @@ def test_glframebufferattachmentinfo(self):
 
   @requires_graphics_hardware
   def test_sdl_glshader(self):
-    self.reftest(
-      'test_sdl_glshader.c',
-      'test_sdl_glshader.png',
-      args=['-O2', '--closure=1', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-sGL_ENABLE_GET_PROC_ADDRESS'],
-    )
+    self.reftest('test_sdl_glshader.c', 'test_sdl_glshader.png', args=['-O2', '--closure=1', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-sGL_ENABLE_GET_PROC_ADDRESS'])
 
   @requires_graphics_hardware
   @also_with_proxying
   def test_sdl_glshader2(self):
-    self.btest_exit(
-      'test_sdl_glshader2.c', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-sGL_ENABLE_GET_PROC_ADDRESS']
-    )
+    self.btest_exit('test_sdl_glshader2.c', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-sGL_ENABLE_GET_PROC_ADDRESS'])
 
   @requires_graphics_hardware
   def test_gl_glteximage(self):
     self.btest('gl_teximage.c', '1', args=['-lGL', '-lSDL'])
 
-  @parameterized(
-    {
-      '': ([],),
-      'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sOFFSCREEN_FRAMEBUFFER'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sOFFSCREEN_FRAMEBUFFER'],),
+  })
   @requires_graphics_hardware
   def test_gl_textures(self, args):
     self.btest_exit('gl_textures.c', args=['-lGL', '-g', '-sSTACK_SIZE=1MB'] + args)
@@ -2611,49 +1947,28 @@ def test_gl_textures(self, args):
   def test_gl_ps(self):
     # pointers and a shader
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'gl_ps.c',
-      'gl_ps.png',
-      args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '--use-preload-plugins'],
-      reference_slack=1,
-    )
+    self.reftest('gl_ps.c', 'gl_ps.png', args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '--use-preload-plugins'], reference_slack=1)
 
   @requires_graphics_hardware
   def test_gl_ps_packed(self):
     # packed data that needs to be strided
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'gl_ps_packed.c',
-      'gl_ps.png',
-      args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '--use-preload-plugins'],
-      reference_slack=1,
-    )
+    self.reftest('gl_ps_packed.c', 'gl_ps.png', args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '--use-preload-plugins'], reference_slack=1)
 
   @requires_graphics_hardware
   def test_gl_ps_strides(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'gl_ps_strides.c',
-      'gl_ps_strides.png',
-      args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '--use-preload-plugins'],
-    )
+    self.reftest('gl_ps_strides.c', 'gl_ps_strides.png', args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '--use-preload-plugins'])
 
   @requires_graphics_hardware
   @also_with_proxying
   def test_gl_ps_worker(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'gl_ps_worker.c',
-      'gl_ps.png',
-      args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '--use-preload-plugins'],
-      reference_slack=1,
-    )
+    self.reftest('gl_ps_worker.c', 'gl_ps.png', args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '--use-preload-plugins'], reference_slack=1)
 
   @requires_graphics_hardware
   def test_gl_renderers(self):
-    self.reftest(
-      'gl_renderers.c', 'gl_renderers.png', args=['-sGL_UNSAFE_OPTS=0', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL']
-    )
+    self.reftest('gl_renderers.c', 'gl_renderers.png', args=['-sGL_UNSAFE_OPTS=0', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_2gb('render fails')
@@ -2663,20 +1978,11 @@ def test_gl_stride(self):
 
   @requires_graphics_hardware
   def test_gl_vertex_buffer_pre(self):
-    self.reftest(
-      'gl_vertex_buffer_pre.c',
-      'gl_vertex_buffer_pre.png',
-      args=['-sGL_UNSAFE_OPTS=0', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('gl_vertex_buffer_pre.c', 'gl_vertex_buffer_pre.png', args=['-sGL_UNSAFE_OPTS=0', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_gl_vertex_buffer(self):
-    self.reftest(
-      'gl_vertex_buffer.c',
-      'gl_vertex_buffer.png',
-      args=['-sGL_UNSAFE_OPTS=0', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-      reference_slack=1,
-    )
+    self.reftest('gl_vertex_buffer.c', 'gl_vertex_buffer.png', args=['-sGL_UNSAFE_OPTS=0', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'], reference_slack=1)
 
   @requires_graphics_hardware
   @also_with_proxying
@@ -2689,29 +1995,17 @@ def test_gles2_conformance(self):
 
   @requires_graphics_hardware
   def test_matrix_identity(self):
-    self.btest(
-      'gl_matrix_identity.c',
-      expected=['-1882984448', '460451840', '1588195328', '2411982848'],
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.btest('gl_matrix_identity.c', expected=['-1882984448', '460451840', '1588195328', '2411982848'], args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre.c',
-      'third_party/cubegeom/cubegeom_pre.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_pre.c', 'third_party/cubegeom/cubegeom_pre.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre_regal(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre.c',
-      'third_party/cubegeom/cubegeom_pre.png',
-      args=['-sUSE_REGAL', '-DUSE_REGAL', '-lGL', '-lSDL', '-lc++', '-lc++abi'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_pre.c', 'third_party/cubegeom/cubegeom_pre.png', args=['-sUSE_REGAL', '-DUSE_REGAL', '-lGL', '-lSDL', '-lc++', '-lc++abi'])
 
   @requires_graphics_hardware
   @no_swiftshader
@@ -2719,80 +2013,50 @@ def test_cubegeom_pre_relocatable(self):
     # RELOCATABLE needs to be set via `set_setting` so that it will also apply when
     # building `browser_reporting.c`
     self.set_setting('RELOCATABLE')
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre.c',
-      'third_party/cubegeom/cubegeom_pre.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_pre.c', 'third_party/cubegeom/cubegeom_pre.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre2(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre2.c',
-      'third_party/cubegeom/cubegeom_pre2.png',
-      args=['-sGL_DEBUG', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )  # some coverage for GL_DEBUG not breaking the build
+    self.reftest('third_party/cubegeom/cubegeom_pre2.c', 'third_party/cubegeom/cubegeom_pre2.png', args=['-sGL_DEBUG', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL']) # some coverage for GL_DEBUG not breaking the build
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre3(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre3.c',
-      'third_party/cubegeom/cubegeom_pre2.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_pre3.c', 'third_party/cubegeom/cubegeom_pre2.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @also_with_proxying
-  @parameterized(
-    {
-      '': ([],),
-      'tracing': (['-sTRACE_WEBGL_CALLS'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'tracing': (['-sTRACE_WEBGL_CALLS'],),
+  })
   @requires_graphics_hardware
   def test_cubegeom(self, args):
     if self.proxied and args:
       # proxy only in the simple, normal case (we can't trace GL calls when proxied)
       self.skipTest('tracing + proxying not supported')
-    self.reftest(
-      'third_party/cubegeom/cubegeom.c',
-      'third_party/cubegeom/cubegeom.png',
-      args=['-O2', '-g', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'] + args,
-    )
+    self.reftest('third_party/cubegeom/cubegeom.c', 'third_party/cubegeom/cubegeom.png', args=['-O2', '-g', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'] + args)
 
   @requires_graphics_hardware
   @also_with_proxying
   def test_cubegeom_regal(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom.c',
-      'third_party/cubegeom/cubegeom.png',
-      args=['-O2', '-g', '-DUSE_REGAL', '-sUSE_REGAL', '-lGL', '-lSDL', '-lc++', '-lc++abi'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom.c', 'third_party/cubegeom/cubegeom.png', args=['-O2', '-g', '-DUSE_REGAL', '-sUSE_REGAL', '-lGL', '-lSDL', '-lc++', '-lc++abi'])
 
   @requires_graphics_hardware
   @also_with_proxying
   def test_cubegeom_regal_mt(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom.c',
-      'third_party/cubegeom/cubegeom.png',
-      args=['-O2', '-g', '-pthread', '-DUSE_REGAL', '-pthread', '-sUSE_REGAL', '-lGL', '-lSDL', '-lc++', '-lc++abi'],
-    )
-
-  @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ([],),
-      'O1': (['-O1'],),
-      # also test -Os in wasm, which uses meta-dce, which should not break
-      # legacy gl emulation hacks
-      'Os': (['-Os'],),
-    }
-  )
+    self.reftest('third_party/cubegeom/cubegeom.c', 'third_party/cubegeom/cubegeom.png', args=['-O2', '-g', '-pthread', '-DUSE_REGAL', '-pthread', '-sUSE_REGAL', '-lGL', '-lSDL', '-lc++', '-lc++abi'])
+
+  @requires_graphics_hardware
+  @parameterized({
+    '': ([],),
+    'O1': (['-O1'],),
+    # also test -Os in wasm, which uses meta-dce, which should not break
+    # legacy gl emulation hacks
+    'Os': (['-Os'],),
+  })
   def test_cubegeom_proc(self, opts):
-    create_file(
-      'side.c',
-      r'''
+    create_file('side.c', r'''
 
 extern void* SDL_GL_GetProcAddress(const char *);
 
@@ -2802,175 +2066,94 @@ def test_cubegeom_proc(self, opts):
   if (!glBindBuffer) glBindBuffer = SDL_GL_GetProcAddress("glBindBuffer");
   return glBindBuffer;
 }
-''',
-    )
-    self.reftest(
-      'third_party/cubegeom/cubegeom_proc.c',
-      'third_party/cubegeom/cubegeom.png',
-      args=opts + ['side.c', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-sGL_ENABLE_GET_PROC_ADDRESS'],
-    )
+''')
+    self.reftest('third_party/cubegeom/cubegeom_proc.c', 'third_party/cubegeom/cubegeom.png', args=opts + ['side.c', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-sGL_ENABLE_GET_PROC_ADDRESS'])
 
   @also_with_wasmfs
   @requires_graphics_hardware
   def test_cubegeom_glew(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_glew.c',
-      'third_party/cubegeom/cubegeom.png',
-      args=['-O2', '--closure=1', '-sLEGACY_GL_EMULATION', '-lGL', '-lGLEW', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_glew.c', 'third_party/cubegeom/cubegeom.png', args=['-O2', '--closure=1', '-sLEGACY_GL_EMULATION', '-lGL', '-lGLEW', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_color(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_color.c',
-      'third_party/cubegeom/cubegeom_color.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_color.c', 'third_party/cubegeom/cubegeom_color.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @also_with_proxying
   def test_cubegeom_normal(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_normal.c',
-      'third_party/cubegeom/cubegeom_normal.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_normal.c', 'third_party/cubegeom/cubegeom_normal.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @also_with_proxying
-  def test_cubegeom_normal_dap(self):  # draw is given a direct pointer to clientside memory, no element array buffer
-    self.reftest(
-      'third_party/cubegeom/cubegeom_normal_dap.c',
-      'third_party/cubegeom/cubegeom_normal.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+  def test_cubegeom_normal_dap(self): # draw is given a direct pointer to clientside memory, no element array buffer
+    self.reftest('third_party/cubegeom/cubegeom_normal_dap.c', 'third_party/cubegeom/cubegeom_normal.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
-  def test_cubegeom_normal_dap_far(self):  # indices do nto start from 0
-    self.reftest(
-      'third_party/cubegeom/cubegeom_normal_dap_far.c',
-      'third_party/cubegeom/cubegeom_normal.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+  def test_cubegeom_normal_dap_far(self): # indices do nto start from 0
+    self.reftest('third_party/cubegeom/cubegeom_normal_dap_far.c', 'third_party/cubegeom/cubegeom_normal.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
-  def test_cubegeom_normal_dap_far_range(self):  # glDrawRangeElements
-    self.reftest(
-      'third_party/cubegeom/cubegeom_normal_dap_far_range.c',
-      'third_party/cubegeom/cubegeom_normal.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+  def test_cubegeom_normal_dap_far_range(self): # glDrawRangeElements
+    self.reftest('third_party/cubegeom/cubegeom_normal_dap_far_range.c', 'third_party/cubegeom/cubegeom_normal.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
-  def test_cubegeom_normal_dap_far_glda(self):  # use glDrawArrays
-    self.reftest(
-      'third_party/cubegeom/cubegeom_normal_dap_far_glda.c',
-      'third_party/cubegeom/cubegeom_normal_dap_far_glda.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+  def test_cubegeom_normal_dap_far_glda(self): # use glDrawArrays
+    self.reftest('third_party/cubegeom/cubegeom_normal_dap_far_glda.c', 'third_party/cubegeom/cubegeom_normal_dap_far_glda.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_firefox('fails on CI but works locally')
-  def test_cubegeom_normal_dap_far_glda_quad(self):  # with quad
-    self.reftest(
-      'third_party/cubegeom/cubegeom_normal_dap_far_glda_quad.c',
-      'third_party/cubegeom/cubegeom_normal_dap_far_glda_quad.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+  def test_cubegeom_normal_dap_far_glda_quad(self): # with quad
+    self.reftest('third_party/cubegeom/cubegeom_normal_dap_far_glda_quad.c', 'third_party/cubegeom/cubegeom_normal_dap_far_glda_quad.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_mt(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_mt.c',
-      'third_party/cubegeom/cubegeom_mt.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )  # multitexture
+    self.reftest('third_party/cubegeom/cubegeom_mt.c', 'third_party/cubegeom/cubegeom_mt.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL']) # multitexture
 
   @requires_graphics_hardware
   @also_with_proxying
   def test_cubegeom_color2(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_color2.c',
-      'third_party/cubegeom/cubegeom_color2.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_color2.c', 'third_party/cubegeom/cubegeom_color2.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_texturematrix(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_texturematrix.c',
-      'third_party/cubegeom/cubegeom_texturematrix.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_texturematrix.c', 'third_party/cubegeom/cubegeom_texturematrix.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_fog(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_fog.c',
-      'third_party/cubegeom/cubegeom_fog.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_fog.c', 'third_party/cubegeom/cubegeom_fog.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre_vao(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre_vao.c',
-      'third_party/cubegeom/cubegeom_pre_vao.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_pre_vao.c', 'third_party/cubegeom/cubegeom_pre_vao.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre_vao_regal(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre_vao.c',
-      'third_party/cubegeom/cubegeom_pre_vao.png',
-      args=['-sUSE_REGAL', '-DUSE_REGAL', '-lGL', '-lSDL', '-lc++', '-lc++abi'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_pre_vao.c', 'third_party/cubegeom/cubegeom_pre_vao.png', args=['-sUSE_REGAL', '-DUSE_REGAL', '-lGL', '-lSDL', '-lc++', '-lc++abi'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre2_vao(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre2_vao.c',
-      'third_party/cubegeom/cubegeom_pre_vao.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-sGL_ENABLE_GET_PROC_ADDRESS'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_pre2_vao.c', 'third_party/cubegeom/cubegeom_pre_vao.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-sGL_ENABLE_GET_PROC_ADDRESS'])
 
   @requires_graphics_hardware
   def test_cubegeom_pre2_vao2(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre2_vao2.c',
-      'third_party/cubegeom/cubegeom_pre2_vao2.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-sGL_ENABLE_GET_PROC_ADDRESS'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_pre2_vao2.c', 'third_party/cubegeom/cubegeom_pre2_vao2.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-sGL_ENABLE_GET_PROC_ADDRESS'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre_vao_es(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre_vao_es.c',
-      'third_party/cubegeom/cubegeom_pre_vao.png',
-      args=['-sFULL_ES2', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_pre_vao_es.c', 'third_party/cubegeom/cubegeom_pre_vao.png', args=['-sFULL_ES2', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_row_length(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_pre_vao_es.c',
-      'third_party/cubegeom/cubegeom_pre_vao.png',
-      args=['-sFULL_ES2', '-lGL', '-lSDL', '-DUSE_UNPACK_ROW_LENGTH'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_pre_vao_es.c', 'third_party/cubegeom/cubegeom_pre_vao.png', args=['-sFULL_ES2', '-lGL', '-lSDL', '-DUSE_UNPACK_ROW_LENGTH'])
 
   @requires_graphics_hardware
   def test_cubegeom_u4fv_2(self):
-    self.reftest(
-      'third_party/cubegeom/cubegeom_u4fv_2.c',
-      'third_party/cubegeom/cubegeom_u4fv_2.png',
-      args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'],
-    )
+    self.reftest('third_party/cubegeom/cubegeom_u4fv_2.c', 'third_party/cubegeom/cubegeom_u4fv_2.png', args=['-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @also_with_proxying
@@ -3001,67 +2184,36 @@ def test_sdl_create_rgb_surface_from(self):
 
   def test_sdl_rotozoom(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl_rotozoom.c',
-      'test_sdl_rotozoom.png',
-      args=['--preload-file', 'screenshot.png', '--use-preload-plugins', '-lSDL', '-lGL'],
-      reference_slack=3,
-    )
+    self.reftest('test_sdl_rotozoom.c', 'test_sdl_rotozoom.png', args=['--preload-file', 'screenshot.png', '--use-preload-plugins', '-lSDL', '-lGL'], reference_slack=3)
 
   def test_sdl_gfx_primitives(self):
     self.reftest('test_sdl_gfx_primitives.c', 'test_sdl_gfx_primitives.png', args=['-lSDL', '-lGL'], reference_slack=1)
 
   def test_sdl_canvas_palette_2(self):
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       Module['preRun'] = () => {
         SDL.defaults.copyOnLock = false;
       };
-    ''',
-    )
+    ''')
 
-    create_file(
-      'args-r.js',
-      '''
+    create_file('args-r.js', '''
       Module['arguments'] = ['-r'];
-    ''',
-    )
+    ''')
 
-    create_file(
-      'args-g.js',
-      '''
+    create_file('args-g.js', '''
       Module['arguments'] = ['-g'];
-    ''',
-    )
+    ''')
 
-    create_file(
-      'args-b.js',
-      '''
+    create_file('args-b.js', '''
       Module['arguments'] = ['-b'];
-    ''',
-    )
-
-    self.reftest(
-      'test_sdl_canvas_palette_2.c',
-      'test_sdl_canvas_palette_r.png',
-      args=['--pre-js', 'pre.js', '--pre-js', 'args-r.js', '-lSDL', '-lGL'],
-    )
-    self.reftest(
-      'test_sdl_canvas_palette_2.c',
-      'test_sdl_canvas_palette_g.png',
-      args=['--pre-js', 'pre.js', '--pre-js', 'args-g.js', '-lSDL', '-lGL'],
-    )
-    self.reftest(
-      'test_sdl_canvas_palette_2.c',
-      'test_sdl_canvas_palette_b.png',
-      args=['--pre-js', 'pre.js', '--pre-js', 'args-b.js', '-lSDL', '-lGL'],
-    )
+    ''')
+
+    self.reftest('test_sdl_canvas_palette_2.c', 'test_sdl_canvas_palette_r.png', args=['--pre-js', 'pre.js', '--pre-js', 'args-r.js', '-lSDL', '-lGL'])
+    self.reftest('test_sdl_canvas_palette_2.c', 'test_sdl_canvas_palette_g.png', args=['--pre-js', 'pre.js', '--pre-js', 'args-g.js', '-lSDL', '-lGL'])
+    self.reftest('test_sdl_canvas_palette_2.c', 'test_sdl_canvas_palette_b.png', args=['--pre-js', 'pre.js', '--pre-js', 'args-b.js', '-lSDL', '-lGL'])
 
   def test_sdl_ttf_render_text_solid(self):
-    self.reftest(
-      'test_sdl_ttf_render_text_solid.c', 'test_sdl_ttf_render_text_solid.png', args=['-O2', '-lSDL', '-lGL']
-    )
+    self.reftest('test_sdl_ttf_render_text_solid.c', 'test_sdl_ttf_render_text_solid.png', args=['-O2', '-lSDL', '-lGL'])
 
   def test_sdl_alloctext(self):
     self.btest_exit('test_sdl_alloctext.c', args=['-lSDL', '-lGL'])
@@ -3075,44 +2227,26 @@ def test_sdl_free_screen(self):
   @requires_graphics_hardware
   def test_glbegin_points(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'glbegin_points.c',
-      'glbegin_points.png',
-      args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '--use-preload-plugins'],
-    )
+    self.reftest('glbegin_points.c', 'glbegin_points.png', args=['--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '--use-preload-plugins'])
 
   @requires_graphics_hardware
   def test_s3tc(self):
     shutil.copy(test_file('screenshot.dds'), '.')
-    self.reftest(
-      's3tc.c', 's3tc.png', args=['--preload-file', 'screenshot.dds', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL']
-    )
+    self.reftest('s3tc.c', 's3tc.png', args=['--preload-file', 'screenshot.dds', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_s3tc_ffp_only(self):
     shutil.copy(test_file('screenshot.dds'), '.')
-    self.reftest(
-      's3tc.c',
-      's3tc.png',
-      args=['--preload-file', 'screenshot.dds', '-sLEGACY_GL_EMULATION', '-sGL_FFP_ONLY', '-lGL', '-lSDL'],
-    )
-
-  @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ([],),
-      'subimage': (['-DTEST_TEXSUBIMAGE'],),
-    }
-  )
+    self.reftest('s3tc.c', 's3tc.png', args=['--preload-file', 'screenshot.dds', '-sLEGACY_GL_EMULATION', '-sGL_FFP_ONLY', '-lGL', '-lSDL'])
+
+  @requires_graphics_hardware
+  @parameterized({
+    '': ([],),
+    'subimage': (['-DTEST_TEXSUBIMAGE'],),
+  })
   def test_anisotropic(self, args):
     shutil.copy(test_file('browser/water.dds'), '.')
-    self.reftest(
-      'test_anisotropic.c',
-      'test_anisotropic.png',
-      reference_slack=2,
-      args=['--preload-file', 'water.dds', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-Wno-incompatible-pointer-types']
-      + args,
-    )
+    self.reftest('test_anisotropic.c', 'test_anisotropic.png', reference_slack=2, args=['--preload-file', 'water.dds', '-sLEGACY_GL_EMULATION', '-lGL', '-lSDL', '-Wno-incompatible-pointer-types'] + args)
 
   @requires_graphics_hardware
   def test_tex_nonbyte(self):
@@ -3123,16 +2257,12 @@ def test_float_tex(self):
     self.reftest('float_tex.c', 'float_tex.png', args=['-lGL', '-lglut'])
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ([],),
-      'tracing': (['-sTRACE_WEBGL_CALLS'],),
-      'es2': (['-sMIN_WEBGL_VERSION=2', '-sFULL_ES2', '-sWEBGL2_BACKWARDS_COMPATIBILITY_EMULATION'],),
-      'es2_tracing': (
-        ['-sMIN_WEBGL_VERSION=2', '-sFULL_ES2', '-sWEBGL2_BACKWARDS_COMPATIBILITY_EMULATION', '-sTRACE_WEBGL_CALLS'],
-      ),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'tracing': (['-sTRACE_WEBGL_CALLS'],),
+    'es2': (['-sMIN_WEBGL_VERSION=2', '-sFULL_ES2', '-sWEBGL2_BACKWARDS_COMPATIBILITY_EMULATION'],),
+    'es2_tracing': (['-sMIN_WEBGL_VERSION=2', '-sFULL_ES2', '-sWEBGL2_BACKWARDS_COMPATIBILITY_EMULATION', '-sTRACE_WEBGL_CALLS'],),
+  })
   def test_subdata(self, args):
     if self.is_4gb() and '-sMIN_WEBGL_VERSION=2' in args:
       self.skipTest('texSubImage2D fails: https://crbug.com/325090165')
@@ -3146,13 +2276,11 @@ def test_perspective(self):
   def test_glerror(self):
     self.btest('gl_error.c', expected='1', args=['-sLEGACY_GL_EMULATION', '-lGL'])
 
-  @parameterized(
-    {
-      '': ([],),
-      'strict': (['-lopenal', '-sSTRICT'],),
-      'closure': (['--closure=1'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'strict': (['-lopenal', '-sSTRICT'],),
+    'closure': (['--closure=1'],),
+  })
   def test_openal_error(self, args):
     self.btest_exit('openal/test_openal_error.c', args=args)
 
@@ -3163,18 +2291,13 @@ def test_openal_extensions(self):
     self.btest_exit('openal/test_openal_extensions.c')
 
   def test_runtimelink(self):
-    create_file(
-      'header.h',
-      r'''
+    create_file('header.h', r'''
       struct point {
         int x, y;
       };
-    ''',
-    )
+    ''')
 
-    create_file(
-      'supp.c',
-      r'''
+    create_file('supp.c', r'''
       #include <stdio.h>
       #include "header.h"
 
@@ -3188,12 +2311,9 @@ def test_runtimelink(self):
       }
 
       int suppInt = 76;
-    ''',
-    )
+    ''')
 
-    create_file(
-      'main.c',
-      r'''
+    create_file('main.c', r'''
       #include <stdio.h>
       #include <assert.h>
       #include "header.h"
@@ -3215,17 +2335,14 @@ def test_runtimelink(self):
         assert(suppInt == 76);
         return 0;
       }
-    ''',
-    )
+    ''')
     self.run_process([EMCC, 'supp.c', '-o', 'supp.wasm', '-sSIDE_MODULE', '-O2'] + self.get_emcc_args())
     self.btest_exit('main.c', args=['-sMAIN_MODULE=2', '-O2', 'supp.wasm'])
 
   @also_with_wasm2js
   def test_pre_run_deps(self):
     # Adding a dependency in preRun will delay run
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       Module.preRun = () => {
         addRunDependency();
         out('preRun called, added a dependency...');
@@ -3234,8 +2351,7 @@ def test_pre_run_deps(self):
           removeRunDependency()
         }, 2000);
       };
-    ''',
-    )
+    ''')
 
     self.btest('test_pre_run_deps.c', expected='10', args=['--pre-js', 'pre.js'])
 
@@ -3292,8 +2408,7 @@ def test_runtime_misuse(self):
       assert(ok === expected_ok);
     '''
 
-    post_hook = (
-      r'''
+    post_hook = r'''
       function myJSCallback() {
         // Run on the next event loop, as code may run in a postRun right after main().
         setTimeout(async () => {
@@ -3307,59 +2422,31 @@ def test_runtime_misuse(self):
         doCwrapCall(200);
         doDirectCall(300);
       }
-    '''
-      % self.PORT
-    )
+    ''' % self.PORT
 
-    create_file(
-      'pre_runtime.js',
-      r'''
+    create_file('pre_runtime.js', r'''
       Module.onRuntimeInitialized = myJSCallback;
-    ''',
-    )
+    ''')
 
     for filename, extra_args, second_code in [
       ('test_runtime_misuse.c', [], 600),
-      (
-        'test_runtime_misuse_2.c',
-        ['--pre-js', 'pre_runtime.js'],
-        601,
-      ),  # 601, because no main means we *do* run another call after exit()
+      ('test_runtime_misuse_2.c', ['--pre-js', 'pre_runtime.js'], 601) # 601, because no main means we *do* run another call after exit()
     ]:
       print('\n', filename, extra_args)
 
       print('mem init, so async, call too early')
       create_file('post.js', post_prep + post_test + post_hook)
-      self.btest(
-        filename, expected='600', args=['--post-js', 'post.js', '-sEXIT_RUNTIME'] + extra_args, reporting=Reporting.NONE
-      )
+      self.btest(filename, expected='600', args=['--post-js', 'post.js', '-sEXIT_RUNTIME'] + extra_args, reporting=Reporting.NONE)
       print('sync startup, call too late')
       create_file('post.js', post_prep + 'Module.postRun = () => { ' + post_test + ' };' + post_hook)
-      self.btest(
-        filename,
-        expected=str(second_code),
-        args=['--post-js', 'post.js', '-sEXIT_RUNTIME'] + extra_args,
-        reporting=Reporting.NONE,
-      )
+      self.btest(filename, expected=str(second_code), args=['--post-js', 'post.js', '-sEXIT_RUNTIME'] + extra_args, reporting=Reporting.NONE)
 
       print('sync, runtime still alive, so all good')
-      create_file(
-        'post.js', post_prep + 'expected_ok = true; Module.postRun = () => { ' + post_test + ' };' + post_hook
-      )
+      create_file('post.js', post_prep + 'expected_ok = true; Module.postRun = () => { ' + post_test + ' };' + post_hook)
       self.btest(filename, expected='606', args=['--post-js', 'post.js'] + extra_args, reporting=Reporting.NONE)
 
   def test_cwrap_early(self):
-    self.btest(
-      'browser/test_cwrap_early.c',
-      args=[
-        '-O2',
-        '-sASSERTIONS',
-        '--pre-js',
-        test_file('browser/test_cwrap_early.js'),
-        '-sEXPORTED_RUNTIME_METHODS=cwrap',
-      ],
-      expected='0',
-    )
+    self.btest('browser/test_cwrap_early.c', args=['-O2', '-sASSERTIONS', '--pre-js', test_file('browser/test_cwrap_early.js'), '-sEXPORTED_RUNTIME_METHODS=cwrap'], expected='0')
 
   @no_wasm64('TODO: wasm64 + BUILD_AS_WORKER')
   def test_worker_api(self):
@@ -3368,18 +2455,7 @@ def test_worker_api(self):
 
   @no_wasm64('TODO: wasm64 + BUILD_AS_WORKER')
   def test_worker_api_2(self):
-    self.compile_btest(
-      'worker_api_2_worker.cpp',
-      [
-        '-o',
-        'worker.js',
-        '-sBUILD_AS_WORKER',
-        '-O2',
-        '--minify=0',
-        '-sEXPORTED_FUNCTIONS=_one,_two,_three,_four',
-        '--closure=1',
-      ],
-    )
+    self.compile_btest('worker_api_2_worker.cpp', ['-o', 'worker.js', '-sBUILD_AS_WORKER', '-O2', '--minify=0', '-sEXPORTED_FUNCTIONS=_one,_two,_three,_four', '--closure=1'])
     self.btest('worker_api_2_main.cpp', args=['-O2', '--minify=0'], expected='11')
 
   @no_wasm64('TODO: wasm64 + BUILD_AS_WORKER')
@@ -3389,19 +2465,14 @@ def test_worker_api_3(self):
 
   @no_wasm64('TODO: wasm64 + BUILD_AS_WORKER')
   def test_worker_api_sleep(self):
-    self.compile_btest(
-      'worker_api_worker_sleep.cpp', ['-o', 'worker.js', '-sBUILD_AS_WORKER', '-sEXPORTED_FUNCTIONS=_one', '-sASYNCIFY']
-    )
+    self.compile_btest('worker_api_worker_sleep.cpp', ['-o', 'worker.js', '-sBUILD_AS_WORKER', '-sEXPORTED_FUNCTIONS=_one', '-sASYNCIFY'])
     self.btest('worker_api_main.cpp', expected='566')
 
   @no_wasm64('TODO: wasm64 + BUILD_AS_WORKER')
   def test_worker_api_with_pthread_compilation_fails(self):
     self.run_process([EMCC, '-c', '-o', 'hello.o', test_file('hello_world.c')])
     stderr = self.expect_fail([EMCC, 'hello.o', '-o', 'a.js', '-g', '--closure=1', '-pthread', '-sBUILD_AS_WORKER'])
-    self.assertContained(
-      "pthreads + BUILD_AS_WORKER require separate modes that don't work together, see https://github.com/emscripten-core/emscripten/issues/8854",
-      stderr,
-    )
+    self.assertContained("pthreads + BUILD_AS_WORKER require separate modes that don't work together, see https://github.com/emscripten-core/emscripten/issues/8854", stderr)
 
   @also_with_wasmfs
   def test_emscripten_async_wget2(self):
@@ -3416,21 +2487,19 @@ def test_emscripten_async_wget_side_module(self):
     self.emcc(test_file('browser_module.c'), ['-o', 'lib.wasm', '-O2', '-sSIDE_MODULE'])
     self.btest_exit('browser_main.c', args=['-O2', '-sMAIN_MODULE=2'])
 
-  @parameterized({'': ([],), 'lz4': (['-sLZ4'],)})
+  @parameterized({
+    '': ([],),
+    'lz4': (['-sLZ4'],)
+  })
   def test_preload_module(self, args):
-    create_file(
-      'library.c',
-      r'''
+    create_file('library.c', r'''
       #include <stdio.h>
       int library_func() {
         return 42;
       }
-    ''',
-    )
+    ''')
     self.emcc('library.c', ['-sSIDE_MODULE', '-O2', '-o', 'library.so'])
-    create_file(
-      'main.c',
-      r'''
+    create_file('main.c', r'''
       #include <assert.h>
       #include <dlfcn.h>
       #include <stdio.h>
@@ -3448,35 +2517,20 @@ def test_preload_module(self, args):
         assert(x() == 42);
         return 0;
       }
-    ''',
-    )
-    self.btest_exit('main.c', args=['-sMAIN_MODULE=2', '--preload-file', '.@/', '--use-preload-plugins'] + args)
+    ''')
+    self.btest_exit(
+      'main.c',
+      args=['-sMAIN_MODULE=2', '--preload-file', '.@/', '--use-preload-plugins'] + args)
 
   # This does not actually verify anything except that --cpuprofiler and --memoryprofiler compiles.
   # Run interactive.test_cpuprofiler_memoryprofiler for interactive testing.
   @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ([],),
-      'modularized': (
-        ['-sMODULARIZE=1', '-sEXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')],
-      ),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'modularized': (['-sMODULARIZE=1', '-sEXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')],),
+  })
   def test_cpuprofiler_memoryprofiler(self, opts):
-    self.btest_exit(
-      'hello_world_gles.c',
-      args=[
-        '-DLONGTEST=1',
-        '-DTEST_MEMORYPROFILER_ALLOCATIONS_MAP=1',
-        '--cpuprofiler',
-        '--memoryprofiler',
-        '-lGL',
-        '-lglut',
-        '-DANIMATE',
-      ]
-      + opts,
-    )
+    self.btest_exit('hello_world_gles.c', args=['-DLONGTEST=1', '-DTEST_MEMORYPROFILER_ALLOCATIONS_MAP=1', '--cpuprofiler', '--memoryprofiler', '-lGL', '-lglut', '-DANIMATE'] + opts)
 
   def test_uuid(self):
     self.btest_exit('test_uuid.c', args=['-luuid'])
@@ -3489,54 +2543,44 @@ def test_glew(self):
     self.btest('glew.c', args=['-lGL', '-lSDL', '-lGLEW', '-sLEGACY_GL_EMULATION', '-DGLEW_MX'], expected='1')
 
   def test_doublestart_bug(self):
-    create_file(
-      'pre.js',
-      r'''
+    create_file('pre.js', r'''
 Module["preRun"] = () => {
   addRunDependency('test_run_dependency');
   removeRunDependency('test_run_dependency');
 };
-''',
-    )
+''')
 
     self.btest('doublestart.c', args=['--pre-js', 'pre.js'], expected='1')
 
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['-O2', '-g1', '--closure=1', '-sHTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS=0'],),
-      'pthread': (['-pthread'],),
-      'proxy_to_pthread': (['-pthread', '-sPROXY_TO_PTHREAD'],),
-      'legacy': (['-sMIN_FIREFOX_VERSION=0', '-sMIN_SAFARI_VERSION=0', '-sMIN_CHROME_VERSION=0', '-Wno-transpile'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['-O2', '-g1', '--closure=1', '-sHTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS=0'],),
+    'pthread': (['-pthread'],),
+    'proxy_to_pthread': (['-pthread', '-sPROXY_TO_PTHREAD'],),
+    'legacy': (['-sMIN_FIREFOX_VERSION=0', '-sMIN_SAFARI_VERSION=0', '-sMIN_CHROME_VERSION=0', '-Wno-transpile'],)
+  })
   def test_html5_core(self, opts):
     if self.is_wasm64() and '-sMIN_CHROME_VERSION=0' in opts:
       self.skipTest('wasm64 does not support older browsers')
     if '-sHTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS=0' in opts:
       # In this mode an exception can be thrown by the browser, and we don't
       # want the test to fail in that case so we override the error handling.
-      create_file(
-        'pre.js',
-        '''
+      create_file('pre.js', '''
       window.disableErrorReporting = true;
       window.addEventListener('error', (event) => {
         if (!event.message.includes('exception:fullscreen error')) {
           reportTopLevelError(event);
         }
       });
-      ''',
-      )
+      ''')
       self.emcc_args.append('--pre-js=pre.js')
     self.btest_exit('test_html5_core.c', args=opts)
 
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['-O2', '-g1', '--closure=1'],),
-      'pthread': (['-pthread', '-sPROXY_TO_PTHREAD'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['-O2', '-g1', '--closure=1'],),
+    'pthread': (['-pthread', '-sPROXY_TO_PTHREAD'],),
+  })
   def test_html5_gamepad(self, args):
     self.btest_exit('test_gamepad.c', args=args)
 
@@ -3544,26 +2588,22 @@ def test_html5_unknown_event_target(self):
     self.btest_exit('test_html5_unknown_event_target.c')
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['-O2', '-g1', '--closure=1'],),
-      'full_es2': (['-sFULL_ES2'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['-O2', '-g1', '--closure=1'],),
+    'full_es2': (['-sFULL_ES2'],),
+  })
   def test_html5_webgl_create_context_no_antialias(self, args):
     self.btest_exit('webgl_create_context.cpp', args=args + ['-DNO_ANTIALIAS', '-lGL'])
 
   # This test supersedes the one above, but it's skipped in the CI because anti-aliasing is not well supported by the Mesa software renderer.
   @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['-O2', '-g1', '--closure=1'],),
-      'full_es2': (['-sFULL_ES2'],),
-      'pthread': (['-pthread'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['-O2', '-g1', '--closure=1'],),
+    'full_es2': (['-sFULL_ES2'],),
+    'pthread': (['-pthread'],),
+  })
   def test_html5_webgl_create_context(self, args):
     self.btest_exit('webgl_create_context.cpp', args=args + ['-lGL'])
 
@@ -3574,12 +2614,10 @@ def test_html5_webgl_create_context2(self):
 
   @requires_graphics_hardware
   # Verify bug https://github.com/emscripten-core/emscripten/issues/22943: creating a WebGL context with explicit swap control and offscreenCanvas
-  @parameterized(
-    {
-      'offscreencanvas': (['-sOFFSCREENCANVAS_SUPPORT'],),
-      'offscreenframebuffer': (['-sOFFSCREEN_FRAMEBUFFER', '-DUSE_OFFSCREEN_FRAMEBUFFER'],),
-    }
-  )
+  @parameterized({
+    'offscreencanvas': (['-sOFFSCREENCANVAS_SUPPORT'],),
+    'offscreenframebuffer': (['-sOFFSCREEN_FRAMEBUFFER', '-DUSE_OFFSCREEN_FRAMEBUFFER'],),
+  })
   def test_html5_webgl_create_context_swapcontrol(self, args):
     self.btest_exit('browser/webgl_create_context_swapcontrol.c', args=args)
 
@@ -3593,10 +2631,7 @@ def test_html5_special_event_targets(self):
   def test_html5_webgl_destroy_context(self):
     for opts in ([], ['-O2', '-g1'], ['-sFULL_ES2']):
       print(opts)
-      self.btest_exit(
-        'webgl_destroy_context.cpp',
-        args=opts + ['--shell-file', test_file('browser/webgl_destroy_context_shell.html'), '-lGL'],
-      )
+      self.btest_exit('webgl_destroy_context.cpp', args=opts + ['--shell-file', test_file('browser/webgl_destroy_context_shell.html'), '-lGL'])
 
   @requires_graphics_hardware
   def test_webgl_context_params(self):
@@ -3615,13 +2650,11 @@ def test_webgl_unmasked_vendor_webgl(self):
     self.btest_exit('webgl_unmasked_vendor_webgl.c', args=['-lGL'])
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      'legacy_browser': (['-sMIN_CHROME_VERSION=0', '-Wno-transpile'],),
-      'closure': (['-O2', '-g1', '--closure=1'],),
-      'full_es2': (['-sFULL_ES2'],),
-    }
-  )
+  @parameterized({
+    'legacy_browser': (['-sMIN_CHROME_VERSION=0', '-Wno-transpile'],),
+    'closure': (['-O2', '-g1', '--closure=1'],),
+    'full_es2': (['-sFULL_ES2'],),
+  })
   def test_webgl2(self, args):
     if '-sMIN_CHROME_VERSION=0' in args and self.is_wasm64():
       self.skipTest('wasm64 not supported by legacy browsers')
@@ -3644,33 +2677,22 @@ def test_webgl2_objects(self):
     self.btest_exit('webgl2_objects.cpp', args=['-sMAX_WEBGL_VERSION=2', '-lGL'])
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ([],),
-      'offscreencanvas': (['-sOFFSCREENCANVAS_SUPPORT', '-pthread', '-sPROXY_TO_PTHREAD'],),
-      'offscreenframbuffer': (['-sOFFSCREEN_FRAMEBUFFER', '-pthread', '-sPROXY_TO_PTHREAD'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'offscreencanvas': (['-sOFFSCREENCANVAS_SUPPORT', '-pthread', '-sPROXY_TO_PTHREAD'],),
+    'offscreenframbuffer': (['-sOFFSCREEN_FRAMEBUFFER', '-pthread', '-sPROXY_TO_PTHREAD'],),
+  })
   def test_html5_webgl_api(self, args):
     if '-sOFFSCREENCANVAS_SUPPORT' in args and os.getenv('EMTEST_LACKS_OFFSCREEN_CANVAS'):
       return
     self.btest_exit('html5_webgl.c', args=['-sMAX_WEBGL_VERSION=2', '-lGL'] + args)
 
-  @parameterized(
-    {
-      'webgl1': (['-DWEBGL_VERSION=1'],),
-      'webgl2': (['-sMAX_WEBGL_VERSION=2', '-DWEBGL_VERSION=2'],),
-      'webgl1_extensions': (['-DWEBGL_VERSION=1', '-sGL_EXPLICIT_UNIFORM_LOCATION'],),
-      'webgl2_extensions': (
-        [
-          '-sMAX_WEBGL_VERSION=2',
-          '-DWEBGL_VERSION=2',
-          '-sGL_EXPLICIT_UNIFORM_LOCATION',
-          '-sGL_EXPLICIT_UNIFORM_BINDING',
-        ],
-      ),
-    }
-  )
+  @parameterized({
+    'webgl1': (['-DWEBGL_VERSION=1'],),
+    'webgl2': (['-sMAX_WEBGL_VERSION=2', '-DWEBGL_VERSION=2'],),
+    'webgl1_extensions': (['-DWEBGL_VERSION=1', '-sGL_EXPLICIT_UNIFORM_LOCATION'],),
+    'webgl2_extensions': (['-sMAX_WEBGL_VERSION=2', '-DWEBGL_VERSION=2', '-sGL_EXPLICIT_UNIFORM_LOCATION', '-sGL_EXPLICIT_UNIFORM_BINDING'],),
+  })
   @requires_graphics_hardware
   def test_webgl_preprocessor_variables(self, opts):
     self.btest_exit('webgl_preprocessor_variables.c', args=['-lGL'] + opts)
@@ -3680,12 +2702,10 @@ def test_webgl2_ubos(self):
     self.btest_exit('webgl2_ubos.cpp', args=['-sMAX_WEBGL_VERSION=2', '-lGL'])
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ([],),
-      'webgl2': (['-sMAX_WEBGL_VERSION=2', '-DTEST_WEBGL2=1'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'webgl2': (['-sMAX_WEBGL_VERSION=2', '-DTEST_WEBGL2=1'],),
+  })
   def test_webgl2_garbage_free_entrypoints(self, args):
     if args and self.is_4gb():
       self.skipTest('readPixels fails: https://crbug.com/324992397')
@@ -3693,10 +2713,7 @@ def test_webgl2_garbage_free_entrypoints(self, args):
 
   @requires_graphics_hardware
   def test_webgl2_backwards_compatibility_emulation(self):
-    self.btest_exit(
-      'webgl2_backwards_compatibility_emulation.cpp',
-      args=['-sMAX_WEBGL_VERSION=2', '-sWEBGL2_BACKWARDS_COMPATIBILITY_EMULATION'],
-    )
+    self.btest_exit('webgl2_backwards_compatibility_emulation.cpp', args=['-sMAX_WEBGL_VERSION=2', '-sWEBGL2_BACKWARDS_COMPATIBILITY_EMULATION'])
 
   @requires_graphics_hardware
   def test_webgl2_runtime_no_context(self):
@@ -3726,52 +2743,40 @@ def test_webgl2_pbo(self):
   @no_firefox('fails on CI likely due to GPU drivers there')
   @requires_graphics_hardware
   def test_webgl2_sokol_mipmap(self):
-    self.reftest(
-      'third_party/sokol/mipmap-emsc.c',
-      'third_party/sokol/mipmap-emsc.png',
-      args=['-sMAX_WEBGL_VERSION=2', '-lGL', '-O1'],
-      reference_slack=2,
-    )
+    self.reftest('third_party/sokol/mipmap-emsc.c', 'third_party/sokol/mipmap-emsc.png',
+                 args=['-sMAX_WEBGL_VERSION=2', '-lGL', '-O1'], reference_slack=2)
 
   @no_firefox('fails on CI likely due to GPU drivers there')
   @no_4gb('fails to render')
   @requires_graphics_hardware
   def test_webgl2_sokol_mrt(self):
-    self.reftest(
-      'third_party/sokol/mrt-emcc.c', 'third_party/sokol/mrt-emcc.png', args=['-sMAX_WEBGL_VERSION=2', '-lGL']
-    )
+    self.reftest('third_party/sokol/mrt-emcc.c', 'third_party/sokol/mrt-emcc.png',
+                 args=['-sMAX_WEBGL_VERSION=2', '-lGL'])
 
   @requires_graphics_hardware
   @no_4gb('fails to render')
   def test_webgl2_sokol_arraytex(self):
-    self.reftest(
-      'third_party/sokol/arraytex-emsc.c', 'third_party/sokol/arraytex-emsc.png', args=['-sMAX_WEBGL_VERSION=2', '-lGL']
-    )
-
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['-O2', '-g1', '--closure=1'],),
-    }
-  )
+    self.reftest('third_party/sokol/arraytex-emsc.c', 'third_party/sokol/arraytex-emsc.png',
+                 args=['-sMAX_WEBGL_VERSION=2', '-lGL'])
+
+  @parameterized({
+    '': ([],),
+    'closure': (['-O2', '-g1', '--closure=1'],),
+  })
   def test_sdl_touch(self, opts):
     self.btest_exit('test_sdl_touch.c', args=opts + ['-DAUTOMATE_SUCCESS=1', '-lSDL', '-lGL'])
 
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['-O2', '-g1', '--closure=1'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['-O2', '-g1', '--closure=1'],),
+  })
   def test_html5_mouse(self, opts):
     self.btest('test_html5_mouse.c', args=opts + ['-DAUTOMATE_SUCCESS=1'], expected='0')
 
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['-O2', '-g1', '--closure=1'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['-O2', '-g1', '--closure=1'],),
+  })
   def test_sdl_mousewheel(self, opts):
     self.btest_exit('test_sdl_mousewheel.c', args=opts + ['-DAUTOMATE_SUCCESS=1', '-lSDL', '-lGL'])
 
@@ -3785,17 +2790,13 @@ def test_wget_data(self):
     self.btest_exit('test_wget_data.c', args=['-O2', '-g2', '-sASYNCIFY'])
 
   @also_with_wasm2js
-  @parameterized(
-    {
-      '': ([],),
-      'es6': (['-sEXPORT_ES6'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'es6': (['-sEXPORT_ES6'],),
+  })
   def test_locate_file(self, args):
     self.set_setting('EXIT_RUNTIME')
-    create_file(
-      'src.c',
-      r'''
+    create_file('src.c', r'''
       #include <stdio.h>
       #include <string.h>
       #include <assert.h>
@@ -3811,17 +2812,12 @@ def test_locate_file(self, args):
         assert(strcmp("load me right before", buf) == 0);
         return 0;
       }
-    ''',
-    )
+    ''')
     create_file('data.txt', 'load me right before...')
     create_file('pre.js', 'Module.locateFile = (x) => "sub/" + x;')
     self.run_process([FILE_PACKAGER, 'test.data', '--preload', 'data.txt'], stdout=open('data.js', 'w'))
     # put pre.js first, then the file packager data, so locateFile is there for the file loading code
-    self.compile_btest(
-      'src.c',
-      ['-O2', '-g', '--pre-js', 'pre.js', '--pre-js', 'data.js', '-o', 'page.html', '-sFORCE_FILESYSTEM'] + args,
-      reporting=Reporting.JS_ONLY,
-    )
+    self.compile_btest('src.c', ['-O2', '-g', '--pre-js', 'pre.js', '--pre-js', 'data.js', '-o', 'page.html', '-sFORCE_FILESYSTEM'] + args, reporting=Reporting.JS_ONLY)
     ensure_dir('sub')
     if self.is_wasm():
       shutil.move('page.wasm', Path('sub/page.wasm'))
@@ -3831,9 +2827,7 @@ def test_locate_file(self, args):
     # alternatively, put locateFile in the HTML
     print('in html')
 
-    create_file(
-      'shell.html',
-      '''
+    create_file('shell.html', '''
       <body>
         <script>
           var Module = {
@@ -3843,28 +2837,10 @@ def test_locate_file(self, args):
 
         {{{ SCRIPT }}}
       </body>
-    ''',
-    )
+    ''')
 
     def in_html(expected):
-      self.compile_btest(
-        'src.c',
-        [
-          '-O2',
-          '-g',
-          '--shell-file',
-          'shell.html',
-          '--pre-js',
-          'data.js',
-          '-o',
-          'page.html',
-          '-sSAFE_HEAP',
-          '-sASSERTIONS',
-          '-sFORCE_FILESYSTEM',
-        ]
-        + args,
-        reporting=Reporting.JS_ONLY,
-      )
+      self.compile_btest('src.c', ['-O2', '-g', '--shell-file', 'shell.html', '--pre-js', 'data.js', '-o', 'page.html', '-sSAFE_HEAP', '-sASSERTIONS', '-sFORCE_FILESYSTEM'] + args, reporting=Reporting.JS_ONLY)
       if self.is_wasm():
         shutil.move('page.wasm', Path('sub/page.wasm'))
       self.run_browser('page.html', '/report_result?exit:' + expected)
@@ -3876,28 +2852,22 @@ def test_glfw3_default_hints(self):
     self.btest_exit('test_glfw3_default_hints.c', args=['-sUSE_GLFW=3', '-lglfw', '-lGL'])
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      'no_gl': (['-DCLIENT_API=GLFW_NO_API'],),
-      'gl_es': (['-DCLIENT_API=GLFW_OPENGL_ES_API', '-sGL_ENABLE_GET_PROC_ADDRESS'],),
-    }
-  )
+  @parameterized({
+    'no_gl': (['-DCLIENT_API=GLFW_NO_API'],),
+    'gl_es': (['-DCLIENT_API=GLFW_OPENGL_ES_API', '-sGL_ENABLE_GET_PROC_ADDRESS'],)
+  })
   def test_glfw3(self, args):
     for opts in ([], ['-sLEGACY_GL_EMULATION'], ['-Os', '--closure=1']):
       print(opts)
       self.btest('test_glfw3.c', args=['-sUSE_GLFW=3', '-lglfw', '-lGL'] + args + opts, expected='1')
 
-  @parameterized(
-    {
-      '': (['-sUSE_GLFW=2', '-DUSE_GLFW=2'],),
-      'glfw3': (['-sUSE_GLFW=3', '-DUSE_GLFW=3'],),
-    }
-  )
+  @parameterized({
+    '': (['-sUSE_GLFW=2', '-DUSE_GLFW=2'],),
+    'glfw3': (['-sUSE_GLFW=3', '-DUSE_GLFW=3'],),
+  })
   @requires_graphics_hardware
   def test_glfw_events(self, args):
-    self.btest_exit(
-      'test_glfw_events.c', args=args + ['-lglfw', '-lGL', '--pre-js', test_file('browser/fake_events.js')]
-    )
+    self.btest_exit('test_glfw_events.c', args=args + ['-lglfw', '-lGL', '--pre-js', test_file('browser/fake_events.js')])
 
   @requires_graphics_hardware
   def test_glfw3_hi_dpi_aware(self):
@@ -3913,83 +2883,46 @@ def test_sdl2_image(self):
     # load an image file, get pixel data. Also O2 coverage for --preload-file
     shutil.copy(test_file('screenshot.jpg'), '.')
 
-    for dest, dirname, basename in [
-      ('screenshot.jpg', '/', 'screenshot.jpg'),
-      ('screenshot.jpg@/assets/screenshot.jpg', '/assets', 'screenshot.jpg'),
-    ]:
-      self.btest_exit(
-        'test_sdl2_image.c',
-        600,
-        args=[
-          '-O2',
-          '--preload-file',
-          dest,
-          '-DSCREENSHOT_DIRNAME="' + dirname + '"',
-          '-DSCREENSHOT_BASENAME="' + basename + '"',
-          '-sUSE_SDL=2',
-          '-sUSE_SDL_IMAGE=2',
-          '--use-preload-plugins',
-        ],
-      )
+    for dest, dirname, basename in [('screenshot.jpg', '/', 'screenshot.jpg'),
+                                    ('screenshot.jpg@/assets/screenshot.jpg', '/assets', 'screenshot.jpg')]:
+      self.btest_exit('test_sdl2_image.c', 600, args=[
+        '-O2',
+        '--preload-file', dest,
+        '-DSCREENSHOT_DIRNAME="' + dirname + '"',
+        '-DSCREENSHOT_BASENAME="' + basename + '"',
+        '-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2', '--use-preload-plugins'
+      ])
 
   @requires_graphics_hardware
   def test_sdl2_image_jpeg(self):
     shutil.copy(test_file('screenshot.jpg'), 'screenshot.jpeg')
-    self.btest_exit(
-      'test_sdl2_image.c',
-      600,
-      args=[
-        '--preload-file',
-        'screenshot.jpeg',
-        '-DSCREENSHOT_DIRNAME="/"',
-        '-DSCREENSHOT_BASENAME="screenshot.jpeg"',
-        '-sUSE_SDL=2',
-        '-sUSE_SDL_IMAGE=2',
-        '--use-preload-plugins',
-      ],
-    )
+    self.btest_exit('test_sdl2_image.c', 600, args=[
+      '--preload-file', 'screenshot.jpeg',
+      '-DSCREENSHOT_DIRNAME="/"', '-DSCREENSHOT_BASENAME="screenshot.jpeg"',
+      '-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2', '--use-preload-plugins'
+    ])
 
   @also_with_wasmfs
   @requires_graphics_hardware
   def test_sdl2_image_formats(self):
     shutil.copy(test_file('screenshot.png'), '.')
     shutil.copy(test_file('screenshot.jpg'), '.')
-    self.btest_exit(
-      'test_sdl2_image.c',
-      512,
-      args=[
-        '--preload-file',
-        'screenshot.png',
-        '-DSCREENSHOT_DIRNAME="/"',
-        '-DSCREENSHOT_BASENAME="screenshot.png"',
-        '-DNO_PRELOADED',
-        '-sUSE_SDL=2',
-        '-sUSE_SDL_IMAGE=2',
-        '-sSDL2_IMAGE_FORMATS=png',
-      ],
-    )
-    self.btest_exit(
-      'test_sdl2_image.c',
-      600,
-      args=[
-        '--preload-file',
-        'screenshot.jpg',
-        '-DSCREENSHOT_DIRNAME="/"',
-        '-DSCREENSHOT_BASENAME="screenshot.jpg"',
-        '-DBITSPERPIXEL=24',
-        '-DNO_PRELOADED',
-        '--use-port=sdl2',
-        '--use-port=sdl2_image:formats=jpg',
-      ],
-    )
+    self.btest_exit('test_sdl2_image.c', 512, args=[
+      '--preload-file', 'screenshot.png',
+      '-DSCREENSHOT_DIRNAME="/"', '-DSCREENSHOT_BASENAME="screenshot.png"', '-DNO_PRELOADED',
+      '-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2', '-sSDL2_IMAGE_FORMATS=png'
+    ])
+    self.btest_exit('test_sdl2_image.c', 600, args=[
+      '--preload-file', 'screenshot.jpg',
+      '-DSCREENSHOT_DIRNAME="/"', '-DSCREENSHOT_BASENAME="screenshot.jpg"', '-DBITSPERPIXEL=24', '-DNO_PRELOADED',
+      '--use-port=sdl2', '--use-port=sdl2_image:formats=jpg'
+    ])
 
   def test_sdl2_key(self):
     self.btest_exit('test_sdl2_key.c', 37182145, args=['-sUSE_SDL=2', '--pre-js', test_file('browser/fake_events.js')])
 
   def test_sdl2_text(self):
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       Module.postRun = () => {
         function doOne() {
           Module._one();
@@ -3997,24 +2930,17 @@ def test_sdl2_text(self):
         }
         setTimeout(doOne, 1000/60);
       }
-    ''',
-    )
+    ''')
 
-    self.btest_exit(
-      'test_sdl2_text.c', args=['--pre-js', 'pre.js', '--pre-js', test_file('browser/fake_events.js'), '-sUSE_SDL=2']
-    )
+    self.btest_exit('test_sdl2_text.c', args=['--pre-js', 'pre.js', '--pre-js', test_file('browser/fake_events.js'), '-sUSE_SDL=2'])
 
   @requires_graphics_hardware
   def test_sdl2_mouse(self):
-    self.btest_exit(
-      'test_sdl2_mouse.c', args=['-O2', '--minify=0', '--pre-js', test_file('browser/fake_events.js'), '-sUSE_SDL=2']
-    )
+    self.btest_exit('test_sdl2_mouse.c', args=['-O2', '--minify=0', '--pre-js', test_file('browser/fake_events.js'), '-sUSE_SDL=2'])
 
   @requires_graphics_hardware
   def test_sdl2_mouse_offsets(self):
-    create_file(
-      'page.html',
-      '''
+    create_file('page.html', '''
       <html>
         <head>
           <style type="text/css">
@@ -4058,23 +2984,9 @@ def test_sdl2_mouse_offsets(self):
           <script type="text/javascript" src="sdl2_mouse.js"></script>
         </body>
       </html>
-    ''',
-    )
+    ''')
 
-    self.compile_btest(
-      'browser/test_sdl2_mouse.c',
-      [
-        '-DTEST_SDL_MOUSE_OFFSETS=1',
-        '-O2',
-        '--minify=0',
-        '-o',
-        'sdl2_mouse.js',
-        '--pre-js',
-        test_file('browser/fake_events.js'),
-        '-sUSE_SDL=2',
-        '-sEXIT_RUNTIME',
-      ],
-    )
+    self.compile_btest('browser/test_sdl2_mouse.c', ['-DTEST_SDL_MOUSE_OFFSETS=1', '-O2', '--minify=0', '-o', 'sdl2_mouse.js', '--pre-js', test_file('browser/fake_events.js'), '-sUSE_SDL=2', '-sEXIT_RUNTIME'])
     self.run_browser('page.html', '', '/report_result?exit:0')
 
   def test_sdl2_threads(self):
@@ -4106,36 +3018,21 @@ def test_sdl2_gfx(self):
 
   @requires_graphics_hardware
   def test_sdl2_canvas_palette_2(self):
-    create_file(
-      'args-r.js',
-      '''
+    create_file('args-r.js', '''
       Module['arguments'] = ['-r'];
-    ''',
-    )
+    ''')
 
-    create_file(
-      'args-g.js',
-      '''
+    create_file('args-g.js', '''
       Module['arguments'] = ['-g'];
-    ''',
-    )
+    ''')
 
-    create_file(
-      'args-b.js',
-      '''
+    create_file('args-b.js', '''
       Module['arguments'] = ['-b'];
-    ''',
-    )
-
-    self.reftest(
-      'test_sdl2_canvas_palette_2.c', 'test_sdl_canvas_palette_r.png', args=['-sUSE_SDL=2', '--pre-js', 'args-r.js']
-    )
-    self.reftest(
-      'test_sdl2_canvas_palette_2.c', 'test_sdl_canvas_palette_g.png', args=['-sUSE_SDL=2', '--pre-js', 'args-g.js']
-    )
-    self.reftest(
-      'test_sdl2_canvas_palette_2.c', 'test_sdl_canvas_palette_b.png', args=['-sUSE_SDL=2', '--pre-js', 'args-b.js']
-    )
+    ''')
+
+    self.reftest('test_sdl2_canvas_palette_2.c', 'test_sdl_canvas_palette_r.png', args=['-sUSE_SDL=2', '--pre-js', 'args-r.js'])
+    self.reftest('test_sdl2_canvas_palette_2.c', 'test_sdl_canvas_palette_g.png', args=['-sUSE_SDL=2', '--pre-js', 'args-g.js'])
+    self.reftest('test_sdl2_canvas_palette_2.c', 'test_sdl_canvas_palette_b.png', args=['-sUSE_SDL=2', '--pre-js', 'args-b.js'])
 
   def test_sdl2_swsurface(self):
     self.btest_exit('test_sdl2_swsurface.c', args=['-sUSE_SDL=2'])
@@ -4144,31 +3041,19 @@ def test_sdl2_swsurface(self):
   def test_sdl2_image_prepare(self):
     # load an image file, get pixel data.
     shutil.copy(test_file('screenshot.jpg'), 'screenshot.not')
-    self.reftest(
-      'test_sdl2_image_prepare.c',
-      'screenshot.jpg',
-      args=['--preload-file', 'screenshot.not', '-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2'],
-    )
+    self.reftest('test_sdl2_image_prepare.c', 'screenshot.jpg', args=['--preload-file', 'screenshot.not', '-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2'])
 
   @requires_graphics_hardware
   def test_sdl2_image_prepare_data(self):
     # load an image file, get pixel data.
     shutil.copy(test_file('screenshot.jpg'), 'screenshot.not')
-    self.reftest(
-      'test_sdl2_image_prepare_data.c',
-      'screenshot.jpg',
-      args=['--preload-file', 'screenshot.not', '-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2'],
-    )
+    self.reftest('test_sdl2_image_prepare_data.c', 'screenshot.jpg', args=['--preload-file', 'screenshot.not', '-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2'])
 
   @requires_graphics_hardware
   @proxied
   def test_sdl2_canvas_proxy(self):
     create_file('data.txt', 'datum')
-    self.reftest(
-      'test_sdl2_canvas_proxy.c',
-      'test_sdl2_canvas.png',
-      args=['-sUSE_SDL=2', '--proxy-to-worker', '--preload-file', 'data.txt'],
-    )
+    self.reftest('test_sdl2_canvas_proxy.c', 'test_sdl2_canvas.png', args=['-sUSE_SDL=2', '--proxy-to-worker', '--preload-file', 'data.txt'])
 
   def test_sdl2_pumpevents(self):
     # key events should be detected using SDL_PumpEvents
@@ -4187,112 +3072,53 @@ def test_sdl2_gl_read(self):
 
   @requires_graphics_hardware
   def test_sdl2_glmatrixmode_texture(self):
-    self.reftest(
-      'test_sdl2_glmatrixmode_texture.c',
-      'test_sdl2_glmatrixmode_texture.png',
-      args=['-sLEGACY_GL_EMULATION', '-sUSE_SDL=2'],
-    )
+    self.reftest('test_sdl2_glmatrixmode_texture.c', 'test_sdl2_glmatrixmode_texture.png',
+                 args=['-sLEGACY_GL_EMULATION', '-sUSE_SDL=2'])
 
   @requires_graphics_hardware
   def test_sdl2_gldrawelements(self):
-    self.reftest(
-      'test_sdl2_gldrawelements.c', 'test_sdl2_gldrawelements.png', args=['-sLEGACY_GL_EMULATION', '-sUSE_SDL=2']
-    )
+    self.reftest('test_sdl2_gldrawelements.c', 'test_sdl2_gldrawelements.png',
+                 args=['-sLEGACY_GL_EMULATION', '-sUSE_SDL=2'])
 
   @requires_graphics_hardware
   def test_sdl2_glclipplane_gllighting(self):
-    self.reftest(
-      'test_sdl2_glclipplane_gllighting.c',
-      'test_sdl2_glclipplane_gllighting.png',
-      args=['-sLEGACY_GL_EMULATION', '-sUSE_SDL=2'],
-    )
+    self.reftest('test_sdl2_glclipplane_gllighting.c', 'test_sdl2_glclipplane_gllighting.png',
+                 args=['-sLEGACY_GL_EMULATION', '-sUSE_SDL=2'])
 
   @requires_graphics_hardware
   def test_sdl2_glalphatest(self):
-    self.reftest('test_sdl2_glalphatest.c', 'test_sdl2_glalphatest.png', args=['-sLEGACY_GL_EMULATION', '-sUSE_SDL=2'])
+    self.reftest('test_sdl2_glalphatest.c', 'test_sdl2_glalphatest.png',
+                 args=['-sLEGACY_GL_EMULATION', '-sUSE_SDL=2'])
 
   @requires_graphics_hardware
   def test_sdl2_fog_simple(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl2_fog_simple.c',
-      'screenshot-fog-simple.png',
-      args=[
-        '-sUSE_SDL=2',
-        '-sUSE_SDL_IMAGE=2',
-        '-O2',
-        '--minify=0',
-        '--preload-file',
-        'screenshot.png',
-        '-sLEGACY_GL_EMULATION',
-        '--use-preload-plugins',
-      ],
-    )
+    self.reftest('test_sdl2_fog_simple.c', 'screenshot-fog-simple.png',
+                 args=['-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2', '-O2', '--minify=0', '--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins'])
 
   @requires_graphics_hardware
   def test_sdl2_fog_negative(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl2_fog_negative.c',
-      'screenshot-fog-negative.png',
-      args=[
-        '-sUSE_SDL=2',
-        '-sUSE_SDL_IMAGE=2',
-        '--preload-file',
-        'screenshot.png',
-        '-sLEGACY_GL_EMULATION',
-        '--use-preload-plugins',
-      ],
-    )
+    self.reftest('test_sdl2_fog_negative.c', 'screenshot-fog-negative.png',
+                 args=['-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2', '--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins'])
 
   @requires_graphics_hardware
   def test_sdl2_fog_density(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl2_fog_density.c',
-      'screenshot-fog-density.png',
-      args=[
-        '-sUSE_SDL=2',
-        '-sUSE_SDL_IMAGE=2',
-        '--preload-file',
-        'screenshot.png',
-        '-sLEGACY_GL_EMULATION',
-        '--use-preload-plugins',
-      ],
-    )
+    self.reftest('test_sdl2_fog_density.c', 'screenshot-fog-density.png',
+                 args=['-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2', '--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins'])
 
   @requires_graphics_hardware
   def test_sdl2_fog_exp2(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl2_fog_exp2.c',
-      'screenshot-fog-exp2.png',
-      args=[
-        '-sUSE_SDL=2',
-        '-sUSE_SDL_IMAGE=2',
-        '--preload-file',
-        'screenshot.png',
-        '-sLEGACY_GL_EMULATION',
-        '--use-preload-plugins',
-      ],
-    )
+    self.reftest('test_sdl2_fog_exp2.c', 'screenshot-fog-exp2.png',
+                 args=['-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2', '--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins'])
 
   @requires_graphics_hardware
   def test_sdl2_fog_linear(self):
     shutil.copy(test_file('screenshot.png'), '.')
-    self.reftest(
-      'test_sdl2_fog_linear.c',
-      'screenshot-fog-linear.png',
-      reference_slack=1,
-      args=[
-        '-sUSE_SDL=2',
-        '-sUSE_SDL_IMAGE=2',
-        '--preload-file',
-        'screenshot.png',
-        '-sLEGACY_GL_EMULATION',
-        '--use-preload-plugins',
-      ],
-    )
+    self.reftest('test_sdl2_fog_linear.c', 'screenshot-fog-linear.png', reference_slack=1,
+                 args=['-sUSE_SDL=2', '-sUSE_SDL_IMAGE=2', '--preload-file', 'screenshot.png', '-sLEGACY_GL_EMULATION', '--use-preload-plugins'])
 
   def test_sdl2_unwasteful(self):
     self.btest_exit('test_sdl2_unwasteful.c', args=['-sUSE_SDL=2', '-O1'])
@@ -4303,27 +3129,19 @@ def test_sdl2_canvas_write(self):
   @requires_graphics_hardware
   @proxied
   def test_sdl2_gl_frames_swap(self):
-    self.reftest(
-      'test_sdl2_gl_frames_swap.c', 'test_sdl2_gl_frames_swap.png', args=['--proxy-to-worker', '-sUSE_SDL=2']
-    )
+    self.reftest('test_sdl2_gl_frames_swap.c', 'test_sdl2_gl_frames_swap.png', args=['--proxy-to-worker', '-sUSE_SDL=2'])
 
   @requires_graphics_hardware
   def test_sdl2_ttf(self):
     shutil.copy2(test_file('freetype/LiberationSansBold.ttf'), self.get_dir())
-    self.reftest(
-      'test_sdl2_ttf.c',
-      'test_sdl2_ttf.png',
-      args=['-O2', '-sUSE_SDL=2', '-sUSE_SDL_TTF=2', '--embed-file', 'LiberationSansBold.ttf'],
-    )
+    self.reftest('test_sdl2_ttf.c', 'test_sdl2_ttf.png',
+                 args=['-O2', '-sUSE_SDL=2', '-sUSE_SDL_TTF=2', '--embed-file', 'LiberationSansBold.ttf'])
 
   @requires_graphics_hardware
   def test_sdl2_ttf_rtl(self):
     shutil.copy2(test_file('third_party/notofont/NotoNaskhArabic-Regular.ttf'), self.get_dir())
-    self.reftest(
-      'test_sdl2_ttf_rtl.c',
-      'test_sdl2_ttf_rtl.png',
-      args=['-O2', '-sUSE_SDL=2', '-sUSE_SDL_TTF=2', '--embed-file', 'NotoNaskhArabic-Regular.ttf'],
-    )
+    self.reftest('test_sdl2_ttf_rtl.c', 'test_sdl2_ttf_rtl.png',
+                 args=['-O2', '-sUSE_SDL=2', '-sUSE_SDL_TTF=2', '--embed-file', 'NotoNaskhArabic-Regular.ttf'])
 
   def test_sdl2_custom_cursor(self):
     shutil.copy(test_file('cursor.bmp'), '.')
@@ -4340,33 +3158,28 @@ def test_sdl2_misc_via_object(self):
     self.compile_btest('test.o', ['-sEXIT_RUNTIME', '-sUSE_SDL=2', '-o', 'test.html'])
     self.run_browser('test.html', '/report_result?exit:0')
 
-  @parameterized(
-    {
-      '': (['-sUSE_SDL=2', '-sUSE_SDL_MIXER=2'],),
-      'dash_l': (['-lSDL2', '-lSDL2_mixer'],),
-    }
-  )
+  @parameterized({
+    '': (['-sUSE_SDL=2', '-sUSE_SDL_MIXER=2'],),
+    'dash_l': (['-lSDL2', '-lSDL2_mixer'],),
+  })
   @requires_sound_hardware
   def test_sdl2_mixer_wav(self, flags):
     shutil.copy(test_file('sounds/the_entertainer.wav'), 'sound.wav')
     self.btest_exit('test_sdl2_mixer_wav.c', args=['--preload-file', 'sound.wav'] + flags)
 
-  @parameterized(
-    {
-      'wav': ([], '0', 'the_entertainer.wav'),
-      'ogg': (['ogg'], 'MIX_INIT_OGG', 'alarmvictory_1.ogg'),
-      'mp3': (['mp3'], 'MIX_INIT_MP3', 'pudinha.mp3'),
-      'mod': (['mod'], 'MIX_INIT_MOD', 'bleep.xm'),
-      # TODO: need to source freepats.cfg and a midi file
-      # 'mod': (['mid'],    'MIX_INIT_MID', 'midi.mid'),
-    }
-  )
+  @parameterized({
+    'wav': ([],         '0',            'the_entertainer.wav'),
+    'ogg': (['ogg'],    'MIX_INIT_OGG', 'alarmvictory_1.ogg'),
+    'mp3': (['mp3'],    'MIX_INIT_MP3', 'pudinha.mp3'),
+    'mod': (['mod'],    'MIX_INIT_MOD', 'bleep.xm'),
+    # TODO: need to source freepats.cfg and a midi file
+    # 'mod': (['mid'],    'MIX_INIT_MID', 'midi.mid'),
+  })
   @requires_sound_hardware
   def test_sdl2_mixer_music(self, formats, flags, music_name):
     shutil.copy(test_file('sounds', music_name), '.')
     args = [
-      '--preload-file',
-      music_name,
+      '--preload-file', music_name,
       '-DSOUND_PATH="%s"' % music_name,
       '-DFLAGS=' + flags,
       '-sUSE_SDL=2',
@@ -4386,50 +3199,33 @@ def test_cocos2d_hello(self):
     # e.g. warning: undefined symbol: TIFFClientOpen
     cocos2d_root = os.path.join(ports.Ports.get_dir(), 'cocos2d', 'Cocos2d-version_3_3')
     preload_file = os.path.join(cocos2d_root, 'samples', 'Cpp', 'HelloCpp', 'Resources') + '@'
-    self.reftest(
-      'cocos2d_hello.cpp',
-      'cocos2d_hello.png',
-      reference_slack=1,
-      args=[
-        '-sUSE_COCOS2D=3',
-        '-sERROR_ON_UNDEFINED_SYMBOLS=0',
-        # This line should really just be `-std=c++14` like we use to compile
-        # the cocos library itself, but that doesn't work in this case because
-        # btest adds browser_reporting.c to the command.
-        '-D_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION',
-        '-Wno-js-compiler',
-        '-Wno-experimental',
-        '--preload-file',
-        preload_file,
-        '--use-preload-plugins',
-        '-Wno-inconsistent-missing-override',
-        '-Wno-deprecated-declarations',
-      ],
-    )
-
-  @parameterized(
-    {
-      'asyncify': (['-sASYNCIFY=1'],),
-      'jspi': (['-sASYNCIFY=2', '-Wno-experimental'],),
-      'jspi_wasm_bigint': (['-sASYNCIFY=2', '-sWASM_BIGINT', '-Wno-experimental'],),
-    }
-  )
+    self.reftest('cocos2d_hello.cpp', 'cocos2d_hello.png', reference_slack=1,
+                 args=['-sUSE_COCOS2D=3', '-sERROR_ON_UNDEFINED_SYMBOLS=0',
+                       # This line should really just be `-std=c++14` like we use to compile
+                       # the cocos library itself, but that doesn't work in this case because
+                       # btest adds browser_reporting.c to the command.
+                       '-D_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION',
+                       '-Wno-js-compiler',
+                       '-Wno-experimental',
+                       '--preload-file', preload_file, '--use-preload-plugins',
+                       '-Wno-inconsistent-missing-override',
+                       '-Wno-deprecated-declarations'])
+
+  @parameterized({
+    'asyncify': (['-sASYNCIFY=1'],),
+    'jspi': (['-sASYNCIFY=2', '-Wno-experimental'],),
+    'jspi_wasm_bigint': (['-sASYNCIFY=2', '-sWASM_BIGINT', '-Wno-experimental'],),
+  })
   def test_async(self, args):
     if is_jspi(args) and not is_chrome():
-      self.skipTest(
-        f'Current browser ({EMTEST_BROWSER}) does not support JSPI. Only chromium-based browsers ({CHROMIUM_BASED_BROWSERS}) support JSPI today.'
-      )
+      self.skipTest(f'Current browser ({EMTEST_BROWSER}) does not support JSPI. Only chromium-based browsers ({CHROMIUM_BASED_BROWSERS}) support JSPI today.')
 
     for opts in (0, 1, 2, 3):
       print(opts)
       self.btest_exit('async.cpp', args=['-O' + str(opts), '-g2'] + args)
 
   def test_asyncify_tricky_function_sig(self):
-    self.btest(
-      'test_asyncify_tricky_function_sig.cpp',
-      '85',
-      args=['-sASYNCIFY_ONLY=[foo(char.const*?.int#),foo2(),main,__original_main]', '-sASYNCIFY'],
-    )
+    self.btest('test_asyncify_tricky_function_sig.cpp', '85', args=['-sASYNCIFY_ONLY=[foo(char.const*?.int#),foo2(),main,__original_main]', '-sASYNCIFY'])
 
   def test_async_in_pthread(self):
     self.btest_exit('async.cpp', args=['-sASYNCIFY', '-pthread', '-sPROXY_TO_PTHREAD', '-g'])
@@ -4440,46 +3236,34 @@ def test_async_2(self):
     create_file('pre.js', 'Error.stackTraceLimit = 80;\n')
     self.btest_exit('async_2.cpp', args=['-O3', '--pre-js', 'pre.js', '-sASYNCIFY', '-sSTACK_SIZE=1MB'])
 
-  @parameterized(
-    {
-      '': ([],),
-      'O3': (['-O3'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'O3': (['-O3'],),
+  })
   def test_async_virtual(self, args):
     self.btest_exit('async_virtual.cpp', args=args + ['-profiling', '-sASYNCIFY'])
 
-  @parameterized(
-    {
-      '': ([],),
-      'O3': (['-O3'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'O3': (['-O3'],),
+  })
   def test_async_virtual_2(self, args):
     self.btest_exit('async_virtual_2.cpp', args=args + ['-sASSERTIONS', '-sSAFE_HEAP', '-profiling', '-sASYNCIFY'])
 
-  @parameterized(
-    {
-      '': ([],),
-      'O3': (['-O3'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'O3': (['-O3'],),
+  })
   def test_async_mainloop(self, args):
     self.btest_exit('test_async_mainloop.c', args=args + ['-sASYNCIFY'])
 
   @requires_sound_hardware
-  @parameterized(
-    {
-      '': ([],),
-      'safeheap': (['-sSAFE_HEAP'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'safeheap': (['-sSAFE_HEAP'],),
+  })
   def test_sdl_audio_beep_sleep(self, args):
-    self.btest_exit(
-      'test_sdl_audio_beep_sleep.cpp',
-      args=['-Os', '-sASSERTIONS', '-sDISABLE_EXCEPTION_CATCHING=0', '-profiling', '-lSDL', '-sASYNCIFY'] + args,
-      timeout=90,
-    )
+    self.btest_exit('test_sdl_audio_beep_sleep.cpp', args=['-Os', '-sASSERTIONS', '-sDISABLE_EXCEPTION_CATCHING=0', '-profiling', '-lSDL', '-sASYNCIFY'] + args, timeout=90)
 
   def test_mainloop_reschedule(self):
     self.btest('test_mainloop_reschedule.c', '1', args=['-Os', '-sASYNCIFY'])
@@ -4494,26 +3278,18 @@ def test_async_iostream(self):
   # method that uses asyncify, and therefore it needs to be declared in
   # ASYNCIFY_IMPORTS.
   # To make the test more precise we also use ASYNCIFY_IGNORE_INDIRECT here.
-  @parameterized(
-    {
-      'normal': (['-sASYNCIFY_IMPORTS=sync_tunnel,sync_tunnel_bool'],),  # noqa
-      'pattern_imports': (['-sASYNCIFY_IMPORTS=[sync_tun*]'],),  # noqa
-      'response': (['-sASYNCIFY_IMPORTS=@filey.txt'],),  # noqa
-      'nothing': (['-DBAD'],),  # noqa
-      'empty_list': (['-DBAD', '-sASYNCIFY_IMPORTS=[]'],),  # noqa
-      'em_js_bad': (['-DBAD', '-DUSE_EM_JS'],),  # noqa
-    }
-  )
+  @parameterized({
+    'normal': (['-sASYNCIFY_IMPORTS=sync_tunnel,sync_tunnel_bool'],), # noqa
+    'pattern_imports': (['-sASYNCIFY_IMPORTS=[sync_tun*]'],), # noqa
+    'response': (['-sASYNCIFY_IMPORTS=@filey.txt'],), # noqa
+    'nothing': (['-DBAD'],), # noqa
+    'empty_list': (['-DBAD', '-sASYNCIFY_IMPORTS=[]'],), # noqa
+    'em_js_bad': (['-DBAD', '-DUSE_EM_JS'],), # noqa
+  })
   def test_async_returnvalue(self, args):
     if '@' in str(args):
       create_file('filey.txt', 'sync_tunnel\nsync_tunnel_bool\n')
-    self.btest(
-      'async_returnvalue.cpp',
-      '0',
-      args=['-sASYNCIFY', '-sASYNCIFY_IGNORE_INDIRECT', '--js-library', test_file('browser/async_returnvalue.js')]
-      + args
-      + ['-sASSERTIONS'],
-    )
+    self.btest('async_returnvalue.cpp', '0', args=['-sASYNCIFY', '-sASYNCIFY_IGNORE_INDIRECT', '--js-library', test_file('browser/async_returnvalue.js')] + args + ['-sASSERTIONS'])
 
   def test_async_bad_list(self):
     self.btest('async_bad_list.cpp', '0', args=['-sASYNCIFY', '-sASYNCIFY_ONLY=waka', '--profiling'])
@@ -4526,68 +3302,49 @@ def test_minimal_runtime_modularize(self):
   def test_minimal_runtime_export_name(self):
     self.btest_exit('browser_test_hello_world.c', args=['-sEXPORT_NAME=Foo', '-sMINIMAL_RUNTIME'])
 
-  @parameterized(
-    {
-      '': ([],),
-      'O1': (['-O1'],),
-      'O2': (['-O2'],),
-      'profiling': (['-O2', '-profiling'],),
-      'closure': (['-O2', '--closure=1'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'O1': (['-O1'],),
+    'O2': (['-O2'],),
+    'profiling': (['-O2', '-profiling'],),
+    'closure': (['-O2', '--closure=1'],),
+  })
   def test_modularize(self, opts):
     for args, code in [
       # defaults
-      (
-        [],
-        '''
+      ([], '''
         let promise = Module();
         if (!promise instanceof Promise) throw new Error('Return value should be a promise');
-      ''',
-      ),
+      '''),
       # use EXPORT_NAME
-      (
-        ['-sEXPORT_NAME="HelloWorld"'],
-        '''
+      (['-sEXPORT_NAME="HelloWorld"'], '''
         if (typeof Module !== "undefined") throw "what?!"; // do not pollute the global scope, we are modularized!
         HelloWorld.noInitialRun = true; // errorneous module capture will load this and cause timeout
         let promise = HelloWorld();
         if (!promise instanceof Promise) throw new Error('Return value should be a promise');
-      ''',
-      ),
+      '''),
       # pass in a Module option (which prevents main(), which we then invoke ourselves)
-      (
-        ['-sEXPORT_NAME="HelloWorld"'],
-        '''
+      (['-sEXPORT_NAME="HelloWorld"'], '''
         HelloWorld({ noInitialRun: true }).then(hello => {
           hello._main();
         });
-      ''',
-      ),
+      '''),
     ]:
       print('test on', opts, args, code)
       # this test is synchronous, so avoid async startup due to wasm features
       self.compile_btest('browser_test_hello_world.c', ['-sMODULARIZE', '-sSINGLE_FILE'] + args + opts)
-      create_file(
-        'a.html',
-        '''
+      create_file('a.html', '''
         <script src="a.out.js"></script>
         <script>
           %s
         </script>
-      '''
-        % code,
-      )
+      ''' % code)
       self.run_browser('a.html', '/report_result?0')
 
   def test_modularize_network_error(self):
-    self.compile_btest(
-      'browser_test_hello_world.c', ['-sMODULARIZE', '-sEXPORT_NAME=createModule'], reporting=Reporting.NONE
-    )
+    self.compile_btest('browser_test_hello_world.c', ['-sMODULARIZE', '-sEXPORT_NAME=createModule'], reporting=Reporting.NONE)
     shutil.copy(test_file('browser_reporting.js'), '.')
-    create_file(
-      'a.html',
-      '''
+    create_file('a.html', '''
       <script src="browser_reporting.js"></script>
       <script src="a.out.js"></script>
       <script>
@@ -4599,20 +3356,15 @@ def test_modularize_network_error(self):
             reportResultToServer(err.message);
           });
       </script>
-    ''',
-    )
+    ''')
     print('Deleting a.out.wasm to cause a download error')
     os.remove('a.out.wasm')
     self.run_browser('a.html', '/report_result?Aborted(both async and sync fetching of the wasm failed)')
 
   def test_modularize_init_error(self):
-    self.compile_btest(
-      'browser/test_modularize_init_error.cpp', ['-sMODULARIZE', '-sEXPORT_NAME=createModule'], reporting=Reporting.NONE
-    )
+    self.compile_btest('browser/test_modularize_init_error.cpp', ['-sMODULARIZE', '-sEXPORT_NAME=createModule'], reporting=Reporting.NONE)
     shutil.copy(test_file('browser_reporting.js'), '.')
-    create_file(
-      'a.html',
-      '''
+    create_file('a.html', '''
       <script src="browser_reporting.js"></script>
       <script src="a.out.js"></script>
       <script>
@@ -4624,8 +3376,7 @@ def test_modularize_init_error(self):
             reportResultToServer(err);
           });
       </script>
-    ''',
-    )
+    ''')
     self.run_browser('a.html', '/report_result?intentional error to test rejection')
 
   # test illustrating the regression on the modularize feature since commit c5af8f6
@@ -4640,9 +3391,7 @@ def test_modularize_and_preload_files(self):
     totalMemory = 33554432
     for opts in ([], ['-O1'], ['-O2', '-profiling'], ['-O2'], ['-O2', '--closure=1']):
       # the main function simply checks that the amount of allocated heap memory is correct
-      create_file(
-        'test.c',
-        r'''
+      create_file('test.c', r'''
         #include <stdio.h>
         #include <emscripten.h>
         int main() {
@@ -4653,38 +3402,26 @@ def test_modularize_and_preload_files(self):
           });
           return 0;
         }
-      '''
-        % totalMemory,
-      )
+      ''' % totalMemory)
       # generate a dummy file
       create_file('dummy_file', 'dummy')
       # compile the code with the modularize feature and the preload-file option enabled
       # no wasm, since this tests customizing total memory at runtime
-      self.compile_btest(
-        'test.c',
-        ['-sWASM=0', '-sIMPORTED_MEMORY', '-sMODULARIZE', '-sEXPORT_NAME="Foo"', '--preload-file', 'dummy_file'] + opts,
-        reporting=Reporting.JS_ONLY,
-      )
-      create_file(
-        'a.html',
-        '''
+      self.compile_btest('test.c', ['-sWASM=0', '-sIMPORTED_MEMORY', '-sMODULARIZE', '-sEXPORT_NAME="Foo"', '--preload-file', 'dummy_file'] + opts, reporting=Reporting.JS_ONLY)
+      create_file('a.html', '''
         <script src="a.out.js"></script>
         <script>
           // instantiate the Foo module with custom INITIAL_MEMORY value
           var foo = Foo({ INITIAL_MEMORY: %d });
         </script>
-      '''
-        % totalMemory,
-      )
+      ''' % totalMemory)
       self.run_browser('a.html', '/report_result?exit:0')
 
-  @parameterized(
-    {
-      '': ([],),
-      'O1': (['-O1'],),
-      'O2': (['-O2'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'O1': (['-O1'],),
+    'O2': (['-O2'],),
+  })
   def test_webidl(self, args):
     # see original in test_core.py
     self.run_process([WEBIDL_BINDER, test_file('webidl/test.idl'), 'glue'])
@@ -4693,16 +3430,12 @@ def test_webidl(self, args):
     self.btest('webidl/test.cpp', '1', args=['--post-js', 'glue.js', '-I.', '-DBROWSER'] + args)
 
   @no_wasm64('https://github.com/llvm/llvm-project/issues/98778')
-  @parameterized(
-    {
-      '': ([],),
-      'proxy_to_worker': (['--proxy-to-worker'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'proxy_to_worker': (['--proxy-to-worker'],),
+  })
   def test_dylink(self, args):
-    create_file(
-      'main.c',
-      r'''
+    create_file('main.c', r'''
       #include <assert.h>
       #include <stdio.h>
       #include <stdlib.h>
@@ -4714,17 +3447,13 @@ def test_dylink(self, args):
         assert(strcmp(ret, "hello through side\n") == 0);
         return 0;
       }
-    ''',
-    )
-    create_file(
-      'side.c',
-      r'''
+    ''')
+    create_file('side.c', r'''
       #include <string.h>
       char *side(const char *data) {
         return strdup(data);
       }
-    ''',
-    )
+    ''')
     self.emcc('side.c', ['-sSIDE_MODULE', '-O2', '-o', 'side.wasm'])
     self.btest_exit('main.c', args=['-sMAIN_MODULE=2', '-O2', 'side.wasm'] + args)
 
@@ -4734,36 +3463,19 @@ def test_dlopen_async(self):
     self.btest_exit('other/test_dlopen_async.c', args=['-sMAIN_MODULE=2'])
 
   def test_dlopen_blocking(self):
-    self.emcc(
-      test_file('other/test_dlopen_blocking_side.c'),
-      ['-o', 'libside.so', '-sSIDE_MODULE', '-pthread', '-Wno-experimental'],
-    )
+    self.emcc(test_file('other/test_dlopen_blocking_side.c'), ['-o', 'libside.so', '-sSIDE_MODULE', '-pthread', '-Wno-experimental'])
     # Attempt to use dlopen the side module (without preloading) should fail on the main thread
     # since the syncronous `readBinary` function does not exist.
-    self.btest_exit(
-      'other/test_dlopen_blocking.c', assert_returncode=1, args=['-sMAIN_MODULE=2', '-sAUTOLOAD_DYLIBS=0', 'libside.so']
-    )
+    self.btest_exit('other/test_dlopen_blocking.c', assert_returncode=1, args=['-sMAIN_MODULE=2', '-sAUTOLOAD_DYLIBS=0', 'libside.so'])
     # But with PROXY_TO_PTHEAD it does work, since we can do blocking and sync XHR in a worker.
-    self.btest_exit(
-      'other/test_dlopen_blocking.c',
-      args=[
-        '-sMAIN_MODULE=2',
-        '-sPROXY_TO_PTHREAD',
-        '-pthread',
-        '-Wno-experimental',
-        '-sAUTOLOAD_DYLIBS=0',
-        'libside.so',
-      ],
-    )
+    self.btest_exit('other/test_dlopen_blocking.c', args=['-sMAIN_MODULE=2', '-sPROXY_TO_PTHREAD', '-pthread', '-Wno-experimental', '-sAUTOLOAD_DYLIBS=0', 'libside.so'])
 
   # verify that dynamic linking works in all kinds of in-browser environments.
   # don't mix different kinds in a single test.
-  @parameterized(
-    {
-      '': ([0],),
-      'inworker': ([1],),
-    }
-  )
+  @parameterized({
+    '': ([0],),
+    'inworker': ([1],),
+  })
   def test_dylink_dso_needed(self, inworker):
     self.emcc_args += ['-O2']
 
@@ -4775,21 +3487,15 @@ def do_run(src, expected_output, emcc_args):
       # (in main we won't be able to catch what static constructors inside
       # linked dynlibs printed), and in pre.js it is too early (out is not yet
       # setup by the shell).
-      create_file(
-        'post.js',
-        r'''
+      create_file('post.js', r'''
           Module.realPrint = out;
           out = (x) => {
             if (!Module.printed) Module.printed = "";
             Module.printed += x + '\n'; // out is passed str without last \n
             Module.realPrint(x);
           };
-        ''',
-      )
-      create_file(
-        'test_dylink_dso_needed.c',
-        src
-        + r'''
+        ''')
+      create_file('test_dylink_dso_needed.c', src + r'''
         #include <emscripten/em_asm.h>
 
         int main() {
@@ -4800,9 +3506,7 @@ def do_run(src, expected_output, emcc_args):
           });
           return rtn;
         }
-      '''
-        % expected_output,
-      )
+      ''' % expected_output)
       # --proxy-to-worker only on main
       if inworker:
         emcc_args += ['--proxy-to-worker']
@@ -4813,9 +3517,7 @@ def do_run(src, expected_output, emcc_args):
   @requires_graphics_hardware
   @no_wasm64('https://github.com/llvm/llvm-project/issues/98778')
   def test_dylink_glemu(self):
-    create_file(
-      'main.c',
-      r'''
+    create_file('main.c', r'''
       #include <stdio.h>
       #include <string.h>
       #include <assert.h>
@@ -4826,11 +3528,8 @@ def test_dylink_glemu(self):
         assert(strstr(exts, "GL_EXT_texture_env_combine"));
         return 0;
       }
-    ''',
-    )
-    create_file(
-      'side.c',
-      r'''
+    ''')
+    create_file('side.c', r'''
       #include "SDL/SDL.h"
       #include "SDL/SDL_opengl.h"
       const char *side() {
@@ -4838,17 +3537,14 @@ def test_dylink_glemu(self):
         SDL_SetVideoMode(600, 600, 16, SDL_OPENGL);
         return (const char *)glGetString(GL_EXTENSIONS);
       }
-    ''',
-    )
+    ''')
     self.emcc('side.c', ['-sSIDE_MODULE', '-O2', '-o', 'side.wasm', '-lSDL'])
 
     self.btest_exit('main.c', args=['-sMAIN_MODULE=2', '-O2', '-sLEGACY_GL_EMULATION', '-lSDL', '-lGL', 'side.wasm'])
 
   def test_dylink_many(self):
     # test asynchronously loading two side modules during startup
-    create_file(
-      'main.c',
-      r'''
+    create_file('main.c', r'''
       #include <assert.h>
       int side1();
       int side2();
@@ -4857,20 +3553,13 @@ def test_dylink_many(self):
         assert(side2() == 2);
         return 0;
       }
-    ''',
-    )
-    create_file(
-      'side1.c',
-      r'''
+    ''')
+    create_file('side1.c', r'''
       int side1() { return 1; }
-    ''',
-    )
-    create_file(
-      'side2.c',
-      r'''
+    ''')
+    create_file('side2.c', r'''
       int side2() { return 2; }
-    ''',
-    )
+    ''')
     self.emcc('side1.c', ['-sSIDE_MODULE', '-o', 'side1.wasm'])
     self.emcc('side2.c', ['-sSIDE_MODULE', '-o', 'side2.wasm'])
     self.btest_exit('main.c', args=['-sMAIN_MODULE=2', 'side1.wasm', 'side2.wasm'])
@@ -4885,9 +3574,7 @@ def test_dylink_pthread_many(self):
     # in the browser's main thread. However, it should still be
     # populated in the same order as in a pthread worker to
     # guarantee function pointer interop.
-    create_file(
-      'main.cpp',
-      r'''
+    create_file('main.cpp', r'''
       #include <cassert>
       #include <thread>
       #include <emscripten/emscripten.h>
@@ -4905,101 +3592,63 @@ def test_dylink_pthread_many(self):
         }).detach();
         emscripten_exit_with_live_runtime();
       }
-    ''',
-    )
+    ''')
 
     # The browser will try to load side1 first.
     # Use a big payload in side1 so that it takes longer to load than side2
-    create_file(
-      'side1.cpp',
-      r'''
-      char const * payload1 = "'''
-      + str(list(range(1, int(1e5))))
-      + r'''";
+    create_file('side1.cpp', r'''
+      char const * payload1 = "''' + str(list(range(1, int(1e5)))) + r'''";
       int side1() { return 1; }
-    ''',
-    )
-    create_file(
-      'side2.cpp',
-      r'''
+    ''')
+    create_file('side2.cpp', r'''
       char const * payload2 = "0";
       int side2() { return 2; }
-    ''',
-    )
+    ''')
     self.emcc('side1.cpp', ['-Wno-experimental', '-pthread', '-sSIDE_MODULE', '-o', 'side1.wasm'])
     self.emcc('side2.cpp', ['-Wno-experimental', '-pthread', '-sSIDE_MODULE', '-o', 'side2.wasm'])
-    self.btest_exit('main.cpp', args=['-Wno-experimental', '-pthread', '-sMAIN_MODULE=2', 'side1.wasm', 'side2.wasm'])
+    self.btest_exit('main.cpp',
+                    args=['-Wno-experimental', '-pthread', '-sMAIN_MODULE=2', 'side1.wasm', 'side2.wasm'])
 
   @no_2gb('uses INITIAL_MEMORY')
   @no_4gb('uses INITIAL_MEMORY')
   def test_memory_growth_during_startup(self):
     create_file('data.dat', 'X' * (30 * 1024 * 1024))
-    self.btest(
-      'browser_test_hello_world.c',
-      '0',
-      args=[
-        '-sASSERTIONS',
-        '-sALLOW_MEMORY_GROWTH',
-        '-sINITIAL_MEMORY=16MB',
-        '-sSTACK_SIZE=16384',
-        '--preload-file',
-        'data.dat',
-      ],
-    )
+    self.btest('browser_test_hello_world.c', '0', args=['-sASSERTIONS', '-sALLOW_MEMORY_GROWTH', '-sINITIAL_MEMORY=16MB', '-sSTACK_SIZE=16384', '--preload-file', 'data.dat'])
 
   # pthreads tests
 
   def prep_no_SAB(self):
-    create_file(
-      'html.html',
-      read_file(path_from_root('src/shell_minimal.html')).replace(
-        '''<body>''',
-        '''<body>
+    create_file('html.html', read_file(path_from_root('src/shell_minimal.html')).replace('''<body>''', '''<body>
       <script>
         SharedArrayBuffer = undefined;
         Atomics = undefined;
       </script>
-    ''',
-      ),
-    )
+    '''))
 
   def test_pthread_c11_threads(self):
-    self.btest_exit(
-      'pthread/test_pthread_c11_threads.c', args=['-gsource-map', '-std=gnu11', '-pthread', '-sPROXY_TO_PTHREAD']
-    )
+    self.btest_exit('pthread/test_pthread_c11_threads.c',
+                    args=['-gsource-map', '-std=gnu11', '-pthread', '-sPROXY_TO_PTHREAD'])
 
   def test_pthread_pool_size_strict(self):
     # Check that it doesn't fail with sufficient number of threads in the pool.
-    self.btest_exit(
-      'pthread/test_pthread_c11_threads.c',
-      args=['-g2', '-std=gnu11', '-pthread', '-sPTHREAD_POOL_SIZE=4', '-sPTHREAD_POOL_SIZE_STRICT=2'],
-    )
+    self.btest_exit('pthread/test_pthread_c11_threads.c',
+                    args=['-g2', '-std=gnu11', '-pthread', '-sPTHREAD_POOL_SIZE=4', '-sPTHREAD_POOL_SIZE_STRICT=2'])
     # Check that it fails instead of deadlocking on insufficient number of threads in the pool.
-    self.btest(
-      'pthread/test_pthread_c11_threads.c',
-      expected='abort:Assertion failed: thrd_create(&t4, thread_main, NULL) == thrd_success',
-      args=['-g2', '-std=gnu11', '-pthread', '-sPTHREAD_POOL_SIZE=3', '-sPTHREAD_POOL_SIZE_STRICT=2'],
-    )
+    self.btest('pthread/test_pthread_c11_threads.c',
+               expected='abort:Assertion failed: thrd_create(&t4, thread_main, NULL) == thrd_success',
+               args=['-g2', '-std=gnu11', '-pthread', '-sPTHREAD_POOL_SIZE=3', '-sPTHREAD_POOL_SIZE_STRICT=2'])
 
   def test_pthread_in_pthread_pool_size_strict(self):
     # Check that it fails when there's a pthread creating another pthread.
-    self.btest_exit(
-      'pthread/test_pthread_create_pthread.c',
-      args=['-g2', '-pthread', '-sPTHREAD_POOL_SIZE=2', '-sPTHREAD_POOL_SIZE_STRICT=2'],
-    )
+    self.btest_exit('pthread/test_pthread_create_pthread.c', args=['-g2', '-pthread', '-sPTHREAD_POOL_SIZE=2', '-sPTHREAD_POOL_SIZE_STRICT=2'])
     # Check that it fails when there's a pthread creating another pthread.
-    self.btest_exit(
-      'pthread/test_pthread_create_pthread.c',
-      args=['-g2', '-pthread', '-sPTHREAD_POOL_SIZE=1', '-sPTHREAD_POOL_SIZE_STRICT=2', '-DSMALL_POOL'],
-    )
+    self.btest_exit('pthread/test_pthread_create_pthread.c', args=['-g2', '-pthread', '-sPTHREAD_POOL_SIZE=1', '-sPTHREAD_POOL_SIZE_STRICT=2', '-DSMALL_POOL'])
 
   # Test that the emscripten_ atomics api functions work.
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['--closure=1'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['--closure=1'],),
+  })
   def test_pthread_atomics(self, args):
     self.btest_exit('pthread/test_pthread_atomics.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8', '-g1'] + args)
 
@@ -5008,78 +3657,52 @@ def test_pthread_64bit_atomics(self):
     self.btest_exit('pthread/test_pthread_64bit_atomics.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8'])
 
   # Test 64-bit C++11 atomics.
-  @parameterized({'': ([],), 'O3': (['-O3'],)})
+  @parameterized({
+    '': ([],),
+    'O3': (['-O3'],)
+  })
   def test_pthread_64bit_cxx11_atomics(self, opt):
     for pthreads in ([], ['-pthread']):
       self.btest_exit('pthread/test_pthread_64bit_cxx11_atomics.cpp', args=opt + pthreads)
 
   # Test c++ std::thread::hardware_concurrency()
   def test_pthread_hardware_concurrency(self):
-    self.btest_exit(
-      'pthread/test_pthread_hardware_concurrency.cpp',
-      args=['-O2', '-pthread', '-sPTHREAD_POOL_SIZE="navigator.hardwareConcurrency"'],
-    )
+    self.btest_exit('pthread/test_pthread_hardware_concurrency.cpp', args=['-O2', '-pthread', '-sPTHREAD_POOL_SIZE="navigator.hardwareConcurrency"'])
 
   # Test that we error if not ALLOW_BLOCKING_ON_MAIN_THREAD
   def test_pthread_main_thread_blocking_wait(self):
-    self.btest(
-      'pthread/main_thread_wait.c',
-      expected='abort:Blocking on the main thread is not allowed by default.',
-      args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE', '-sALLOW_BLOCKING_ON_MAIN_THREAD=0'],
-    )
+    self.btest('pthread/main_thread_wait.c', expected='abort:Blocking on the main thread is not allowed by default.', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE', '-sALLOW_BLOCKING_ON_MAIN_THREAD=0'])
 
   # Test that we error or warn depending on ALLOW_BLOCKING_ON_MAIN_THREAD or ASSERTIONS
   def test_pthread_main_thread_blocking_join(self):
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
       Module['printErr'] = (x) => {
         if (x.includes('Blocking on the main thread is very dangerous')) {
           maybeReportResultToServer('got_warn');
         }
       };
-    ''',
-    )
+    ''')
     # Test that we warn about blocking on the main thread in debug builds
-    self.btest(
-      'pthread/main_thread_join.cpp',
-      expected='got_warn',
-      args=['-sEXIT_RUNTIME', '-sASSERTIONS', '--pre-js', 'pre.js', '-pthread', '-sPTHREAD_POOL_SIZE'],
-    )
+    self.btest('pthread/main_thread_join.cpp', expected='got_warn', args=['-sEXIT_RUNTIME', '-sASSERTIONS', '--pre-js', 'pre.js', '-pthread', '-sPTHREAD_POOL_SIZE'])
     # Test that we do not warn about blocking on the main thread in release builds
-    self.btest_exit(
-      'pthread/main_thread_join.cpp', args=['-O3', '--pre-js', 'pre.js', '-pthread', '-sPTHREAD_POOL_SIZE']
-    )
+    self.btest_exit('pthread/main_thread_join.cpp', args=['-O3', '--pre-js', 'pre.js', '-pthread', '-sPTHREAD_POOL_SIZE'])
     # Test that tryjoin is fine, even if not ALLOW_BLOCKING_ON_MAIN_THREAD
-    self.btest_exit(
-      'pthread/main_thread_join.cpp',
-      assert_returncode=2,
-      args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE', '-g', '-DTRY_JOIN', '-sALLOW_BLOCKING_ON_MAIN_THREAD=0'],
-    )
+    self.btest_exit('pthread/main_thread_join.cpp', assert_returncode=2, args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE', '-g', '-DTRY_JOIN', '-sALLOW_BLOCKING_ON_MAIN_THREAD=0'])
     # Test that tryjoin is fine, even if not ALLOW_BLOCKING_ON_MAIN_THREAD, and even without a pool
-    self.btest_exit(
-      'pthread/main_thread_join.cpp',
-      assert_returncode=2,
-      args=['-O3', '-pthread', '-g', '-DTRY_JOIN', '-sALLOW_BLOCKING_ON_MAIN_THREAD=0'],
-    )
+    self.btest_exit('pthread/main_thread_join.cpp', assert_returncode=2, args=['-O3', '-pthread', '-g', '-DTRY_JOIN', '-sALLOW_BLOCKING_ON_MAIN_THREAD=0'])
     # Test that everything works ok when we are on a pthread
-    self.btest_exit(
-      'pthread/main_thread_join.cpp',
-      args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE', '-sPROXY_TO_PTHREAD', '-sALLOW_BLOCKING_ON_MAIN_THREAD=0'],
-    )
+    self.btest_exit('pthread/main_thread_join.cpp', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE', '-sPROXY_TO_PTHREAD', '-sALLOW_BLOCKING_ON_MAIN_THREAD=0'])
 
   # Test the old GCC atomic __sync_fetch_and_op builtin operations.
   @no_2gb('https://github.com/emscripten-core/emscripten/issues/21318')
   @no_4gb('https://github.com/emscripten-core/emscripten/issues/21318')
-  @parameterized(
-    {
-      '': (['-g'],),
-      'O1': (['-O1', '-g'],),
-      'O2': (['-O2'],),
-      'O3': (['-O3'],),
-      'Os': (['-Os'],),
-    }
-  )
+  @parameterized({
+    '': (['-g'],),
+    'O1': (['-O1', '-g'],),
+    'O2': (['-O2'],),
+    'O3': (['-O3'],),
+    'Os': (['-Os'],),
+  })
   def test_pthread_gcc_atomic_fetch_and_op(self, args):
     self.emcc_args += ['-Wno-sync-fetch-and-nand-semantics-changed']
     self.btest_exit('pthread/test_pthread_gcc_atomic_fetch_and_op.c', args=args + ['-pthread', '-sPTHREAD_POOL_SIZE=8'])
@@ -5092,9 +3715,7 @@ def test_pthread_gcc_64bit_atomic_fetch_and_op(self):
     if self.is_wasm2js():
       self.skipTest('https://github.com/WebAssembly/binaryen/issues/4358')
     self.emcc_args += ['-Wno-sync-fetch-and-nand-semantics-changed']
-    self.btest_exit(
-      'pthread/test_pthread_gcc_64bit_atomic_fetch_and_op.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8']
-    )
+    self.btest_exit('pthread/test_pthread_gcc_64bit_atomic_fetch_and_op.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8'])
 
   # Test the old GCC atomic __sync_op_and_fetch builtin operations.
   @also_with_wasm2js
@@ -5112,9 +3733,7 @@ def test_pthread_gcc_64bit_atomic_op_and_fetch(self):
     if self.is_wasm2js():
       self.skipTest('https://github.com/WebAssembly/binaryen/issues/4358')
     self.emcc_args += ['-Wno-sync-fetch-and-nand-semantics-changed', '--profiling-funcs']
-    self.btest_exit(
-      'pthread/test_pthread_gcc_64bit_atomic_op_and_fetch.c', args=['-pthread', '-O2', '-sPTHREAD_POOL_SIZE=8']
-    )
+    self.btest_exit('pthread/test_pthread_gcc_64bit_atomic_op_and_fetch.c', args=['-pthread', '-O2', '-sPTHREAD_POOL_SIZE=8'])
 
   # Tests the rest of the remaining GCC atomics after the two above tests.
   @also_with_wasm2js
@@ -5127,18 +3746,16 @@ def test_pthread_gcc_spinlock(self):
     for arg in ([], ['-DUSE_EMSCRIPTEN_INTRINSICS']):
       self.btest_exit('pthread/test_pthread_gcc_spinlock.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8'] + arg)
 
-  @parameterized(
-    {
-      '': ([],),
-      'O3': (['-O3'],),
-      'minimal_runtime': (['-sMINIMAL_RUNTIME'],),
-      'single_file': (['-sSINGLE_FILE'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'O3': (['-O3'],),
+    'minimal_runtime': (['-sMINIMAL_RUNTIME'],),
+    'single_file': (['-sSINGLE_FILE'],),
+  })
   def test_pthread_create(self, args):
-    self.btest_exit(
-      'pthread/test_pthread_create.c', args=['-pthread', '-sPTHREAD_POOL_SIZE=8'] + args, extra_tries=0
-    )  # this should be 100% deterministic
+    self.btest_exit('pthread/test_pthread_create.c',
+                    args=['-pthread', '-sPTHREAD_POOL_SIZE=8'] + args,
+                    extra_tries=0) # this should be 100% deterministic
     files = os.listdir('.')
     if '-sSINGLE_FILE' in args:
       self.assertEqual(len(files), 1, files)
@@ -5147,19 +3764,13 @@ def test_pthread_create(self, args):
 
   # Test that preallocating worker threads work.
   def test_pthread_preallocates_workers(self):
-    self.btest_exit(
-      'pthread/test_pthread_preallocates_workers.c',
-      args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=4', '-sPTHREAD_POOL_DELAY_LOAD'],
-    )
+    self.btest_exit('pthread/test_pthread_preallocates_workers.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=4', '-sPTHREAD_POOL_DELAY_LOAD'])
 
   # Test that allocating a lot of threads doesn't regress. This needs to be checked manually!
   @no_2gb('uses INITIAL_MEMORY')
   @no_4gb('uses INITIAL_MEMORY')
   def test_pthread_large_pthread_allocation(self):
-    self.btest_exit(
-      'pthread/test_large_pthread_allocation.c',
-      args=['-sINITIAL_MEMORY=128MB', '-O3', '-pthread', '-sPTHREAD_POOL_SIZE=50'],
-    )
+    self.btest_exit('pthread/test_large_pthread_allocation.c', args=['-sINITIAL_MEMORY=128MB', '-O3', '-pthread', '-sPTHREAD_POOL_SIZE=50'])
 
   # Tests the -sPROXY_TO_PTHREAD option.
   def test_pthread_proxy_to_pthread(self):
@@ -5167,13 +3778,8 @@ def test_pthread_proxy_to_pthread(self):
 
   # Test that a pthread can spawn another pthread of its own.
   def test_pthread_create_pthread(self):
-    for modularize in (
-      [],
-      ['-sMODULARIZE', '-sEXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')],
-    ):
-      self.btest_exit(
-        'pthread/test_pthread_create_pthread.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=2'] + modularize
-      )
+    for modularize in ([], ['-sMODULARIZE', '-sEXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')]):
+      self.btest_exit('pthread/test_pthread_create_pthread.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=2'] + modularize)
 
   # Test another case of pthreads spawning pthreads, but this time the callers immediately join on the threads they created.
   def test_pthread_nested_spawns(self):
@@ -5193,9 +3799,7 @@ def test_pthread_cancel(self):
 
   # Test that pthread_cancel() cancels pthread_cond_wait() operation
   def test_pthread_cancel_cond_wait(self):
-    self.btest_exit(
-      'pthread/test_pthread_cancel_cond_wait.c', assert_returncode=1, args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8']
-    )
+    self.btest_exit('pthread/test_pthread_cancel_cond_wait.c', assert_returncode=1, args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8'])
 
   # Test pthread_kill() operation
   @no_chrome('pthread_kill hangs chrome renderer, and keep subsequent tests from passing')
@@ -5207,12 +3811,10 @@ def test_pthread_cleanup(self):
     self.btest_exit('pthread/test_pthread_cleanup.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8'])
 
   # Tests the pthread mutex api.
-  @parameterized(
-    {
-      '': ([],),
-      'spinlock': (['-DSPINLOCK_TEST'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'spinlock': (['-DSPINLOCK_TEST'],),
+  })
   def test_pthread_mutex(self, args):
     self.btest_exit('pthread/test_pthread_mutex.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8'] + args)
 
@@ -5237,42 +3839,33 @@ def test_pthread_once(self):
 
   # Test against a certain thread exit time handling bug by spawning tons of threads.
   def test_pthread_spawns(self):
-    self.btest_exit(
-      'pthread/test_pthread_spawns.cpp',
-      args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8', '--closure=1', '-sENVIRONMENT=web,worker'],
-    )
+    self.btest_exit('pthread/test_pthread_spawns.cpp', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8', '--closure=1', '-sENVIRONMENT=web,worker'])
 
   # It is common for code to flip volatile global vars for thread control. This is a bit lax, but nevertheless, test whether that
   # kind of scheme will work with Emscripten as well.
-  @parameterized(
-    {
-      '': (['-DUSE_C_VOLATILE'],),
-      'atomic': ([],),
-    }
-  )
+  @parameterized({
+    '': (['-DUSE_C_VOLATILE'],),
+    'atomic': ([],),
+  })
   def test_pthread_volatile(self, args):
     self.btest_exit('pthread/test_pthread_volatile.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8'] + args)
 
   # Test thread-specific data (TLS).
   def test_pthread_thread_local_storage(self):
-    self.btest_exit(
-      'pthread/test_pthread_thread_local_storage.cpp', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8', '-sASSERTIONS']
-    )
+    self.btest_exit('pthread/test_pthread_thread_local_storage.cpp', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8', '-sASSERTIONS'])
 
   # Test the pthread condition variable creation and waiting.
   def test_pthread_condition_variable(self):
     self.btest_exit('pthread/test_pthread_condition_variable.cpp', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8'])
 
   # Test that pthreads are able to do printf.
-  @parameterized(
-    {
-      '': ([],),
-      'O3': (['-O3'],),
-      'debug': (['-sLIBRARY_DEBUG'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'O3': (['-O3'],),
+    'debug': (['-sLIBRARY_DEBUG'],),
+  })
   def test_pthread_printf(self, args):
-    self.btest_exit('pthread/test_pthread_printf.c', args=['-pthread', '-sPTHREAD_POOL_SIZE'] + args)
+     self.btest_exit('pthread/test_pthread_printf.c', args=['-pthread', '-sPTHREAD_POOL_SIZE'] + args)
 
   # Test that pthreads are able to do cout. Failed due to https://bugzilla.mozilla.org/show_bug.cgi?id=1154858.
   def test_pthread_iostream(self):
@@ -5291,12 +3884,10 @@ def test_pthread_file_io(self):
     self.btest_exit('pthread/test_pthread_file_io.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE'])
 
   # Test that the pthread_create() function operates benignly in the case that threading is not supported.
-  @parameterized(
-    {
-      '': ([],),
-      'mt': (['-pthread', '-sPTHREAD_POOL_SIZE=8'],),
-    }
-  )
+  @parameterized({
+   '': ([],),
+   'mt': (['-pthread', '-sPTHREAD_POOL_SIZE=8'],),
+  })
   def test_pthread_supported(self, args):
     self.btest_exit('pthread/test_pthread_supported.cpp', args=['-O3'] + args)
 
@@ -5312,27 +3903,21 @@ def test_pthread_proxying_in_futex_wait(self):
   # Test that sbrk() operates properly in multithreaded conditions
   @no_2gb('uses INITIAL_MEMORY')
   @no_4gb('uses INITIAL_MEMORY')
-  @parameterized(
-    {
-      '': (['-DABORTING_MALLOC=0', '-sABORTING_MALLOC=0'],),
-      'aborting_malloc': (['-DABORTING_MALLOC=1'],),
-    }
-  )
+  @parameterized({
+    '': (['-DABORTING_MALLOC=0', '-sABORTING_MALLOC=0'],),
+    'aborting_malloc': (['-DABORTING_MALLOC=1'],),
+  })
   def test_pthread_sbrk(self, args):
     # With aborting malloc = 1, test allocating memory in threads
     # With aborting malloc = 0, allocate so much memory in threads that some of the allocations fail.
-    self.btest_exit(
-      'pthread/test_pthread_sbrk.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8', '-sINITIAL_MEMORY=128MB'] + args
-    )
+    self.btest_exit('pthread/test_pthread_sbrk.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8', '-sINITIAL_MEMORY=128MB'] + args)
 
   # Test that -sABORTING_MALLOC=0 works in both pthreads and non-pthreads
   # builds. (sbrk fails gracefully)
-  @parameterized(
-    {
-      '': ([],),
-      'mt': (['-pthread'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'mt': (['-pthread'],),
+  })
   def test_pthread_gauge_available_memory(self, args):
     for opts in ([], ['-O2']):
       self.btest('gauge_available_memory.cpp', expected='1', args=['-sABORTING_MALLOC=0'] + args + opts)
@@ -5354,82 +3939,26 @@ def test_pthread_call_async(self):
   # Test that it is possible to synchronously call a JavaScript function on the
   # main thread and get a return value back.
   def test_pthread_call_sync_on_main_thread(self):
-    self.btest_exit(
-      'pthread/call_sync_on_main_thread.c',
-      args=[
-        '-O3',
-        '-pthread',
-        '-sPROXY_TO_PTHREAD',
-        '-DPROXY_TO_PTHREAD=1',
-        '--js-library',
-        test_file('pthread/call_sync_on_main_thread.js'),
-      ],
-    )
-    self.btest_exit(
-      'pthread/call_sync_on_main_thread.c',
-      args=[
-        '-O3',
-        '-pthread',
-        '-DPROXY_TO_PTHREAD=0',
-        '--js-library',
-        test_file('pthread/call_sync_on_main_thread.js'),
-      ],
-    )
-    self.btest_exit(
-      'pthread/call_sync_on_main_thread.c',
-      args=['-Oz', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread/call_sync_on_main_thread.js')],
-    )
+    self.btest_exit('pthread/call_sync_on_main_thread.c', args=['-O3', '-pthread', '-sPROXY_TO_PTHREAD', '-DPROXY_TO_PTHREAD=1', '--js-library', test_file('pthread/call_sync_on_main_thread.js')])
+    self.btest_exit('pthread/call_sync_on_main_thread.c', args=['-O3', '-pthread', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread/call_sync_on_main_thread.js')])
+    self.btest_exit('pthread/call_sync_on_main_thread.c', args=['-Oz', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread/call_sync_on_main_thread.js')])
 
   # Test that it is possible to asynchronously call a JavaScript function on the
   # main thread.
   def test_pthread_call_async_on_main_thread(self):
-    self.btest(
-      'pthread/call_async_on_main_thread.c',
-      expected='7',
-      args=[
-        '-O3',
-        '-pthread',
-        '-sPROXY_TO_PTHREAD',
-        '-DPROXY_TO_PTHREAD=1',
-        '--js-library',
-        test_file('pthread/call_async_on_main_thread.js'),
-      ],
-    )
-    self.btest(
-      'pthread/call_async_on_main_thread.c',
-      expected='7',
-      args=[
-        '-O3',
-        '-pthread',
-        '-DPROXY_TO_PTHREAD=0',
-        '--js-library',
-        test_file('pthread/call_async_on_main_thread.js'),
-      ],
-    )
-    self.btest(
-      'pthread/call_async_on_main_thread.c',
-      expected='7',
-      args=['-Oz', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread/call_async_on_main_thread.js')],
-    )
+    self.btest('pthread/call_async_on_main_thread.c', expected='7', args=['-O3', '-pthread', '-sPROXY_TO_PTHREAD', '-DPROXY_TO_PTHREAD=1', '--js-library', test_file('pthread/call_async_on_main_thread.js')])
+    self.btest('pthread/call_async_on_main_thread.c', expected='7', args=['-O3', '-pthread', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread/call_async_on_main_thread.js')])
+    self.btest('pthread/call_async_on_main_thread.c', expected='7', args=['-Oz', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread/call_async_on_main_thread.js')])
 
   # Tests that spawning a new thread does not cause a reinitialization of the
   # global data section of the application memory area.
   def test_pthread_global_data_initialization(self):
-    for args in (
-      ['-sMODULARIZE', '-sEXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')],
-      ['-O3'],
-    ):
-      self.btest_exit(
-        'pthread/test_pthread_global_data_initialization.c',
-        args=args + ['-pthread', '-sPROXY_TO_PTHREAD', '-sPTHREAD_POOL_SIZE'],
-      )
+    for args in (['-sMODULARIZE', '-sEXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')], ['-O3']):
+      self.btest_exit('pthread/test_pthread_global_data_initialization.c', args=args + ['-pthread', '-sPROXY_TO_PTHREAD', '-sPTHREAD_POOL_SIZE'])
 
   @requires_wasm2js
   def test_pthread_global_data_initialization_in_sync_compilation_mode(self):
-    self.btest_exit(
-      'pthread/test_pthread_global_data_initialization.c',
-      args=['-sWASM_ASYNC_COMPILATION=0', '-pthread', '-sPROXY_TO_PTHREAD', '-sPTHREAD_POOL_SIZE'],
-    )
+    self.btest_exit('pthread/test_pthread_global_data_initialization.c', args=['-sWASM_ASYNC_COMPILATION=0', '-pthread', '-sPROXY_TO_PTHREAD', '-sPTHREAD_POOL_SIZE'])
 
   # Test that emscripten_get_now() reports coherent wallclock times across all
   # pthreads, instead of each pthread independently reporting wallclock times
@@ -5462,60 +3991,33 @@ def test_pthread_safe_stack(self):
     # Note that as the test runs with PROXY_TO_PTHREAD, we set STACK_SIZE,
     # and not DEFAULT_PTHREAD_STACK_SIZE, as the pthread for main() gets the
     # same stack size as the main thread normally would.
-    self.btest(
-      'core/test_safe_stack.c',
-      expected='abort:stack overflow',
-      args=['-pthread', '-sPROXY_TO_PTHREAD', '-sSTACK_OVERFLOW_CHECK=2', '-sSTACK_SIZE=64KB'],
-    )
+    self.btest('core/test_safe_stack.c', expected='abort:stack overflow', args=['-pthread', '-sPROXY_TO_PTHREAD', '-sSTACK_OVERFLOW_CHECK=2', '-sSTACK_SIZE=64KB'])
 
   @no_wasm64('TODO: ASAN in memory64')
-  @parameterized(
-    {
-      'leak': ['test_pthread_lsan_leak', ['-gsource-map']],
-      'no_leak': ['test_pthread_lsan_no_leak', []],
-    }
-  )
+  @parameterized({
+    'leak': ['test_pthread_lsan_leak', ['-gsource-map']],
+    'no_leak': ['test_pthread_lsan_no_leak', []],
+  })
   @no_firefox('https://github.com/emscripten-core/emscripten/issues/15978')
   def test_pthread_lsan(self, name, args):
-    self.btest(
-      Path('pthread', name + '.cpp'),
-      expected='1',
-      args=['-fsanitize=leak', '-pthread', '-sPROXY_TO_PTHREAD', '--pre-js', test_file('pthread', name + '.js')] + args,
-    )
+    self.btest(Path('pthread', name + '.cpp'), expected='1', args=['-fsanitize=leak', '-pthread', '-sPROXY_TO_PTHREAD', '--pre-js', test_file('pthread', name + '.js')] + args)
 
   @no_wasm64('TODO: ASAN in memory64')
   @no_2gb('ASAN + GLOBAL_BASE')
   @no_4gb('ASAN + GLOBAL_BASE')
-  @parameterized(
-    {
-      # Reusing the LSan test files for ASan.
-      'leak': ['test_pthread_lsan_leak', ['-gsource-map']],
-      'no_leak': ['test_pthread_lsan_no_leak', []],
-    }
-  )
+  @parameterized({
+    # Reusing the LSan test files for ASan.
+    'leak': ['test_pthread_lsan_leak', ['-gsource-map']],
+    'no_leak': ['test_pthread_lsan_no_leak', []],
+  })
   def test_pthread_asan(self, name, args):
-    self.btest(
-      Path('pthread', name + '.cpp'),
-      expected='1',
-      args=['-fsanitize=address', '-pthread', '-sPROXY_TO_PTHREAD', '--pre-js', test_file('pthread', name + '.js')]
-      + args,
-    )
+    self.btest(Path('pthread', name + '.cpp'), expected='1', args=['-fsanitize=address', '-pthread', '-sPROXY_TO_PTHREAD', '--pre-js', test_file('pthread', name + '.js')] + args)
 
   @no_wasm64('TODO: ASAN in memory64')
   @no_2gb('ASAN + GLOBAL_BASE')
   @no_4gb('ASAN + GLOBAL_BASE')
   def test_pthread_asan_use_after_free(self):
-    self.btest(
-      'pthread/test_pthread_asan_use_after_free.cpp',
-      expected='1',
-      args=[
-        '-fsanitize=address',
-        '-pthread',
-        '-sPROXY_TO_PTHREAD',
-        '--pre-js',
-        test_file('pthread/test_pthread_asan_use_after_free.js'),
-      ],
-    )
+    self.btest('pthread/test_pthread_asan_use_after_free.cpp', expected='1', args=['-fsanitize=address', '-pthread', '-sPROXY_TO_PTHREAD', '--pre-js', test_file('pthread/test_pthread_asan_use_after_free.js')])
 
   @no_wasm64('TODO: ASAN in memory64')
   @no_2gb('ASAN + GLOBAL_BASE')
@@ -5527,27 +4029,20 @@ def test_pthread_asan_use_after_free_2(self):
     # of proxy-to-pthread, and also the allocation happens on the pthread
     # (which tests that it can use the offset converter to get the stack
     # trace there)
-    self.btest(
-      'pthread/test_pthread_asan_use_after_free_2.cpp',
-      expected='1',
-      args=[
-        '-fsanitize=address',
-        '-pthread',
-        '-sPTHREAD_POOL_SIZE=1',
-        '--pre-js',
-        test_file('pthread/test_pthread_asan_use_after_free_2.js'),
-      ],
-    )
+    self.btest('pthread/test_pthread_asan_use_after_free_2.cpp', expected='1', args=['-fsanitize=address', '-pthread', '-sPTHREAD_POOL_SIZE=1', '--pre-js', test_file('pthread/test_pthread_asan_use_after_free_2.js')])
 
   def test_pthread_exit_process(self):
-    args = ['-pthread', '-sPROXY_TO_PTHREAD', '-sPTHREAD_POOL_SIZE=2', '-sEXIT_RUNTIME', '-DEXIT_RUNTIME', '-O0']
+    args = ['-pthread',
+            '-sPROXY_TO_PTHREAD',
+            '-sPTHREAD_POOL_SIZE=2',
+            '-sEXIT_RUNTIME',
+            '-DEXIT_RUNTIME',
+            '-O0']
     args += ['--pre-js', test_file('core/pthread/test_pthread_exit_runtime.pre.js')]
     self.btest('core/pthread/test_pthread_exit_runtime.c', expected='onExit status: 42', args=args)
 
   def test_pthread_trap(self):
-    create_file(
-      'pre.js',
-      '''
+    create_file('pre.js', '''
     if (typeof window === 'object' && window) {
       window.addEventListener('error', function(e) {
         if (e.error && e.error.message.includes('unreachable'))
@@ -5555,9 +4050,12 @@ def test_pthread_trap(self):
         else
           maybeReportResultToServer("unexpected: " + e);
       });
-    }''',
-    )
-    args = ['-pthread', '-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME', '--profiling-funcs', '--pre-js=pre.js']
+    }''')
+    args = ['-pthread',
+            '-sPROXY_TO_PTHREAD',
+            '-sEXIT_RUNTIME',
+            '--profiling-funcs',
+            '--pre-js=pre.js']
     self.btest('pthread/test_pthread_trap.c', expected='expected exception caught', args=args)
 
   # Tests MAIN_THREAD_EM_ASM_INT() function call signatures.
@@ -5565,23 +4063,15 @@ def test_main_thread_em_asm_signatures(self):
     self.btest_exit('core/test_em_asm_signatures.cpp', assert_returncode=121, args=[])
 
   def test_main_thread_em_asm_signatures_pthreads(self):
-    self.btest_exit(
-      'core/test_em_asm_signatures.cpp',
-      assert_returncode=121,
-      args=['-O3', '-pthread', '-sPROXY_TO_PTHREAD', '-sASSERTIONS'],
-    )
+    self.btest_exit('core/test_em_asm_signatures.cpp', assert_returncode=121, args=['-O3', '-pthread', '-sPROXY_TO_PTHREAD', '-sASSERTIONS'])
 
   def test_main_thread_async_em_asm(self):
-    self.btest_exit(
-      'core/test_main_thread_async_em_asm.cpp', args=['-O3', '-pthread', '-sPROXY_TO_PTHREAD', '-sASSERTIONS']
-    )
+    self.btest_exit('core/test_main_thread_async_em_asm.cpp', args=['-O3', '-pthread', '-sPROXY_TO_PTHREAD', '-sASSERTIONS'])
 
   def test_main_thread_em_asm_blocking(self):
     shutil.copy(test_file('browser/test_em_asm_blocking.html'), 'page.html')
 
-    self.compile_btest(
-      'browser/test_em_asm_blocking.cpp', ['-O2', '-o', 'wasm.js', '-pthread', '-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME']
-    )
+    self.compile_btest('browser/test_em_asm_blocking.cpp', ['-O2', '-o', 'wasm.js', '-pthread', '-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME'])
     self.run_browser('page.html', '/report_result?exit:8')
 
   # Test that it is possible to send a signal via calling alarm(timeout), which in turn calls to the signal handler set by signal(SIGALRM, func);
@@ -5589,33 +4079,13 @@ def test_sigalrm(self):
     self.btest_exit('test_sigalrm.c', args=['-O3'])
 
   def test_canvas_style_proxy(self):
-    self.btest(
-      'canvas_style_proxy.c',
-      expected='1',
-      args=[
-        '--proxy-to-worker',
-        '--shell-file',
-        test_file('canvas_style_proxy_shell.html'),
-        '--pre-js',
-        test_file('canvas_style_proxy_pre.js'),
-      ],
-    )
+    self.btest('canvas_style_proxy.c', expected='1', args=['--proxy-to-worker', '--shell-file', test_file('canvas_style_proxy_shell.html'), '--pre-js', test_file('canvas_style_proxy_pre.js')])
 
   def test_canvas_size_proxy(self):
     self.btest('canvas_size_proxy.c', expected='0', args=['--proxy-to-worker'])
 
   def test_custom_messages_proxy(self):
-    self.btest(
-      'custom_messages_proxy.c',
-      expected='1',
-      args=[
-        '--proxy-to-worker',
-        '--shell-file',
-        test_file('custom_messages_proxy_shell.html'),
-        '--post-js',
-        test_file('custom_messages_proxy_postjs.js'),
-      ],
-    )
+    self.btest('custom_messages_proxy.c', expected='1', args=['--proxy-to-worker', '--shell-file', test_file('custom_messages_proxy_shell.html'), '--post-js', test_file('custom_messages_proxy_postjs.js')])
 
   def test_vanilla_html_when_proxying(self):
     for opts in (0, 1, 2):
@@ -5624,17 +4094,15 @@ def test_vanilla_html_when_proxying(self):
       create_file('test.html', '<script src="test.js"></script>')
       self.run_browser('test.html', '/report_result?0')
 
-  @parameterized(
-    {
-      '': ([], 1),
-      'O1': (['-O1'], 1),
-      'O2': (['-O2'], 1),
-      'O3': (['-O3'], 1),
-      # force it on
-      'force': (['-sWASM_ASYNC_COMPILATION'], 1),
-      'off': (['-sWASM_ASYNC_COMPILATION=0'], 0),
-    }
-  )
+  @parameterized({
+    '': ([], 1),
+    'O1': (['-O1'], 1),
+    'O2': (['-O2'], 1),
+    'O3': (['-O3'], 1),
+    # force it on
+    'force': (['-sWASM_ASYNC_COMPILATION'], 1),
+    'off': (['-sWASM_ASYNC_COMPILATION=0'], 0),
+  })
   def test_async_compile(self, opts, returncode):
     # notice when we use async compilation
     script = '''
@@ -5672,7 +4140,10 @@ def test_async_compile(self, opts, returncode):
     self.btest_exit('test_async_compile.c', assert_returncode=1, args=common_args)
 
   # Test that implementing Module.instantiateWasm() callback works.
-  @parameterized({'': ([],), 'asan': (['-fsanitize=address'],)})
+  @parameterized({
+    '': ([],),
+    'asan': (['-fsanitize=address'],)
+  })
   def test_manual_wasm_instantiate(self, args):
     if args:
       if self.is_wasm64():
@@ -5686,42 +4157,24 @@ def test_manual_wasm_instantiate(self, args):
   def test_wasm_locate_file(self):
     # Test that it is possible to define "Module.locateFile(foo)" function to locate where worker.js will be loaded from.
     ensure_dir('cdn')
-    create_file(
-      'shell2.html',
-      read_file(path_from_root('src/shell.html')).replace(
-        'var Module = {',
-        'var Module = { locateFile: function(filename) { if (filename == "test.wasm") return "cdn/test.wasm"; else return filename; }, ',
-      ),
-    )
+    create_file('shell2.html', read_file(path_from_root('src/shell.html')).replace('var Module = {', 'var Module = { locateFile: function(filename) { if (filename == "test.wasm") return "cdn/test.wasm"; else return filename; }, '))
     self.compile_btest('browser_test_hello_world.c', ['--shell-file', 'shell2.html', '-o', 'test.html'])
     shutil.move('test.wasm', Path('cdn/test.wasm'))
     self.run_browser('test.html', '/report_result?0')
 
   @also_with_threads
   def test_utf8_textdecoder(self):
-    self.btest_exit(
-      'benchmark/benchmark_utf8.c', 0, args=['--embed-file', test_file('utf8_corpus.txt') + '@/utf8_corpus.txt']
-    )
+    self.btest_exit('benchmark/benchmark_utf8.c', 0, args=['--embed-file', test_file('utf8_corpus.txt') + '@/utf8_corpus.txt'])
 
   @also_with_threads
   def test_utf16_textdecoder(self):
-    self.btest_exit(
-      'benchmark/benchmark_utf16.cpp',
-      0,
-      args=[
-        '--embed-file',
-        test_file('utf16_corpus.txt') + '@/utf16_corpus.txt',
-        '-sEXPORTED_RUNTIME_METHODS=UTF16ToString,stringToUTF16,lengthBytesUTF16',
-      ],
-    )
+    self.btest_exit('benchmark/benchmark_utf16.cpp', 0, args=['--embed-file', test_file('utf16_corpus.txt') + '@/utf16_corpus.txt', '-sEXPORTED_RUNTIME_METHODS=UTF16ToString,stringToUTF16,lengthBytesUTF16'])
 
   @also_with_threads
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['--closure=1'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['--closure=1'],),
+  })
   def test_TextDecoder(self, args):
     self.emcc_args += args
 
@@ -5745,75 +4198,55 @@ def test_TextDecoder(self, args):
     self.assertGreater(just_fallback, td_without_fallback)
 
   def test_small_js_flags(self):
-    self.btest(
-      'browser_test_hello_world.c', '0', args=['-O3', '--closure=1', '-sINCOMING_MODULE_JS_API=[]', '-sENVIRONMENT=web']
-    )
+    self.btest('browser_test_hello_world.c', '0', args=['-O3', '--closure=1', '-sINCOMING_MODULE_JS_API=[]', '-sENVIRONMENT=web'])
     # Check an absolute js code size, with some slack.
     size = os.path.getsize('test.js')
     print('size:', size)
     # Note that this size includes test harness additions (for reporting the result, etc.).
     if not self.is_wasm64() and not self.is_2gb():
-      self.check_expected_size_in_file('js', test_file('browser/test_small_js_flags.js.size'), size)
+      self.check_expected_size_in_file('js',
+                                       test_file('browser/test_small_js_flags.js.size'),
+                                       size)
 
   # Tests that it is possible to initialize and render WebGL content in a
   # pthread by using OffscreenCanvas.
   @no_chrome('https://crbug.com/961765')
-  @parameterized(
-    {
-      '': ([],),
-      # -DTEST_CHAINED_WEBGL_CONTEXT_PASSING:
-      # Tests that it is possible to transfer WebGL canvas in a chain from main
-      # thread -> thread 1 -> thread 2 and then init and render WebGL content there.
-      'chained': (['-DTEST_CHAINED_WEBGL_CONTEXT_PASSING'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    # -DTEST_CHAINED_WEBGL_CONTEXT_PASSING:
+    # Tests that it is possible to transfer WebGL canvas in a chain from main
+    # thread -> thread 1 -> thread 2 and then init and render WebGL content there.
+    'chained': (['-DTEST_CHAINED_WEBGL_CONTEXT_PASSING'],),
+  })
   @requires_offscreen_canvas
   @requires_graphics_hardware
   def test_webgl_offscreen_canvas_in_pthread(self, args):
-    self.btest(
-      'gl_in_pthread.c',
-      expected='1',
-      args=args + ['-pthread', '-sPTHREAD_POOL_SIZE=2', '-sOFFSCREENCANVAS_SUPPORT', '-lGL'],
-    )
+    self.btest('gl_in_pthread.c', expected='1', args=args + ['-pthread', '-sPTHREAD_POOL_SIZE=2', '-sOFFSCREENCANVAS_SUPPORT', '-lGL'])
 
   # Tests that it is possible to render WebGL content on a <canvas> on the main
   # thread, after it has once been used to render WebGL content in a pthread
   # first -DTEST_MAIN_THREAD_EXPLICIT_COMMIT: Test the same (WebGL on main
   # thread after pthread), but by using explicit .commit() to swap on the main
   # thread instead of implicit "swap when rAF ends" logic
-  @parameterized(
-    {
-      '': ([],),
-      'explicit': (['-DTEST_MAIN_THREAD_EXPLICIT_COMMIT'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'explicit': (['-DTEST_MAIN_THREAD_EXPLICIT_COMMIT'],),
+  })
   @requires_offscreen_canvas
   @requires_graphics_hardware
-  @disabled(
-    'This test is disabled because current OffscreenCanvas does not allow transfering it after a rendering context has been created for it.'
-  )
+  @disabled('This test is disabled because current OffscreenCanvas does not allow transfering it after a rendering context has been created for it.')
   def test_webgl_offscreen_canvas_in_mainthread_after_pthread(self, args):
-    self.btest(
-      'gl_in_mainthread_after_pthread.c',
-      expected='0',
-      args=args + ['-pthread', '-sPTHREAD_POOL_SIZE=2', '-sOFFSCREENCANVAS_SUPPORT', '-lGL'],
-    )
+    self.btest('gl_in_mainthread_after_pthread.c', expected='0', args=args + ['-pthread', '-sPTHREAD_POOL_SIZE=2', '-sOFFSCREENCANVAS_SUPPORT', '-lGL'])
 
   @requires_offscreen_canvas
   @requires_graphics_hardware
   def test_webgl_offscreen_canvas_only_in_pthread(self):
-    self.btest_exit(
-      'gl_only_in_pthread.c',
-      args=['-pthread', '-sPTHREAD_POOL_SIZE', '-sOFFSCREENCANVAS_SUPPORT', '-lGL', '-sOFFSCREEN_FRAMEBUFFER'],
-    )
+    self.btest_exit('gl_only_in_pthread.c', args=['-pthread', '-sPTHREAD_POOL_SIZE', '-sOFFSCREENCANVAS_SUPPORT', '-lGL', '-sOFFSCREEN_FRAMEBUFFER'])
 
   # Tests that rendering from client side memory without default-enabling extensions works.
   @requires_graphics_hardware
   def test_webgl_from_client_side_memory_without_default_enabled_extensions(self):
-    self.btest_exit(
-      'webgl_draw_triangle.c',
-      args=['-lGL', '-sOFFSCREEN_FRAMEBUFFER', '-DEXPLICIT_SWAP=1', '-DDRAW_FROM_CLIENT_MEMORY=1', '-sFULL_ES2'],
-    )
+    self.btest_exit('webgl_draw_triangle.c', args=['-lGL', '-sOFFSCREEN_FRAMEBUFFER', '-DEXPLICIT_SWAP=1', '-DDRAW_FROM_CLIENT_MEMORY=1', '-sFULL_ES2'])
 
   # Tests for WEBGL_multi_draw extension
   # For testing WebGL draft extensions like this, if using chrome as the browser,
@@ -5821,20 +4254,15 @@ def test_webgl_from_client_side_memory_without_default_enabled_extensions(self):
   @requires_graphics_hardware
   @no_2gb('https://crbug.com/324562920')
   @no_4gb('https://crbug.com/324562920')
-  @parameterized(
-    {
-      'arrays': (['-DMULTI_DRAW_ARRAYS'],),
-      'arrays_instanced': (['-DMULTI_DRAW_ARRAYS_INSTANCED'],),
-      'elements': (['-DMULTI_DRAW_ELEMENTS'],),
-      'elements_instanced': (['-DMULTI_DRAW_ELEMENTS_INSTANCED'],),
-    }
-  )
+  @parameterized({
+    'arrays': (['-DMULTI_DRAW_ARRAYS'],),
+    'arrays_instanced': (['-DMULTI_DRAW_ARRAYS_INSTANCED'],),
+    'elements': (['-DMULTI_DRAW_ELEMENTS'],),
+    'elements_instanced': (['-DMULTI_DRAW_ELEMENTS_INSTANCED'],),
+  })
   def test_webgl_multi_draw(self, args):
-    self.reftest(
-      'webgl_multi_draw_test.c',
-      'webgl_multi_draw.png',
-      args=['-lGL', '-sOFFSCREEN_FRAMEBUFFER', '-DEXPLICIT_SWAP'] + args,
-    )
+    self.reftest('webgl_multi_draw_test.c', 'webgl_multi_draw.png',
+                 args=['-lGL', '-sOFFSCREEN_FRAMEBUFFER', '-DEXPLICIT_SWAP'] + args)
 
   # Tests for base_vertex/base_instance extension
   # For testing WebGL draft extensions like this, if using chrome as the browser,
@@ -5845,48 +4273,42 @@ def test_webgl_multi_draw(self, args):
   def test_webgl_draw_base_vertex_base_instance(self):
     for multiDraw in (0, 1):
       for drawElements in (0, 1):
-        self.reftest(
-          'webgl_draw_base_vertex_base_instance_test.c',
-          'webgl_draw_instanced_base_vertex_base_instance.png',
-          args=[
-            '-lGL',
-            '-sMAX_WEBGL_VERSION=2',
-            '-sOFFSCREEN_FRAMEBUFFER',
-            '-DMULTI_DRAW=' + str(multiDraw),
-            '-DDRAW_ELEMENTS=' + str(drawElements),
-            '-DEXPLICIT_SWAP=1',
-            '-DWEBGL_CONTEXT_VERSION=2',
-          ],
-        )
+        self.reftest('webgl_draw_base_vertex_base_instance_test.c', 'webgl_draw_instanced_base_vertex_base_instance.png',
+                     args=['-lGL',
+                           '-sMAX_WEBGL_VERSION=2',
+                           '-sOFFSCREEN_FRAMEBUFFER',
+                           '-DMULTI_DRAW=' + str(multiDraw),
+                           '-DDRAW_ELEMENTS=' + str(drawElements),
+                           '-DEXPLICIT_SWAP=1',
+                           '-DWEBGL_CONTEXT_VERSION=2'])
 
   @requires_graphics_hardware
   def test_webgl_sample_query(self):
     self.btest_exit('webgl_sample_query.cpp', args=['-sMAX_WEBGL_VERSION=2', '-lGL'])
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      # EXT query entrypoints on WebGL 1.0
-      '': (['-sMAX_WEBGL_VERSION'],),
-      # EXT query entrypoints on a WebGL 1.0 context while built for WebGL 2.0
-      'v2': (['-sMAX_WEBGL_VERSION=2'],),
-      # builtin query entrypoints on WebGL 2.0
-      'v2api': (['-sMAX_WEBGL_VERSION=2', '-DTEST_WEBGL2'],),
-    }
-  )
+  @parameterized({
+    # EXT query entrypoints on WebGL 1.0
+    '': (['-sMAX_WEBGL_VERSION'],),
+    # EXT query entrypoints on a WebGL 1.0 context while built for WebGL 2.0
+    'v2': (['-sMAX_WEBGL_VERSION=2'],),
+    # builtin query entrypoints on WebGL 2.0
+    'v2api': (['-sMAX_WEBGL_VERSION=2', '-DTEST_WEBGL2'],),
+  })
   def test_webgl_timer_query(self, args):
     self.btest_exit('webgl_timer_query.c', args=args + ['-lGL'])
 
   # Tests that -sOFFSCREEN_FRAMEBUFFER rendering works.
   @requires_graphics_hardware
-  @parameterized({'': ([],), 'threads': (['-pthread', '-sPROXY_TO_PTHREAD'],)})
-  @parameterized(
-    {
-      '': ([],),
-      'es2': (['-sFULL_ES2'],),
-      'es3': (['-sFULL_ES3'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'threads': (['-pthread', '-sPROXY_TO_PTHREAD'],)
+  })
+  @parameterized({
+    '': ([],),
+    'es2': (['-sFULL_ES2'],),
+    'es3': (['-sFULL_ES3'],),
+  })
   def test_webgl_offscreen_framebuffer(self, version, threads):
     # Tests all the different possible versions of libgl
     args = ['-lGL', '-sOFFSCREEN_FRAMEBUFFER', '-DEXPLICIT_SWAP=1'] + threads + version
@@ -5899,32 +4321,28 @@ def test_webgl_vao_without_automatic_extensions(self):
 
   # Tests that offscreen framebuffer state restoration works
   @requires_graphics_hardware
-  @parameterized(
-    {
-      # full state restoration path on WebGL 1.0
-      'gl1_no_vao': (['-sMAX_WEBGL_VERSION=1', '-DTEST_DISABLE_VAO'],),
-      # VAO path on WebGL 1.0
-      'gl1': (['-sMAX_WEBGL_VERSION=1', '-DTEST_VERIFY_WEBGL1_VAO_SUPPORT=1'],),
-      'gl1_max_gl2': (['-sMAX_WEBGL_VERSION=2'],),
-      # VAO path on WebGL 2.0
-      'gl2': (['-sMAX_WEBGL_VERSION=2', '-DTEST_WEBGL2=1', '-DTEST_ANTIALIAS=1'],),
-      # full state restoration path on WebGL 2.0
-      'gl2_no_vao': (['-sMAX_WEBGL_VERSION=2', '-DTEST_WEBGL2=1', '-DTEST_ANTIALIAS=1', '-DTEST_DISABLE_VAO'],),
-      # blitFramebuffer path on WebGL 2.0 (falls back to VAO on Firefox < 67)
-      'gl2_no_aa': (['-sMAX_WEBGL_VERSION=2', '-DTEST_WEBGL2=1', '-DTEST_ANTIALIAS=0'],),
-    }
-  )
+  @parameterized({
+    # full state restoration path on WebGL 1.0
+    'gl1_no_vao': (['-sMAX_WEBGL_VERSION=1', '-DTEST_DISABLE_VAO'],),
+    # VAO path on WebGL 1.0
+    'gl1': (['-sMAX_WEBGL_VERSION=1', '-DTEST_VERIFY_WEBGL1_VAO_SUPPORT=1'],),
+    'gl1_max_gl2': (['-sMAX_WEBGL_VERSION=2'],),
+    # VAO path on WebGL 2.0
+    'gl2': (['-sMAX_WEBGL_VERSION=2', '-DTEST_WEBGL2=1', '-DTEST_ANTIALIAS=1'],),
+    # full state restoration path on WebGL 2.0
+    'gl2_no_vao': (['-sMAX_WEBGL_VERSION=2', '-DTEST_WEBGL2=1', '-DTEST_ANTIALIAS=1', '-DTEST_DISABLE_VAO'],),
+    # blitFramebuffer path on WebGL 2.0 (falls back to VAO on Firefox < 67)
+    'gl2_no_aa': (['-sMAX_WEBGL_VERSION=2', '-DTEST_WEBGL2=1', '-DTEST_ANTIALIAS=0'],),
+  })
   def test_webgl_offscreen_framebuffer_state_restoration(self, args, skip_vao=False):
     cmd = args + ['-lGL', '-sOFFSCREEN_FRAMEBUFFER', '-DEXPLICIT_SWAP=1']
     self.btest_exit('webgl_offscreen_framebuffer_swap_with_bad_state.c', args=cmd)
 
-  @parameterized(
-    {
-      '': ([],),
-      'es2': (['-sFULL_ES2'],),
-      'es3': (['-sFULL_ES3'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'es2': (['-sFULL_ES2'],),
+    'es3': (['-sFULL_ES3'],),
+  })
   @requires_graphics_hardware
   def test_webgl_draw_triangle_with_uniform_color(self, args):
     self.btest_exit('webgl_draw_triangle_with_uniform_color.c', args=args)
@@ -5932,9 +4350,7 @@ def test_webgl_draw_triangle_with_uniform_color(self, args):
   # Tests that using an array of structs in GL uniforms works.
   @requires_graphics_hardware
   def test_webgl_array_of_structs_uniform(self):
-    self.reftest(
-      'webgl_array_of_structs_uniform.c', 'webgl_array_of_structs_uniform.png', args=['-lGL', '-sMAX_WEBGL_VERSION=2']
-    )
+    self.reftest('webgl_array_of_structs_uniform.c', 'webgl_array_of_structs_uniform.png', args=['-lGL', '-sMAX_WEBGL_VERSION=2'])
 
   # Tests that if a WebGL context is created in a pthread on a canvas that has
   # not been transferred to that pthread, WebGL calls are then proxied to the
@@ -5946,12 +4362,10 @@ def test_webgl_array_of_structs_uniform(self):
   # automatic transferring of Module.canvas when
   # EMSCRIPTEN_PTHREAD_TRANSFERRED_CANVASES is not defined, then OffscreenCanvas
   # is also used
-  @parameterized(
-    {
-      '': ([False],),
-      'asyncify': ([True],),
-    }
-  )
+  @parameterized({
+    '': ([False],),
+    'asyncify': ([True],),
+  })
   @requires_offscreen_canvas
   @requires_graphics_hardware
   def test_webgl_offscreen_canvas_in_proxied_pthread(self, asyncify):
@@ -5962,24 +4376,18 @@ def test_webgl_offscreen_canvas_in_proxied_pthread(self, asyncify):
       args += ['-sASYNCIFY', '-DASYNCIFY']
     self.btest_exit('gl_in_proxy_pthread.c', args=args)
 
-  @parameterized(
-    {
-      '': ([],),
-      'proxy': (['-sPROXY_TO_PTHREAD'],),
-    }
-  )
-  @parameterized(
-    {
-      '': ([],),
-      'blocking': (['-DTEST_SYNC_BLOCKING_LOOP=1'],),
-    }
-  )
-  @parameterized(
-    {
-      '': ([],),
-      'offscreen': (['-sOFFSCREENCANVAS_SUPPORT', '-sOFFSCREEN_FRAMEBUFFER'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'proxy': (['-sPROXY_TO_PTHREAD'],),
+  })
+  @parameterized({
+    '': ([],),
+    'blocking': (['-DTEST_SYNC_BLOCKING_LOOP=1'],),
+  })
+  @parameterized({
+    '': ([],),
+    'offscreen': (['-sOFFSCREENCANVAS_SUPPORT', '-sOFFSCREEN_FRAMEBUFFER'],),
+  })
   @requires_graphics_hardware
   @requires_offscreen_canvas
   def test_webgl_resize_offscreencanvas_from_main_thread(self, args1, args2, args3):
@@ -5988,36 +4396,28 @@ def test_webgl_resize_offscreencanvas_from_main_thread(self, args1, args2, args3
     self.btest_exit('resize_offscreencanvas_from_main_thread.cpp', args=cmd)
 
   @requires_graphics_hardware
-  @parameterized(
-    {
-      'v1': (1,),
-      'v2': (2,),
-    }
-  )
-  @parameterized(
-    {
-      'enable': (1,),
-      'disable': (0,),
-    }
-  )
+  @parameterized({
+    'v1': (1,),
+    'v2': (2,),
+  })
+  @parameterized({
+    'enable': (1,),
+    'disable': (0,),
+  })
   def test_webgl_simple_extensions(self, webgl_version, simple_enable_extensions):
-    cmd = [
-      '-DWEBGL_CONTEXT_VERSION=' + str(webgl_version),
-      '-DWEBGL_SIMPLE_ENABLE_EXTENSION=' + str(simple_enable_extensions),
-      '-sMAX_WEBGL_VERSION=2',
-      '-sGL_SUPPORT_AUTOMATIC_ENABLE_EXTENSIONS=' + str(simple_enable_extensions),
-      '-sGL_SUPPORT_SIMPLE_ENABLE_EXTENSIONS=' + str(simple_enable_extensions),
-    ]
+    cmd = ['-DWEBGL_CONTEXT_VERSION=' + str(webgl_version),
+           '-DWEBGL_SIMPLE_ENABLE_EXTENSION=' + str(simple_enable_extensions),
+           '-sMAX_WEBGL_VERSION=2',
+           '-sGL_SUPPORT_AUTOMATIC_ENABLE_EXTENSIONS=' + str(simple_enable_extensions),
+           '-sGL_SUPPORT_SIMPLE_ENABLE_EXTENSIONS=' + str(simple_enable_extensions)]
     self.btest_exit('webgl2_simple_enable_extensions.c', args=cmd)
 
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['-sASSERTIONS', '--closure=1'],),
-      'closure_advanced': (['-sASSERTIONS', '--closure=1', '-O3'],),
-      'main_module': (['-sMAIN_MODULE=1'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['-sASSERTIONS', '--closure=1'],),
+    'closure_advanced': (['-sASSERTIONS', '--closure=1', '-O3'],),
+    'main_module': (['-sMAIN_MODULE=1'],),
+  })
   @requires_webgpu
   def test_webgpu_basic_rendering(self, args):
     self.btest_exit('webgpu_basic_rendering.cpp', args=['-sUSE_WEBGPU'] + args)
@@ -6044,43 +4444,31 @@ def test_webgpu_get_device_pthreads(self):
   # Preallocating the buffer in this was is asm.js only (wasm needs a Memory).
   @requires_wasm2js
   def test_preallocated_heap(self):
-    self.btest_exit(
-      'test_preallocated_heap.cpp',
-      args=[
-        '-sWASM=0',
-        '-sIMPORTED_MEMORY',
-        '-sINITIAL_MEMORY=16MB',
-        '-sABORTING_MALLOC=0',
-        '--shell-file',
-        test_file('test_preallocated_heap_shell.html'),
-      ],
-    )
+    self.btest_exit('test_preallocated_heap.cpp', args=['-sWASM=0', '-sIMPORTED_MEMORY', '-sINITIAL_MEMORY=16MB', '-sABORTING_MALLOC=0', '--shell-file', test_file('test_preallocated_heap_shell.html')])
 
   # Tests emscripten_fetch() usage to XHR data directly to memory without persisting results to IndexedDB.
   @also_with_wasm2js
   def test_fetch_to_memory(self):
     # Test error reporting in the negative case when the file URL doesn't exist. (http 404)
-    self.btest_exit('fetch/test_fetch_to_memory.cpp', args=['-sFETCH_DEBUG', '-sFETCH', '-DFILE_DOES_NOT_EXIST'])
+    self.btest_exit('fetch/test_fetch_to_memory.cpp',
+                    args=['-sFETCH_DEBUG', '-sFETCH', '-DFILE_DOES_NOT_EXIST'])
 
     # Test the positive case when the file URL exists. (http 200)
     shutil.copy(test_file('gears.png'), '.')
     for arg in ([], ['-sFETCH_SUPPORT_INDEXEDDB=0']):
-      self.btest_exit('fetch/test_fetch_to_memory.cpp', args=['-sFETCH_DEBUG', '-sFETCH'] + arg)
+      self.btest_exit('fetch/test_fetch_to_memory.cpp',
+                      args=['-sFETCH_DEBUG', '-sFETCH'] + arg)
 
   @also_with_wasm2js
-  @parameterized(
-    {
-      '': ([],),
-      'pthread_exit': (['-DDO_PTHREAD_EXIT'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'pthread_exit': (['-DDO_PTHREAD_EXIT'],),
+  })
   @no_firefox('https://github.com/emscripten-core/emscripten/issues/16868')
   def test_fetch_from_thread(self, args):
     shutil.copy(test_file('gears.png'), '.')
-    self.btest_exit(
-      'fetch/test_fetch_from_thread.cpp',
-      args=args + ['-pthread', '-sPROXY_TO_PTHREAD', '-sFETCH_DEBUG', '-sFETCH', '-DFILE_DOES_NOT_EXIST'],
-    )
+    self.btest_exit('fetch/test_fetch_from_thread.cpp',
+                    args=args + ['-pthread', '-sPROXY_TO_PTHREAD', '-sFETCH_DEBUG', '-sFETCH', '-DFILE_DOES_NOT_EXIST'])
 
   @also_with_wasm2js
   def test_fetch_to_indexdb(self):
@@ -6098,9 +4486,7 @@ def test_fetch_cached_xhr(self):
   @also_with_wasm2js
   def test_fetch_response_headers(self):
     shutil.copy(test_file('gears.png'), '.')
-    self.btest_exit(
-      'fetch/test_fetch_response_headers.cpp', args=['-sFETCH_DEBUG', '-sFETCH', '-pthread', '-sPROXY_TO_PTHREAD']
-    )
+    self.btest_exit('fetch/test_fetch_response_headers.cpp', args=['-sFETCH_DEBUG', '-sFETCH', '-pthread', '-sPROXY_TO_PTHREAD'])
 
   # Test emscripten_fetch() usage to stream a XHR in to memory without storing the full file in memory
   @also_with_wasm2js
@@ -6110,7 +4496,7 @@ def test_fetch_stream_file(self):
     # won't fully fit in the heap. This verifies that streaming works properly.
     s = '12345678'
     for _ in range(14):
-      s = s[::-1] + s  # length of str will be 2^17=128KB
+      s = s[::-1] + s # length of str will be 2^17=128KB
     with open('largefile.txt', 'w') as f:
       for _ in range(1024):
         f.write(s)
@@ -6130,9 +4516,7 @@ def test_fetch_xhr_abort(self):
   @also_with_wasm2js
   def test_fetch_sync_xhr(self):
     shutil.copy(test_file('gears.png'), '.')
-    self.btest_exit(
-      'fetch/test_fetch_sync_xhr.cpp', args=['-sFETCH_DEBUG', '-sFETCH', '-pthread', '-sPROXY_TO_PTHREAD']
-    )
+    self.btest_exit('fetch/test_fetch_sync_xhr.cpp', args=['-sFETCH_DEBUG', '-sFETCH', '-pthread', '-sPROXY_TO_PTHREAD'])
 
   # Tests synchronous emscripten_fetch() usage from pthread
   @no_firefox('https://github.com/emscripten-core/emscripten/issues/16868')
@@ -6145,7 +4529,8 @@ def test_fetch_sync(self):
   @also_with_wasm2js
   def test_fetch_sync_xhr_in_proxy_to_worker(self):
     shutil.copy(test_file('gears.png'), '.')
-    self.btest_exit('fetch/test_fetch_sync_xhr.cpp', args=['-sFETCH_DEBUG', '-sFETCH', '--proxy-to-worker'])
+    self.btest_exit('fetch/test_fetch_sync_xhr.cpp',
+                    args=['-sFETCH_DEBUG', '-sFETCH', '--proxy-to-worker'])
 
   @disabled('https://github.com/emscripten-core/emscripten/issues/16746')
   def test_fetch_idb_store(self):
@@ -6154,9 +4539,7 @@ def test_fetch_idb_store(self):
   @disabled('https://github.com/emscripten-core/emscripten/issues/16746')
   def test_fetch_idb_delete(self):
     shutil.copy(test_file('gears.png'), '.')
-    self.btest_exit(
-      'fetch/test_fetch_idb_delete.cpp', args=['-pthread', '-sFETCH_DEBUG', '-sFETCH', '-sWASM=0', '-sPROXY_TO_PTHREAD']
-    )
+    self.btest_exit('fetch/test_fetch_idb_delete.cpp', args=['-pthread', '-sFETCH_DEBUG', '-sFETCH', '-sWASM=0', '-sPROXY_TO_PTHREAD'])
 
   def test_fetch_post(self):
     self.btest_exit('fetch/test_fetch_post.c', args=['-sFETCH'])
@@ -6182,12 +4565,10 @@ def test_fetch_persist(self):
     create_file('myfile.dat', 'hello world\n')
     self.btest_exit('fetch/test_fetch_persist.c', args=['-sFETCH'])
 
-  @parameterized(
-    {
-      '': ([],),
-      'mt': (['-pthread', '-sPTHREAD_POOL_SIZE=2'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'mt': (['-pthread', '-sPTHREAD_POOL_SIZE=2'],),
+  })
   def test_pthread_locale(self, args):
     self.emcc_args.append('-I' + path_from_root('system/lib/libc/musl/src/internal'))
     self.emcc_args.append('-I' + path_from_root('system/lib/pthread'))
@@ -6200,63 +4581,34 @@ def test_emscripten_set_canvas_element_size(self):
 
   # Test that emscripten_get_device_pixel_ratio() is callable from pthreads (and proxies to main
   # thread to obtain the proper window.devicePixelRatio value).
-  @parameterized(
-    {
-      '': ([],),
-      'mt': (['-pthread', '-sPROXY_TO_PTHREAD'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'mt': (['-pthread', '-sPROXY_TO_PTHREAD'],),
+  })
   def test_emscripten_get_device_pixel_ratio(self, args):
     self.btest_exit('emscripten_get_device_pixel_ratio.c', args=args)
 
   # Tests that emscripten_run_script() variants of functions work in pthreads.
-  @parameterized(
-    {
-      '': ([],),
-      'mt': (['-pthread', '-sPROXY_TO_PTHREAD'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'mt': (['-pthread', '-sPROXY_TO_PTHREAD'],),
+  })
   def test_pthread_run_script(self, args):
     shutil.copy(test_file('pthread/foo.js'), '.')
     self.btest_exit('pthread/test_pthread_run_script.c', args=['-O3'] + args)
 
   # Tests emscripten_set_canvas_element_size() and OffscreenCanvas functionality in different build configurations.
   @requires_graphics_hardware
-  @parameterized(
-    {
-      '': ([], True),
-      'offscreen': (['-sOFFSCREENCANVAS_SUPPORT'], True),
-      'pthread': (['-sPROXY_TO_PTHREAD', '-pthread', '-sOFFSCREEN_FRAMEBUFFER'], True),
-      'pthread_ofb_main_loop': (
-        ['-sPROXY_TO_PTHREAD', '-pthread', '-sOFFSCREEN_FRAMEBUFFER', '-DTEST_EXPLICIT_CONTEXT_SWAP=1'],
-        True,
-      ),
-      'pthread_ofb': (
-        ['-sPROXY_TO_PTHREAD', '-pthread', '-sOFFSCREEN_FRAMEBUFFER', '-DTEST_EXPLICIT_CONTEXT_SWAP=1'],
-        False,
-      ),
-      'manual_css': (
-        [
-          '-sPROXY_TO_PTHREAD',
-          '-pthread',
-          '-sOFFSCREEN_FRAMEBUFFER',
-          '-DTEST_EXPLICIT_CONTEXT_SWAP=1',
-          '-DTEST_MANUALLY_SET_ELEMENT_CSS_SIZE=1',
-        ],
-        False,
-      ),
-    }
-  )
+  @parameterized({
+    '': ([], True),
+    'offscreen': (['-sOFFSCREENCANVAS_SUPPORT'], True),
+    'pthread': (['-sPROXY_TO_PTHREAD', '-pthread', '-sOFFSCREEN_FRAMEBUFFER'], True),
+    'pthread_ofb_main_loop': (['-sPROXY_TO_PTHREAD', '-pthread', '-sOFFSCREEN_FRAMEBUFFER', '-DTEST_EXPLICIT_CONTEXT_SWAP=1'], True),
+    'pthread_ofb': (['-sPROXY_TO_PTHREAD', '-pthread', '-sOFFSCREEN_FRAMEBUFFER', '-DTEST_EXPLICIT_CONTEXT_SWAP=1'], False),
+    'manual_css': (['-sPROXY_TO_PTHREAD', '-pthread', '-sOFFSCREEN_FRAMEBUFFER', '-DTEST_EXPLICIT_CONTEXT_SWAP=1', '-DTEST_MANUALLY_SET_ELEMENT_CSS_SIZE=1'], False),
+  })
   def test_emscripten_animate_canvas_element_size(self, args, main_loop):
-    cmd = [
-      '-lGL',
-      '-O3',
-      '-g2',
-      '--shell-file',
-      test_file('canvas_animate_resize_shell.html'),
-      '-sGL_DEBUG',
-      '-sASSERTIONS',
-    ] + args
+    cmd = ['-lGL', '-O3', '-g2', '--shell-file', test_file('canvas_animate_resize_shell.html'), '-sGL_DEBUG', '-sASSERTIONS'] + args
     if not self.is_2gb() and not self.is_4gb():
       # Thread profiler does not yet work with large pointers.
       # https://github.com/emscripten-core/emscripten/issues/21229
@@ -6266,74 +4618,52 @@ def test_emscripten_animate_canvas_element_size(self, args, main_loop):
     self.btest_exit('canvas_animate_resize.c', args=cmd)
 
   # Tests the absolute minimum pthread-enabled application.
-  @parameterized(
-    {
-      '': ([],),
-      'modularize': (
-        ['-sMODULARIZE', '-sEXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')],
-      ),
-    }
-  )
-  @parameterized({'': ([],), 'O3': (['-O3'],)})
+  @parameterized({
+    '': ([],),
+    'modularize': (['-sMODULARIZE', '-sEXPORT_NAME=MyModule', '--shell-file',
+                    test_file('shell_that_launches_modularize.html')],),
+  })
+  @parameterized({
+    '': ([],),
+    'O3': (['-O3'],)
+  })
   def test_pthread_hello_thread(self, opts, modularize):
     self.btest_exit('pthread/hello_thread.c', args=['-pthread'] + modularize + opts)
 
   # Tests that a pthreads build of -sMINIMAL_RUNTIME works well in different build modes
-  @parameterized(
-    {
-      '': ([],),
-      'modularize': (['-sMODULARIZE', '-sEXPORT_NAME=MyModule'],),
-      'O3': (['-O3'],),
-      'O3_modularize': (['-O3', '-sMODULARIZE', '-sEXPORT_NAME=MyModule'],),
-      'O3_modularize_MINIMAL_RUNTIME_2': (['-O3', '-sMODULARIZE', '-sEXPORT_NAME=MyModule', '-sMINIMAL_RUNTIME=2'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'modularize': (['-sMODULARIZE', '-sEXPORT_NAME=MyModule'],),
+    'O3': (['-O3'],),
+    'O3_modularize': (['-O3', '-sMODULARIZE', '-sEXPORT_NAME=MyModule'],),
+    'O3_modularize_MINIMAL_RUNTIME_2': (['-O3', '-sMODULARIZE', '-sEXPORT_NAME=MyModule', '-sMINIMAL_RUNTIME=2'],),
+  })
   def test_minimal_runtime_hello_thread(self, opts):
     self.btest_exit('pthread/hello_thread.c', args=['--closure=1', '-sMINIMAL_RUNTIME', '-pthread'] + opts)
 
   # Tests memory growth in pthreads mode, but still on the main thread.
-  @parameterized({'': ([],), 'proxy': (['-sPROXY_TO_PTHREAD'],)})
+  @parameterized({
+    '': ([],),
+    'proxy': (['-sPROXY_TO_PTHREAD'],)
+  })
   @no_2gb('uses INITIAL_MEMORY')
   @no_4gb('uses INITIAL_MEMORY')
   def test_pthread_growth_mainthread(self, emcc_args):
     self.emcc_args.remove('-Werror')
-    self.btest_exit(
-      'pthread/test_pthread_memory_growth_mainthread.c',
-      args=[
-        '-pthread',
-        '-sPTHREAD_POOL_SIZE=2',
-        '-sALLOW_MEMORY_GROWTH',
-        '-sINITIAL_MEMORY=32MB',
-        '-sMAXIMUM_MEMORY=256MB',
-      ]
-      + emcc_args,
-    )
+    self.btest_exit('pthread/test_pthread_memory_growth_mainthread.c', args=['-pthread', '-sPTHREAD_POOL_SIZE=2', '-sALLOW_MEMORY_GROWTH', '-sINITIAL_MEMORY=32MB', '-sMAXIMUM_MEMORY=256MB'] + emcc_args)
 
   # Tests memory growth in a pthread.
-  @parameterized(
-    {
-      '': ([],),
-      'assert': (['-sASSERTIONS'],),
-      'proxy': (['-sPROXY_TO_PTHREAD'],),
-      'minimal': (['-sMINIMAL_RUNTIME', '-sMODULARIZE', '-sEXPORT_NAME=MyModule'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'assert': (['-sASSERTIONS'],),
+    'proxy': (['-sPROXY_TO_PTHREAD'],),
+    'minimal': (['-sMINIMAL_RUNTIME', '-sMODULARIZE', '-sEXPORT_NAME=MyModule'],),
+  })
   @no_2gb('uses INITIAL_MEMORY')
   @no_4gb('uses INITIAL_MEMORY')
   def test_pthread_growth(self, emcc_args):
     self.emcc_args.remove('-Werror')
-    self.btest_exit(
-      'pthread/test_pthread_memory_growth.c',
-      args=[
-        '-pthread',
-        '-sPTHREAD_POOL_SIZE=2',
-        '-sALLOW_MEMORY_GROWTH',
-        '-sINITIAL_MEMORY=32MB',
-        '-sMAXIMUM_MEMORY=256MB',
-        '-g',
-      ]
-      + emcc_args,
-    )
+    self.btest_exit('pthread/test_pthread_memory_growth.c', args=['-pthread', '-sPTHREAD_POOL_SIZE=2', '-sALLOW_MEMORY_GROWTH', '-sINITIAL_MEMORY=32MB', '-sMAXIMUM_MEMORY=256MB', '-g'] + emcc_args)
 
   # Tests that time in a pthread is relative to the main thread, so measurements
   # on different threads are still monotonic, as if checking a single central
@@ -6365,7 +4695,10 @@ def test_single_file_html(self):
 
   # Tests that SINGLE_FILE works as intended in generated HTML with MINIMAL_RUNTIME
   @also_with_wasm2js
-  @parameterized({'': ([],), 'O3': (['-O3'],)})
+  @parameterized({
+    '': ([],),
+    'O3': (['-O3'],)
+  })
   def test_minimal_runtime_single_file_html(self, opts):
     self.btest('single_file_static_initializer.cpp', '19', args=opts + ['-sMINIMAL_RUNTIME', '-sSINGLE_FILE'])
     self.assertExists('test.html')
@@ -6384,9 +4717,7 @@ def test_single_file_in_web_environment_with_closure(self):
   def test_single_file_locate_file(self):
     self.compile_btest('browser_test_hello_world.c', ['-o', 'test.js', '-sSINGLE_FILE'])
 
-    create_file(
-      'test.html',
-      '''
+    create_file('test.html', '''
       <script>
         var Module = {
           locateFile: function (path) {
@@ -6399,8 +4730,7 @@ def test_single_file_locate_file(self):
         };
       </script>
       <script src="test.js"></script>
-    ''',
-    )
+    ''')
 
     self.run_browser('test.html', '/report_result?0')
 
@@ -6416,27 +4746,18 @@ def test_single_file_worker_js(self):
   # program can run either on the main thread (normal tests) or when we start it in
   # a Worker in this test (in that case, both the main application thread and the worker
   # threads are all inside Web Workers).
-  @parameterized(
-    {
-      '': ([],),
-      'limited_env': (['-sENVIRONMENT=worker'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'limited_env': (['-sENVIRONMENT=worker'],),
+  })
   def test_pthreads_started_in_worker(self, args):
     self.set_setting('EXIT_RUNTIME')
-    self.compile_btest(
-      'pthread/test_pthread_atomics.c',
-      ['-o', 'test.js', '-pthread', '-sPTHREAD_POOL_SIZE=8'] + args,
-      reporting=Reporting.JS_ONLY,
-    )
-    create_file(
-      'test.html',
-      '''
+    self.compile_btest('pthread/test_pthread_atomics.c', ['-o', 'test.js', '-pthread', '-sPTHREAD_POOL_SIZE=8'] + args, reporting=Reporting.JS_ONLY)
+    create_file('test.html', '''
       <script>
         new Worker('test.js');
       </script>
-    ''',
-    )
+    ''')
     self.run_browser('test.html', '/report_result?exit:0')
 
   def test_access_file_after_heap_resize(self):
@@ -6445,23 +4766,15 @@ def test_access_file_after_heap_resize(self):
 
     # with separate file packager invocation
     self.run_process([FILE_PACKAGER, 'data.data', '--preload', 'test.txt', '--js-output=' + 'data.js'])
-    self.btest_exit(
-      'access_file_after_heap_resize.c', args=['-sALLOW_MEMORY_GROWTH', '--pre-js', 'data.js', '-sFORCE_FILESYSTEM']
-    )
+    self.btest_exit('access_file_after_heap_resize.c', args=['-sALLOW_MEMORY_GROWTH', '--pre-js', 'data.js', '-sFORCE_FILESYSTEM'])
 
   def test_unicode_html_shell(self):
-    create_file(
-      'main.c',
-      r'''
+    create_file('main.c', r'''
       int main() {
         return 0;
       }
-    ''',
-    )
-    create_file(
-      'shell.html',
-      read_file(path_from_root('src/shell.html')).replace('Emscripten-Generated Code', 'Emscripten-Generated Emoji 😅'),
-    )
+    ''')
+    create_file('shell.html', read_file(path_from_root('src/shell.html')).replace('Emscripten-Generated Code', 'Emscripten-Generated Emoji 😅'))
     self.btest_exit('main.c', args=['--shell-file', 'shell.html'])
 
   # Tests the functionality of the emscripten_thread_sleep() function.
@@ -6483,13 +4796,10 @@ def test_browser_run_from_different_directory(self):
   # Similar to `test_browser_run_from_different_directory`, but asynchronous because of `-sMODULARIZE`
   def test_browser_run_from_different_directory_async(self):
     for args, creations in [
-      (
-        ['-sMODULARIZE'],
-        [
-          'Module();',  # documented way for using modularize
-          'new Module();',  # not documented as working, but we support it
-        ],
-      ),
+      (['-sMODULARIZE'], [
+        'Module();',    # documented way for using modularize
+        'new Module();' # not documented as working, but we support it
+       ]),
     ]:
       print(args)
       # compile the code with the modularize feature and the preload-file option enabled
@@ -6500,16 +4810,12 @@ def test_browser_run_from_different_directory_async(self):
       for creation in creations:
         print(creation)
         # Make sure JS is loaded from subdirectory
-        create_file(
-          'test-subdir.html',
-          '''
+        create_file('test-subdir.html', '''
           <script src="subdir/test.js"></script>
           <script>
             %s
           </script>
-        '''
-          % creation,
-        )
+        ''' % creation)
         self.run_browser('test-subdir.html', '/report_result?0')
 
   # Similar to `test_browser_run_from_different_directory`, but
@@ -6530,9 +4836,7 @@ def test_browser_modularize_no_current_script(self):
       self.compile_btest('browser_test_hello_world.c', ['-o', 'test.js'] + args)
       shutil.move('test.js', Path(filesystem_path, 'test.js'))
       shutil.move('test.wasm', Path(filesystem_path, 'test.wasm'))
-      create_file(
-        Path(filesystem_path, 'test.html'),
-        '''
+      create_file(Path(filesystem_path, 'test.html'), '''
         <script>
           setTimeout(async () => {
             let response = await fetch('test.js');
@@ -6541,9 +4845,7 @@ def test_browser_modularize_no_current_script(self):
             %s
           }, 1);
         </script>
-      '''
-        % creation,
-      )
+      ''' % creation)
       self.run_browser('/'.join(path + ['test.html']), '/report_result?0')
 
   def test_emscripten_request_animation_frame(self):
@@ -6578,17 +4880,13 @@ def test_emscripten_performance_now(self):
   def test_embind_with_pthreads(self):
     self.btest_exit('embind/test_pthreads.cpp', args=['-lembind', '-pthread', '-sPTHREAD_POOL_SIZE=2'])
 
-  @parameterized(
-    {
-      'asyncify': (['-sASYNCIFY=1'],),
-      'jspi': (['-sASYNCIFY=2', '-Wno-experimental'],),
-    }
-  )
+  @parameterized({
+    'asyncify': (['-sASYNCIFY=1'],),
+    'jspi': (['-sASYNCIFY=2', '-Wno-experimental'],),
+  })
   def test_embind(self, args):
     if is_jspi(args) and not is_chrome():
-      self.skipTest(
-        f'Current browser ({EMTEST_BROWSER}) does not support JSPI. Only chromium-based browsers ({CHROMIUM_BASED_BROWSERS}) support JSPI today.'
-      )
+      self.skipTest(f'Current browser ({EMTEST_BROWSER}) does not support JSPI. Only chromium-based browsers ({CHROMIUM_BASED_BROWSERS}) support JSPI today.')
     if is_jspi(args) and self.is_wasm64():
       self.skipTest('_emval_await fails')
 
@@ -6614,51 +4912,45 @@ def test_closure_in_web_only_target_environment_webgl(self):
     self.btest_exit('webgl_draw_triangle.c', args=['-lGL', '-sENVIRONMENT=web', '-O3', '--closure=1'])
 
   @requires_wasm2js
-  @parameterized({'': ([],), 'minimal': (['-sMINIMAL_RUNTIME'],)})
+  @parameterized({
+    '': ([],),
+    'minimal': (['-sMINIMAL_RUNTIME'],)
+  })
   def test_no_declare_asm_module_exports_wasm2js(self, args):
     # TODO(sbc): Fix closure warnings with MODULARIZE + WASM=0
     self.ldflags.append('-Wno-error=closure')
-    self.btest_exit(
-      'declare_asm_module_exports.c',
-      args=['-sDECLARE_ASM_MODULE_EXPORTS=0', '-sENVIRONMENT=web', '-O3', '--closure=1', '-sWASM=0'] + args,
-    )
-
-  @parameterized(
-    {
-      '': (1,),
-      '2': (2,),
-    }
-  )
+    self.btest_exit('declare_asm_module_exports.c', args=['-sDECLARE_ASM_MODULE_EXPORTS=0', '-sENVIRONMENT=web', '-O3', '--closure=1', '-sWASM=0'] + args)
+
+  @parameterized({
+    '': (1,),
+    '2': (2,),
+  })
   def test_no_declare_asm_module_exports_wasm_minimal_runtime(self, mode):
-    self.btest_exit(
-      'declare_asm_module_exports.c',
-      args=['-sDECLARE_ASM_MODULE_EXPORTS=0', '-sENVIRONMENT=web', '-O3', '--closure=1', f'-sMINIMAL_RUNTIME={mode}'],
-    )
+    self.btest_exit('declare_asm_module_exports.c', args=['-sDECLARE_ASM_MODULE_EXPORTS=0', '-sENVIRONMENT=web', '-O3', '--closure=1', f'-sMINIMAL_RUNTIME={mode}'])
 
   # Tests that the different code paths in src/shell_minimal_runtime.html all work ok.
-  @parameterized(
-    {
-      '': ([],),
-      'modularize': (['-sMODULARIZE'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'modularize': (['-sMODULARIZE'],),
+  })
   @also_with_wasm2js
   def test_minimal_runtime_loader_shell(self, args):
     args = ['-sMINIMAL_RUNTIME=2']
     self.btest_exit('minimal_hello.c', args=args)
 
   # Tests that -sMINIMAL_RUNTIME works well in different build modes
-  @parameterized(
-    {
-      '': ([],),
-      'streaming': (['-sMINIMAL_RUNTIME_STREAMING_WASM_COMPILATION', '--closure=1'],),
-      'streaming_inst': (['-sMINIMAL_RUNTIME_STREAMING_WASM_INSTANTIATION', '--closure=1'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'streaming': (['-sMINIMAL_RUNTIME_STREAMING_WASM_COMPILATION', '--closure=1'],),
+    'streaming_inst': (['-sMINIMAL_RUNTIME_STREAMING_WASM_INSTANTIATION', '--closure=1'],),
+  })
   def test_minimal_runtime_hello_world(self, args):
     self.btest_exit('small_hello_world.c', args=args + ['-sMINIMAL_RUNTIME'])
 
-  @parameterized({'': ([],), 'pthread': (['-sPROXY_TO_PTHREAD', '-pthread'],)})
+  @parameterized({
+    '': ([],),
+    'pthread': (['-sPROXY_TO_PTHREAD', '-pthread'],)
+  })
   def test_offset_converter(self, args):
     self.btest_exit('test_offset_converter.c', args=['-sUSE_OFFSET_CONVERTER', '-gsource-map'] + args)
 
@@ -6667,12 +4959,10 @@ def test_emscripten_unwind_to_js_event_loop(self, *args):
     self.btest_exit('test_emscripten_unwind_to_js_event_loop.c')
 
   @requires_wasm2js
-  @parameterized(
-    {
-      '': ([],),
-      'minimal': (['-sMINIMAL_RUNTIME'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'minimal': (['-sMINIMAL_RUNTIME'],),
+  })
   def test_wasm2js_fallback(self, args):
     self.set_setting('EXIT_RUNTIME')
     self.compile_btest('small_hello_world.c', ['-sWASM=2', '-o', 'test.html'] + args)
@@ -6687,16 +4977,14 @@ def test_wasm2js_fallback(self, args):
     html = read_file('test.html')
     html = html.replace('<body>', '<body><script>delete WebAssembly;</script>')
     create_file('test.html', html)
-    os.remove('test.wasm')  # Also delete the Wasm file to test that it is not attempted to be loaded.
+    os.remove('test.wasm') # Also delete the Wasm file to test that it is not attempted to be loaded.
     self.run_browser('test.html', '/report_result?exit:0')
 
   @requires_wasm2js
-  @parameterized(
-    {
-      '': ([],),
-      'minimal': (['-sMINIMAL_RUNTIME'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'minimal': (['-sMINIMAL_RUNTIME'],),
+  })
   def test_wasm2js_fallback_on_wasm_compilation_failure(self, args):
     self.set_setting('EXIT_RUNTIME')
     self.compile_btest('small_hello_world.c', ['-sWASM=2', '-o', 'test.html'] + args)
@@ -6733,24 +5021,20 @@ def test_wasm_worker_hello_embedded(self):
     self.btest_exit('wasm_worker/hello_wasm_worker.c', args=['-sWASM_WORKERS=2'])
 
   # Tests that it is possible to call emscripten_futex_wait() in Wasm Workers.
-  @parameterized(
-    {
-      '': ([],),
-      'pthread': (['-pthread'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'pthread': (['-pthread'],),
+  })
   def test_wasm_worker_futex_wait(self, args):
     self.btest('wasm_worker/wasm_worker_futex_wait.c', expected='0', args=['-sWASM_WORKERS=1', '-sASSERTIONS'] + args)
 
   # Tests Wasm Worker thread stack setup
   @also_with_minimal_runtime
-  @parameterized(
-    {
-      '0': (0,),
-      '1': (1,),
-      '2': (2,),
-    }
-  )
+  @parameterized({
+    '0': (0,),
+    '1': (1,),
+    '2': (2,),
+  })
   def test_wasm_worker_thread_stack(self, mode):
     self.btest('wasm_worker/thread_stack.c', expected='0', args=['-sWASM_WORKERS', f'-sSTACK_OVERFLOW_CHECK={mode}'])
 
@@ -6772,11 +5056,8 @@ def test_wasm_worker_self_id(self):
   # Tests direct Wasm Assembly .S file based TLS variables in Wasm Workers
   @also_with_minimal_runtime
   def test_wasm_worker_tls_wasm_assembly(self):
-    self.btest(
-      'wasm_worker/wasm_worker_tls_wasm_assembly.c',
-      expected='42',
-      args=['-sWASM_WORKERS', test_file('wasm_worker/wasm_worker_tls_wasm_assembly.S')],
-    )
+    self.btest('wasm_worker/wasm_worker_tls_wasm_assembly.c',
+               expected='42', args=['-sWASM_WORKERS', test_file('wasm_worker/wasm_worker_tls_wasm_assembly.S')])
 
   # Tests C++11 keyword thread_local for TLS in Wasm Workers
   @also_with_minimal_runtime
@@ -6786,9 +5067,7 @@ def test_wasm_worker_cpp11_thread_local(self):
   # Tests C11 keyword _Thread_local for TLS in Wasm Workers
   @also_with_minimal_runtime
   def test_wasm_worker_c11__Thread_local(self):
-    self.btest(
-      'wasm_worker/c11__Thread_local.c', expected='42', args=['-sWASM_WORKERS', '-std=gnu11']
-    )  # Cannot test C11 - because of EM_ASM must test Gnu11.
+    self.btest('wasm_worker/c11__Thread_local.c', expected='42', args=['-sWASM_WORKERS', '-std=gnu11']) # Cannot test C11 - because of EM_ASM must test Gnu11.
 
   # Tests GCC specific extension keyword __thread for TLS in Wasm Workers
   @also_with_minimal_runtime
@@ -6896,11 +5175,8 @@ def test_wasm_worker_no_proxied_js_functions(self):
     self.set_setting('ASSERTIONS')
     # Test uses the dynCall library function in its EM_ASM code
     self.set_setting('DEFAULT_LIBRARY_FUNCS_TO_INCLUDE', ['$dynCall'])
-    self.btest(
-      'wasm_worker/no_proxied_js_functions.c',
-      expected='0',
-      args=['--js-library', test_file('wasm_worker/no_proxied_js_functions.js')],
-    )
+    self.btest('wasm_worker/no_proxied_js_functions.c', expected='0',
+               args=['--js-library', test_file('wasm_worker/no_proxied_js_functions.js')])
 
   # Tests emscripten_semaphore_init(), emscripten_semaphore_waitinf_acquire() and emscripten_semaphore_release()
   @also_with_minimal_runtime
@@ -6916,17 +5192,9 @@ def test_wasm_worker_semaphore_try_acquire(self):
   def test_wasm_worker_proxied_function(self):
     error_msg = "abort:Assertion failed: Attempted to call proxied function '_proxied_js_function' in a Wasm Worker, but in Wasm Worker enabled builds, proxied function architecture is not available!"
     # Test that program aborts in ASSERTIONS-enabled builds
-    self.btest(
-      'wasm_worker/proxied_function.c',
-      expected=error_msg,
-      args=['--js-library', test_file('wasm_worker/proxied_function.js'), '-sWASM_WORKERS', '-sASSERTIONS'],
-    )
+    self.btest('wasm_worker/proxied_function.c', expected=error_msg, args=['--js-library', test_file('wasm_worker/proxied_function.js'), '-sWASM_WORKERS', '-sASSERTIONS'])
     # Test that code does not crash in ASSERTIONS-disabled builds
-    self.btest(
-      'wasm_worker/proxied_function.c',
-      expected='0',
-      args=['--js-library', test_file('wasm_worker/proxied_function.js'), '-sWASM_WORKERS', '-sASSERTIONS=0'],
-    )
+    self.btest('wasm_worker/proxied_function.c', expected='0', args=['--js-library', test_file('wasm_worker/proxied_function.js'), '-sWASM_WORKERS', '-sASSERTIONS=0'])
 
   @no_firefox('no 4GB support yet')
   @no_2gb('uses MAXIMUM_MEMORY')
@@ -6951,23 +5219,18 @@ def test_emmalloc_4gb(self):
     # means we don't compete for memory with anything else (and run it
     # at the very very end, to reduce the risk of it OOM-killing the
     # browser).
-    self.btest_exit(
-      'test_mem_growth.c',
-      args=['-sMALLOC=emmalloc', '-sABORTING_MALLOC=0', '-sALLOW_MEMORY_GROWTH=1', '-sMAXIMUM_MEMORY=4GB'],
-    )
+    self.btest_exit('test_mem_growth.c', args=['-sMALLOC=emmalloc', '-sABORTING_MALLOC=0', '-sALLOW_MEMORY_GROWTH=1', '-sMAXIMUM_MEMORY=4GB'])
 
   # Test that it is possible to malloc() a huge 3GB memory block in 4GB mode using emmalloc.
   # Also test emmalloc-memvalidate and emmalloc-memvalidate-verbose build configurations.
   @no_firefox('no 4GB support yet')
   @no_2gb('not enough space to run in this mode')
-  @parameterized(
-    {
-      '': (['-sMALLOC=emmalloc'],),
-      'debug': (['-sMALLOC=emmalloc-debug'],),
-      'memvalidate': (['-sMALLOC=emmalloc-memvalidate'],),
-      'memvalidate_verbose': (['-sMALLOC=emmalloc-memvalidate-verbose'],),
-    }
-  )
+  @parameterized({
+    '': (['-sMALLOC=emmalloc'],),
+    'debug': (['-sMALLOC=emmalloc-debug'],),
+    'memvalidate': (['-sMALLOC=emmalloc-memvalidate'],),
+    'memvalidate_verbose': (['-sMALLOC=emmalloc-memvalidate-verbose'],),
+  })
   def test_emmalloc_3gb(self, args):
     if self.is_4gb():
       self.set_setting('MAXIMUM_MEMORY', '8GB')
@@ -6986,20 +5249,18 @@ def test_dlmalloc_3gb(self):
     self.btest_exit('alloc_3gb.c', args=['-sMALLOC=dlmalloc', '-sALLOW_MEMORY_GROWTH=1'])
 
   @no_wasm64()
-  @parameterized(
-    {
-      # the fetch backend works even on the main thread: we proxy to a background
-      # thread and busy-wait
-      # this test requires one thread per fetch backend, so updates to the test
-      # will require bumping this
-      'main_thread': (['-sPTHREAD_POOL_SIZE=5'],),
-      # using proxy_to_pthread also works, of course
-      'proxy_to_pthread': (['-sPROXY_TO_PTHREAD', '-DPROXYING'],),
-      # using BigInt support affects the ABI, and should not break things. (this
-      # could be tested on either thread; do the main thread for simplicity)
-      'bigint': (['-sPTHREAD_POOL_SIZE=5', '-sWASM_BIGINT'],),
-    }
-  )
+  @parameterized({
+    # the fetch backend works even on the main thread: we proxy to a background
+    # thread and busy-wait
+    # this test requires one thread per fetch backend, so updates to the test
+    # will require bumping this
+    'main_thread': (['-sPTHREAD_POOL_SIZE=5'],),
+    # using proxy_to_pthread also works, of course
+    'proxy_to_pthread': (['-sPROXY_TO_PTHREAD', '-DPROXYING'],),
+    # using BigInt support affects the ABI, and should not break things. (this
+    # could be tested on either thread; do the main thread for simplicity)
+    'bigint': (['-sPTHREAD_POOL_SIZE=5', '-sWASM_BIGINT'],),
+  })
   def test_wasmfs_fetch_backend(self, args):
     create_file('data.dat', 'hello, fetch')
     create_file('small.dat', 'hello')
@@ -7008,20 +5269,17 @@ def test_wasmfs_fetch_backend(self, args):
     ensure_dir('subdir')
     create_file('subdir/backendfile', 'file 1')
     create_file('subdir/backendfile2', 'file 2')
-    self.btest_exit(
-      'wasmfs/wasmfs_fetch.c',
-      args=['-sWASMFS', '-pthread', '-sPROXY_TO_PTHREAD', '--js-library', test_file('wasmfs/wasmfs_fetch.js')] + args,
-    )
+    self.btest_exit('wasmfs/wasmfs_fetch.c',
+                    args=['-sWASMFS', '-pthread', '-sPROXY_TO_PTHREAD',
+                          '--js-library', test_file('wasmfs/wasmfs_fetch.js')] + args)
 
   @no_firefox('no OPFS support yet')
   @no_wasm64()
-  @parameterized(
-    {
-      '': (['-pthread', '-sPROXY_TO_PTHREAD'],),
-      'jspi': (['-Wno-experimental', '-sASYNCIFY=2'],),
-      'jspi_wasm_bigint': (['-Wno-experimental', '-sASYNCIFY=2', '-sWASM_BIGINT'],),
-    }
-  )
+  @parameterized({
+    '': (['-pthread', '-sPROXY_TO_PTHREAD'],),
+    'jspi': (['-Wno-experimental', '-sASYNCIFY=2'],),
+    'jspi_wasm_bigint': (['-Wno-experimental', '-sASYNCIFY=2', '-sWASM_BIGINT'],),
+  })
   def test_wasmfs_opfs(self, args):
     if '-sASYNCIFY=2' in args:
       self.require_jspi()
@@ -7041,16 +5299,7 @@ def test_wasmfs_opfs_errors(self):
   def test_emmalloc_memgrowth(self, *args):
     if not self.is_4gb():
       self.set_setting('MAXIMUM_MEMORY', '4GB')
-    self.btest_exit(
-      'emmalloc_memgrowth.cpp',
-      args=[
-        '-sMALLOC=emmalloc',
-        '-sALLOW_MEMORY_GROWTH=1',
-        '-sABORTING_MALLOC=0',
-        '-sASSERTIONS=2',
-        '-sMINIMAL_RUNTIME=1',
-      ],
-    )
+    self.btest_exit('emmalloc_memgrowth.cpp', args=['-sMALLOC=emmalloc', '-sALLOW_MEMORY_GROWTH=1', '-sABORTING_MALLOC=0', '-sASSERTIONS=2', '-sMINIMAL_RUNTIME=1'])
 
   @no_firefox('no 4GB support yet')
   @no_2gb('uses MAXIMUM_MEMORY')
@@ -7098,19 +5347,21 @@ def test_browser_run_with_slash_in_query_and_hash(self):
     self.run_browser('test-query-hash.html', '/report_result?0')
 
   @disabled("only run this manually, to test for race conditions")
-  @parameterized({'normal': ([],), 'assertions': (['-sASSERTIONS'],)})
+  @parameterized({
+    'normal': ([],),
+    'assertions': (['-sASSERTIONS'],)
+  })
   def test_manual_pthread_proxy_hammer(self, args):
     # the specific symptom of the hang that was fixed is that the test hangs
     # at some point, using 0% CPU. often that occured in 0-200 iterations, but
     # you may want to adjust "ITERATIONS".
-    self.btest_exit(
-      'pthread/test_pthread_proxy_hammer.cpp',
-      args=['-pthread', '-O2', '-sPROXY_TO_PTHREAD', '-DITERATIONS=1024', '-g1'] + args,
-      timeout=10000,
-      # don't run this with the default extra_tries value, as this is
-      # *meant* to notice something random, a race condition.
-      extra_tries=0,
-    )
+    self.btest_exit('pthread/test_pthread_proxy_hammer.cpp',
+                    args=['-pthread', '-O2', '-sPROXY_TO_PTHREAD',
+                          '-DITERATIONS=1024', '-g1'] + args,
+                    timeout=10000,
+                    # don't run this with the default extra_tries value, as this is
+                    # *meant* to notice something random, a race condition.
+                    extra_tries=0)
 
   def test_assert_failure(self):
     self.btest('test_assert_failure.c', 'abort:Assertion failed: false && "this is a test"')
@@ -7118,17 +5369,11 @@ def test_assert_failure(self):
   def test_pthread_unhandledrejection(self):
     # Check that an unhandled promise rejection is propagated to the main thread
     # as an error. This test is failing if it hangs!
-    self.btest(
-      'pthread/test_pthread_unhandledrejection.c',
-      args=[
-        '-pthread',
-        '-sPROXY_TO_PTHREAD',
-        '--post-js',
-        test_file('pthread/test_pthread_unhandledrejection.post.js'),
-      ],
-      # Firefox and Chrome report this slightly differently
-      expected=['exception:Uncaught rejected!', 'exception:uncaught exception: rejected!'],
-    )
+    self.btest('pthread/test_pthread_unhandledrejection.c',
+               args=['-pthread', '-sPROXY_TO_PTHREAD', '--post-js',
+                     test_file('pthread/test_pthread_unhandledrejection.post.js')],
+               # Firefox and Chrome report this slightly differently
+               expected=['exception:Uncaught rejected!', 'exception:uncaught exception: rejected!'])
 
   def test_pthread_key_recreation(self):
     self.btest_exit('pthread/test_pthread_key_recreation.c', args=['-pthread', '-sPTHREAD_POOL_SIZE=1'])
@@ -7137,22 +5382,20 @@ def test_full_js_library_strict(self):
     self.btest_exit('hello_world.c', args=['-sINCLUDE_FULL_LIBRARY', '-sSTRICT_JS'])
 
   # Tests the AudioWorklet demo
-  @parameterized(
-    {
-      '': ([],),
-      'memory64': (['-sMEMORY64'],),
-      'with_fs': (['--preload-file', test_file('hello_world.c') + '@/'],),
-      'closure': (['--closure', '1', '-Oz'],),
-      'asyncify': (['-sASYNCIFY'],),
-      'pthreads': (['-pthread', '-sPTHREAD_POOL_SIZE=2'],),
-      'pthreads_and_closure': (['-pthread', '--closure', '1', '-Oz'],),
-      'minimal_runtime': (['-sMINIMAL_RUNTIME'],),
-      'minimal_runtime_pthreads_and_closure': (['-sMINIMAL_RUNTIME', '-pthread', '--closure', '1', '-Oz'],),
-      'pthreads_es6': (['-pthread', '-sPTHREAD_POOL_SIZE=2', '-sEXPORT_ES6'],),
-      'es6': (['-sEXPORT_ES6'],),
-      'strict': (['-sSTRICT'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'memory64': (['-sMEMORY64'],),
+    'with_fs': (['--preload-file', test_file('hello_world.c') + '@/'],),
+    'closure': (['--closure', '1', '-Oz'],),
+    'asyncify': (['-sASYNCIFY'],),
+    'pthreads': (['-pthread', '-sPTHREAD_POOL_SIZE=2'],),
+    'pthreads_and_closure': (['-pthread', '--closure', '1', '-Oz'],),
+    'minimal_runtime': (['-sMINIMAL_RUNTIME'],),
+    'minimal_runtime_pthreads_and_closure': (['-sMINIMAL_RUNTIME', '-pthread', '--closure', '1', '-Oz'],),
+    'pthreads_es6': (['-pthread', '-sPTHREAD_POOL_SIZE=2', '-sEXPORT_ES6'],),
+    'es6': (['-sEXPORT_ES6'],),
+    'strict': (['-sSTRICT'],),
+  })
   def test_audio_worklet(self, args):
     if '-sMEMORY64' in args and is_firefox():
       self.skipTest('https://github.com/emscripten-core/emscripten/issues/19161')
@@ -7163,34 +5406,19 @@ def test_audio_worklet_worker(self):
     self.btest('webaudio/audioworklet_worker.c', args=['-sAUDIO_WORKLET', '-sWASM_WORKERS'], expected='1')
 
   # Tests that posting functions between the main thread and the audioworklet thread works
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['--closure', '1', '-Oz'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['--closure', '1', '-Oz'],),
+  })
   def test_audio_worklet_post_function(self, args):
     self.btest('webaudio/audioworklet_post_function.c', args=['-sAUDIO_WORKLET', '-sWASM_WORKERS'] + args, expected='1')
 
-  @parameterized(
-    {
-      '': ([],),
-      'closure': (['--closure', '1', '-Oz'],),
-    }
-  )
+  @parameterized({
+    '': ([],),
+    'closure': (['--closure', '1', '-Oz'],),
+  })
   def test_audio_worklet_modularize(self, args):
-    self.btest_exit(
-      'webaudio/audioworklet.c',
-      args=[
-        '-sAUDIO_WORKLET',
-        '-sWASM_WORKERS',
-        '-sMODULARIZE=1',
-        '-sEXPORT_NAME=MyModule',
-        '--shell-file',
-        test_file('shell_that_launches_modularize.html'),
-      ]
-      + args,
-    )
+    self.btest_exit('webaudio/audioworklet.c', args=['-sAUDIO_WORKLET', '-sWASM_WORKERS', '-sMODULARIZE=1', '-sEXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')] + args)
 
   def test_error_reporting(self):
     # Test catching/reporting Error objects
@@ -7201,12 +5429,10 @@ def test_error_reporting(self):
     create_file('post.js', 'throw "foo";')
     self.btest('hello_world.c', args=['--post-js=post.js'], expected='exception:foo')
 
-  @parameterized(
-    {
-      '': (False,),
-      'es6': (True,),
-    }
-  )
+  @parameterized({
+    '': (False,),
+    'es6': (True,),
+  })
   def test_webpack(self, es6):
     if es6:
       shutil.copytree(test_file('webpack_es6'), 'webpack')
@@ -7279,20 +5505,10 @@ def test_emrun(self):
     # delete it. Therefore switch away from that directory before launching.
     os.chdir(path_from_root())
 
-    args_base = [
-      EMRUN,
-      '--timeout',
-      '30',
-      '--safe_firefox_profile',
-      '--kill-exit',
-      '--port',
-      '6939',
-      '--verbose',
-      '--log-stdout',
-      self.in_dir('stdout.txt'),
-      '--log-stderr',
-      self.in_dir('stderr.txt'),
-    ]
+    args_base = [EMRUN, '--timeout', '30', '--safe_firefox_profile',
+                 '--kill-exit', '--port', '6939', '--verbose',
+                 '--log-stdout', self.in_dir('stdout.txt'),
+                 '--log-stderr', self.in_dir('stderr.txt')]
 
     if EMTEST_BROWSER is not None:
       # If EMTEST_BROWSER carried command line arguments to pass to the browser,
@@ -7305,7 +5521,7 @@ def test_emrun(self):
         browser_args = browser_cmd[1:]
         if 'firefox' in browser_path and ('-profile' in browser_args or '--profile' in browser_args):
           # emrun uses its own -profile, strip it out
-          parser = argparse.ArgumentParser(add_help=False)  # otherwise it throws with -headless
+          parser = argparse.ArgumentParser(add_help=False) # otherwise it throws with -headless
           parser.add_argument('-profile')
           parser.add_argument('--profile')
           browser_args = parser.parse_known_args(browser_args)[1]
@@ -7313,15 +5529,13 @@ def test_emrun(self):
           args_base += ['--browser_args', ' ' + ' '.join(browser_args)]
 
     for args in [
-      [],
-      ['--port', '0'],
-      ['--private_browsing', '--port', '6941'],
-      ['--dump_out_directory', 'other dir/multiple', '--port', '6942'],
-      ['--dump_out_directory=foo_bar', '--port', '6942'],
+        [],
+        ['--port', '0'],
+        ['--private_browsing', '--port', '6941'],
+        ['--dump_out_directory', 'other dir/multiple', '--port', '6942'],
+        ['--dump_out_directory=foo_bar', '--port', '6942'],
     ]:
-      args = (
-        args_base + args + [self.in_dir('test_emrun.html'), '--', '1', '2', '--3', 'escaped space', 'with_underscore']
-      )
+      args = args_base + args + [self.in_dir('test_emrun.html'), '--', '1', '2', '--3', 'escaped space', 'with_underscore']
       print(shared.shlex_join(args))
       proc = self.run_process(args, check=False)
       self.assertEqual(proc.returncode, 100)