From 7b1e629b611a9c8541d210bdd167e53752aecb42 Mon Sep 17 00:00:00 2001
From: Sam Clegg <sbc@chromium.org>
Date: Thu, 13 May 2021 07:31:09 -0700
Subject: [PATCH] Use python3's pathlib in test code. NFC

There are plans underway to start using pathlib more in emscripten.
See: #14074

This change a designed to test the water by using `pathlib` in test
code.

This allows us to use unix-like paths throughout the tests that will
get converted to windows-paths on windows machines automatically
by the pathlib library.
---
 tests/jsrun.py          |   2 +-
 tests/runner.py         |  31 +--
 tests/test_browser.py   | 455 ++++++++++++++++++------------------
 tests/test_core.py      | 499 ++++++++++++++++++++--------------------
 tests/test_other.py     | 327 +++++++++++++-------------
 tests/test_posixtest.py |   2 +-
 tests/test_sanity.py    |   5 +-
 tools/shared.py         |   1 +
 8 files changed, 665 insertions(+), 657 deletions(-)

diff --git a/tests/jsrun.py b/tests/jsrun.py
index 6e5a16522f98c..196add5b2b722 100644
--- a/tests/jsrun.py
+++ b/tests/jsrun.py
@@ -62,7 +62,7 @@ def check_engine(engine):
   if engine_path not in WORKING_ENGINES:
     logging.debug('Checking JS engine %s' % engine)
     try:
-      output = run_js(shared.path_from_root('tests', 'hello_world.js'), engine, skip_check=True)
+      output = run_js(shared.path_from_root('tests/hello_world.js'), engine, skip_check=True)
       if 'hello, world!' in output:
         WORKING_ENGINES[engine_path] = True
       else:
diff --git a/tests/runner.py b/tests/runner.py
index 105a88622adea..259f4871d5b22 100755
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -43,6 +43,7 @@
 import time
 import unittest
 import webbrowser
+from pathlib import Path
 from http.server import HTTPServer, SimpleHTTPRequestHandler
 from urllib.parse import unquote, unquote_plus
 
@@ -65,7 +66,7 @@
 
 def path_from_root(*pathelems):
   """Construct a path relative to the emscripten root directory."""
-  return os.path.join(__rootpath__, *pathelems)
+  return os.fspath(Path(__rootpath__, *pathelems))
 
 
 sys.path.append(path_from_root('third_party/websockify'))
@@ -111,7 +112,7 @@ def delete_contents(pathname):
 
 def test_file(*path_components):
   """Construct a path relative to the emscripten "tests" directory."""
-  return os.path.join(TEST_ROOT, *path_components)
+  return os.fspath(Path(TEST_ROOT, *path_components))
 
 
 # checks if browser testing is enabled
@@ -241,8 +242,8 @@ def modified(self):
 
 
 def ensure_dir(dirname):
-  if not os.path.isdir(dirname):
-    os.makedirs(dirname)
+  dirname = Path(dirname)
+  dirname.mkdir(parents=True, exist_ok=True)
 
 
 def limit_size(string, maxbytes=800000 * 20, maxlines=100000, max_line=5000):
@@ -259,14 +260,16 @@ def limit_size(string, maxbytes=800000 * 20, maxlines=100000, max_line=5000):
 
 
 def create_file(name, contents, binary=False):
-  assert not os.path.isabs(name)
-  mode = 'wb' if binary else 'w'
-  with open(name, mode) as f:
-    f.write(contents)
+  name = Path(name)
+  assert not name.is_absolute()
+  if binary:
+    name.write_bytes(contents)
+  else:
+    name.write_text(contents)
 
 
 def make_executable(name):
-  os.chmod(name, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
+  Path(name).chmod(stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
 
 # The core test modes
@@ -1100,8 +1103,8 @@ def get_poppler_library(self, env_init=None):
     self.set_setting('ERROR_ON_UNDEFINED_SYMBOLS', 0)
 
     self.emcc_args += [
-      '-I' + test_file('third_party', 'freetype', 'include'),
-      '-I' + test_file('third_party', 'poppler', 'include')
+      '-I' + test_file('third_party/freetype/include'),
+      '-I' + test_file('third_party/poppler/include')
     ]
 
     freetype = self.get_freetype_library()
@@ -1613,10 +1616,12 @@ def build_library(name,
     generated_libs = [generated_libs]
   source_dir = test_file(name.replace('_native', ''))
 
-  project_dir = os.path.join(build_dir, name)
+  project_dir = Path(build_dir, name)
+  print(project_dir)
   if os.path.exists(project_dir):
     shutil.rmtree(project_dir)
-  shutil.copytree(source_dir, project_dir) # Useful in debugging sometimes to comment this out, and two lines above
+  # Useful in debugging sometimes to comment this out, and two lines above
+  shutil.copytree(source_dir, project_dir)
 
   generated_libs = [os.path.join(project_dir, lib) for lib in generated_libs]
   if native:
diff --git a/tests/test_browser.py b/tests/test_browser.py
index fa48ae734fd25..48b8a926b3ea1 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -17,6 +17,7 @@
 import webbrowser
 import zlib
 from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
 from urllib.request import urlopen
 
 from runner import BrowserCore, RunnerCore, path_from_root, has_browser, EMTEST_BROWSER, Reporting
@@ -216,18 +217,15 @@ def test_zzz_html_source_map(self):
 ''')
 
   def test_emscripten_log(self):
-    self.btest_exit(test_file('emscripten_log', 'emscripten_log.cpp'),
+    self.btest_exit(test_file('emscripten_log/emscripten_log.cpp'),
                     args=['--pre-js', path_from_root('src', 'emscripten-source-map.min.js'), '-gsource-map'])
 
   def test_preload_file(self):
-    absolute_src_path = os.path.join(self.get_dir(), 'somefile.txt').replace('\\', '/')
-    open(absolute_src_path, 'w').write('''load me right before running the code please''')
+    create_file('somefile.txt', 'load me right before running the code please')
+    create_file('.somefile.txt', 'load me right before running the code please')
+    create_file('some@file.txt', 'load me right before running the code please')
 
-    absolute_src_path2 = os.path.join(self.get_dir(), '.somefile.txt').replace('\\', '/')
-    open(absolute_src_path2, 'w').write('''load me right before running the code please''')
-
-    absolute_src_path3 = os.path.join(self.get_dir(), 'some@file.txt').replace('\\', '/')
-    open(absolute_src_path3, 'w').write('''load me right before running the code please''')
+    absolute_src_path = os.path.abspath('somefile.txt')
 
     def make_main(path):
       print('make main at', path)
@@ -281,7 +279,7 @@ def make_main(path):
     else:
       # All 7-bit non-alphanumeric non-control code ASCII characters except /, : and \ are allowed.
       tricky_filename = '!#$%&\'()+,-. ;=@[]^_`{}~ "*<>?|.txt'
-    open(os.path.join(self.get_dir(), tricky_filename), 'w').write('''load me right before running the code please''')
+    create_file(tricky_filename, 'load me right before running the code please')
     make_main(tricky_filename)
     # As an Emscripten-specific feature, the character '@' must be escaped in the form '@@' to not confuse with the 'src@dst' notation.
     self.compile_btest(['main.cpp', '--preload-file', tricky_filename.replace('@', '@@'), '-o', 'page.html'])
@@ -377,12 +375,13 @@ def test_preload_file_with_manual_data_download(self):
     shutil.copyfile(test_file('manual_download_data.html'), 'manual_download_data.html')
     self.run_browser('manual_download_data.html', 'Hello!', '/report_result?1')
 
-  # Tests that if the output files have single or double quotes in them, that it will be handled by correctly escaping the names.
+  # Tests that if the output files have single or double quotes in them, that it will be handled by
+  # correctly escaping the names.
   def test_output_file_escaping(self):
     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.join(self.get_dir(), d)
+    abs_d = os.path.abspath(d)
     ensure_dir(abs_d)
     txt = 'file with ' + tricky_part + '.txt'
     abs_txt = os.path.join(abs_d, txt)
@@ -410,7 +409,7 @@ def test_output_file_escaping(self):
     data_js_file = os.path.join(abs_d, 'file with ' + tricky_part + '.js')
     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.join(self.get_dir(), page_file)
+    abs_page_file = os.path.abspath(page_file)
     self.compile_btest([cpp, '--pre-js', data_js_file, '-o', abs_page_file, '-s', 'FORCE_FILESYSTEM'])
     self.run_browser(page_file, '|load me right before|.', '/report_result?0')
 
@@ -525,9 +524,9 @@ def make_main(path):
 
   def test_multifile(self):
     # a few files inside a directory
-    ensure_dir(os.path.join('subdirr', 'moar'))
-    create_file(os.path.join('subdirr', 'data1.txt'), '1214141516171819')
-    create_file(os.path.join('subdirr', 'moar', 'data2.txt'), '3.14159265358979')
+    ensure_dir('subdirr/moar')
+    create_file('subdirr/data1.txt', '1214141516171819')
+    create_file('subdirr/moar/data2.txt', '3.14159265358979')
     create_file('main.cpp', r'''
       #include <stdio.h>
       #include <string.h>
@@ -568,7 +567,7 @@ def test_custom_file_package_url(self):
     # a few files inside a directory
     ensure_dir('subdirr')
     ensure_dir('cdn')
-    create_file(os.path.join('subdirr', 'data1.txt'), '1214141516171819')
+    create_file(Path('subdirr/data1.txt'), '1214141516171819')
     # change the file package base dir to look in a "cdn". note that normally
     # you would add this in your own custom html file etc., and not by
     # modifying the existing shell in this manner
@@ -593,7 +592,7 @@ def test_custom_file_package_url(self):
     ''')
 
     self.compile_btest(['main.cpp', '--shell-file', 'shell.html', '--preload-file', 'subdirr/data1.txt', '-o', 'test.html'])
-    shutil.move('test.data', os.path.join('cdn', 'test.data'))
+    shutil.move('test.data', Path('cdn/test.data'))
     self.run_browser('test.html', '', '/report_result?1')
 
   def test_missing_data_throws_error(self):
@@ -660,7 +659,7 @@ def test():
     # test()
 
   def test_dev_random(self):
-    self.btest(os.path.join('filesystem', 'dev_random.cpp'), expected='0')
+    self.btest(Path('filesystem/dev_random.cpp'), expected='0')
 
   def test_sdl_swsurface(self):
     self.btest('sdl_swsurface.c', args=['-lSDL', '-lGL'], expected='1')
@@ -1216,7 +1215,7 @@ def test_webgl_context_attributes(self):
 
     # Copy common code file to temporary directory
     filepath = test_file('test_webgl_context_attributes_common.c')
-    temp_filepath = os.path.join(self.get_dir(), os.path.basename(filepath))
+    temp_filepath = os.path.basename(filepath)
     shutil.copyfile(filepath, temp_filepath)
 
     # perform tests with attributes activated
@@ -1280,13 +1279,13 @@ def test_file_db(self):
   def test_fs_idbfs_sync(self):
     for extra in [[], ['-DEXTRA_WORK']]:
       secret = str(time.time())
-      self.btest(test_file('fs', 'test_idbfs_sync.c'), '1', args=['-lidbfs.js', '-DFIRST', '-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_test,_success', '-lidbfs.js'])
-      self.btest(test_file('fs', 'test_idbfs_sync.c'), '1', args=['-lidbfs.js', '-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_test,_success', '-lidbfs.js'] + extra)
+      self.btest(test_file('fs/test_idbfs_sync.c'), '1', args=['-lidbfs.js', '-DFIRST', '-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_test,_success', '-lidbfs.js'])
+      self.btest(test_file('fs/test_idbfs_sync.c'), '1', args=['-lidbfs.js', '-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_test,_success', '-lidbfs.js'] + extra)
 
   def test_fs_idbfs_sync_force_exit(self):
     secret = str(time.time())
-    self.btest(test_file('fs', 'test_idbfs_sync.c'), '1', args=['-lidbfs.js', '-DFIRST', '-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_test,_success', '-s', 'EXIT_RUNTIME', '-DFORCE_EXIT', '-lidbfs.js'])
-    self.btest(test_file('fs', 'test_idbfs_sync.c'), '1', args=['-lidbfs.js', '-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_test,_success', '-s', 'EXIT_RUNTIME', '-DFORCE_EXIT', '-lidbfs.js'])
+    self.btest(test_file('fs/test_idbfs_sync.c'), '1', args=['-lidbfs.js', '-DFIRST', '-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_test,_success', '-s', 'EXIT_RUNTIME', '-DFORCE_EXIT', '-lidbfs.js'])
+    self.btest(test_file('fs/test_idbfs_sync.c'), '1', args=['-lidbfs.js', '-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_test,_success', '-s', 'EXIT_RUNTIME', '-DFORCE_EXIT', '-lidbfs.js'])
 
   def test_fs_idbfs_fsync(self):
     # sync from persisted state into memory before main()
@@ -1305,13 +1304,13 @@ def test_fs_idbfs_fsync(self):
 
     args = ['--pre-js', 'pre.js', '-lidbfs.js', '-s', 'EXIT_RUNTIME', '-s', 'ASYNCIFY']
     secret = str(time.time())
-    self.btest(test_file('fs', 'test_idbfs_fsync.c'), '1', args=args + ['-DFIRST', '-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_success', '-lidbfs.js'])
-    self.btest(test_file('fs', 'test_idbfs_fsync.c'), '1', args=args + ['-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_success', '-lidbfs.js'])
+    self.btest(test_file('fs/test_idbfs_fsync.c'), '1', args=args + ['-DFIRST', '-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_success', '-lidbfs.js'])
+    self.btest(test_file('fs/test_idbfs_fsync.c'), '1', args=args + ['-DSECRET=\"' + secret + '\"', '-s', 'EXPORTED_FUNCTIONS=_main,_success', '-lidbfs.js'])
 
   def test_fs_memfs_fsync(self):
     args = ['-s', 'ASYNCIFY', '-s', 'EXIT_RUNTIME']
     secret = str(time.time())
-    self.btest(test_file('fs', 'test_memfs_fsync.c'), '1', args=args + ['-DSECRET=\"' + secret + '\"'])
+    self.btest(test_file('fs/test_memfs_fsync.c'), '1', args=args + ['-DSECRET=\"' + secret + '\"'])
 
   def test_fs_workerfs_read(self):
     secret = 'a' * 10
@@ -1328,41 +1327,41 @@ def test_fs_workerfs_read(self):
         }, '/work');
       };
     ''' % (secret, secret2))
-    self.btest(test_file('fs', 'test_workerfs_read.c'), '1', args=['-lworkerfs.js', '--pre-js', 'pre.js', '-DSECRET=\"' + secret + '\"', '-DSECRET2=\"' + secret2 + '\"', '--proxy-to-worker', '-lworkerfs.js'])
+    self.btest(test_file('fs/test_workerfs_read.c'), '1', args=['-lworkerfs.js', '--pre-js', 'pre.js', '-DSECRET=\"' + secret + '\"', '-DSECRET2=\"' + secret2 + '\"', '--proxy-to-worker', '-lworkerfs.js'])
 
   def test_fs_workerfs_package(self):
     create_file('file1.txt', 'first')
     ensure_dir('sub')
-    open(os.path.join('sub', 'file2.txt'), 'w').write('second')
-    self.run_process([FILE_PACKAGER, 'files.data', '--preload', 'file1.txt', os.path.join('sub', 'file2.txt'), '--separate-metadata', '--js-output=files.js'])
-    self.btest(os.path.join('fs', 'test_workerfs_package.cpp'), '1', args=['-lworkerfs.js', '--proxy-to-worker', '-lworkerfs.js'])
+    open(Path('sub/file2.txt'), 'w').write('second')
+    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):
     # generate data
     ensure_dir('subdir')
     create_file('file1.txt', '0123456789' * (1024 * 128))
-    open(os.path.join('subdir', 'file2.txt'), 'w').write('1234567890' * (1024 * 128))
+    open(Path('subdir/file2.txt'), 'w').write('1234567890' * (1024 * 128))
     random_data = bytearray(random.randint(0, 255) for x in range(1024 * 128 * 10 + 1))
     random_data[17] = ord('X')
     open('file3.txt', 'wb').write(random_data)
 
     # compress in emcc,  -s LZ4=1  tells it to tell the file packager
     print('emcc-normal')
-    self.btest(os.path.join('fs', 'test_lz4fs.cpp'), '2', args=['-s', 'LZ4=1', '--preload-file', 'file1.txt', '--preload-file', 'subdir/file2.txt', '--preload-file', 'file3.txt'])
-    assert os.path.getsize('file1.txt') + os.path.getsize(os.path.join('subdir', 'file2.txt')) + os.path.getsize('file3.txt') == 3 * 1024 * 128 * 10 + 1
+    self.btest(Path('fs/test_lz4fs.cpp'), '2', args=['-s', 'LZ4=1', '--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(os.path.join('fs', 'test_lz4fs.cpp'), '2', args=['-s', 'LZ4=1', '--preload-file', 'file1.txt', '--preload-file', 'subdir/file2.txt', '--preload-file', 'file3.txt', '-O2'])
+    self.btest(Path('fs/test_lz4fs.cpp'), '2', args=['-s', 'LZ4=1', '--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'])
     open('files.js', 'wb').write(out)
-    self.btest(os.path.join('fs', 'test_lz4fs.cpp'), '2', args=['--pre-js', 'files.js', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM'])
+    self.btest(Path('fs/test_lz4fs.cpp'), '2', args=['--pre-js', 'files.js', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM'])
     print('    opts')
-    self.btest(os.path.join('fs', 'test_lz4fs.cpp'), '2', args=['--pre-js', 'files.js', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM', '-O2'])
+    self.btest(Path('fs/test_lz4fs.cpp'), '2', args=['--pre-js', 'files.js', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM', '-O2'])
     print('    modularize')
-    self.compile_btest([test_file('fs', 'test_lz4fs.cpp'), '--pre-js', 'files.js', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM', '-s', 'MODULARIZE=1'])
+    self.compile_btest([test_file('fs/test_lz4fs.cpp'), '--pre-js', 'files.js', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM', '-s', 'MODULARIZE=1'])
     create_file('a.html', '''
       <script src="a.out.js"></script>
       <script>
@@ -1374,23 +1373,23 @@ def test_fs_lz4fs_package(self):
     # 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'])
-    self.btest(os.path.join('fs', 'test_lz4fs.cpp'), '1', args=['-DLOAD_MANUALLY', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM'])
+    self.btest(Path('fs/test_lz4fs.cpp'), '1', args=['-DLOAD_MANUALLY', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM'])
     print('    opts')
-    self.btest(os.path.join('fs', 'test_lz4fs.cpp'), '1', args=['-DLOAD_MANUALLY', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM', '-O2'])
+    self.btest(Path('fs/test_lz4fs.cpp'), '1', args=['-DLOAD_MANUALLY', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM', '-O2'])
     print('    opts+closure')
-    self.btest(os.path.join('fs', 'test_lz4fs.cpp'), '1', args=['-DLOAD_MANUALLY', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM', '-O2', '--closure=1', '-g1', '-s', 'CLOSURE_WARNINGS=quiet'])
+    self.btest(Path('fs/test_lz4fs.cpp'), '1', args=['-DLOAD_MANUALLY', '-s', 'LZ4=1', '-s', 'FORCE_FILESYSTEM', '-O2', '--closure=1', '-g1', '-s', 'CLOSURE_WARNINGS=quiet'])
 
     '''# non-lz4 for comparison
     try:
       os.mkdir('files')
     except OSError:
       pass
-    shutil.copyfile('file1.txt', os.path.join('files', 'file1.txt'))
-    shutil.copyfile('file2.txt', os.path.join('files', 'file2.txt'))
-    shutil.copyfile('file3.txt', os.path.join('files', 'file3.txt'))
+    shutil.copyfile('file1.txt', Path('files/file1.txt'))
+    shutil.copyfile('file2.txt', Path('files/file2.txt'))
+    shutil.copyfile('file3.txt', Path('files/file3.txt'))
     out = subprocess.check_output([FILE_PACKAGER, 'files.data', '--preload', 'files/file1.txt', 'files/file2.txt', 'files/file3.txt'])
     open('files.js', 'wb').write(out)
-    self.btest(os.path.join('fs', 'test_lz4fs.cpp'), '2', args=['--pre-js', 'files.js'])'''
+    self.btest(Path('fs/test_lz4fs.cpp'), '2', args=['--pre-js', 'files.js'])'''
 
   def test_separate_metadata_later(self):
     # see issue #6654 - we need to handle separate-metadata both when we run before
@@ -1398,7 +1397,7 @@ def test_separate_metadata_later(self):
 
     create_file('data.dat', ' ')
     self.run_process([FILE_PACKAGER, 'more.data', '--preload', 'data.dat', '--separate-metadata', '--js-output=more.js'])
-    self.btest(os.path.join('browser', 'separate_metadata_later.cpp'), '1', args=['-s', 'FORCE_FILESYSTEM'])
+    self.btest(Path('browser/separate_metadata_later.cpp'), '1', args=['-s', 'FORCE_FILESYSTEM'])
 
   def test_idbstore(self):
     secret = str(time.time())
@@ -1720,13 +1719,13 @@ def test_glgears_deriv(self):
   def test_glbook(self):
     self.emcc_args.remove('-Werror')
     programs = self.get_library('glbook', [
-      os.path.join('Chapter_2', 'Hello_Triangle', 'CH02_HelloTriangle.o'),
-      os.path.join('Chapter_8', 'Simple_VertexShader', 'CH08_SimpleVertexShader.o'),
-      os.path.join('Chapter_9', 'Simple_Texture2D', 'CH09_SimpleTexture2D.o'),
-      os.path.join('Chapter_9', 'Simple_TextureCubemap', 'CH09_TextureCubemap.o'),
-      os.path.join('Chapter_9', 'TextureWrap', 'CH09_TextureWrap.o'),
-      os.path.join('Chapter_10', 'MultiTexture', 'CH10_MultiTexture.o'),
-      os.path.join('Chapter_13', 'ParticleSystem', 'CH13_ParticleSystem.o'),
+      Path('Chapter_2/Hello_Triangle', 'CH02_HelloTriangle.o'),
+      Path('Chapter_8/Simple_VertexShader', 'CH08_SimpleVertexShader.o'),
+      Path('Chapter_9/Simple_Texture2D', 'CH09_SimpleTexture2D.o'),
+      Path('Chapter_9/Simple_TextureCubemap', 'CH09_TextureCubemap.o'),
+      Path('Chapter_9/TextureWrap', 'CH09_TextureWrap.o'),
+      Path('Chapter_10/MultiTexture', 'CH10_MultiTexture.o'),
+      Path('Chapter_13/ParticleSystem', 'CH13_ParticleSystem.o'),
     ], configure=None)
 
     def book_path(*pathelems):
@@ -1756,27 +1755,27 @@ def book_path(*pathelems):
   })
   def test_gles2_emulation(self, args):
     print(args)
-    shutil.copyfile(test_file('glbook', 'Chapter_10', 'MultiTexture', 'basemap.tga'), 'basemap.tga')
-    shutil.copyfile(test_file('glbook', 'Chapter_10', 'MultiTexture', 'lightmap.tga'), 'lightmap.tga')
-    shutil.copyfile(test_file('glbook', 'Chapter_13', 'ParticleSystem', 'smoke.tga'), 'smoke.tga')
+    shutil.copyfile(test_file('glbook/Chapter_10/MultiTexture/basemap.tga'), 'basemap.tga')
+    shutil.copyfile(test_file('glbook/Chapter_10/MultiTexture/lightmap.tga'), 'lightmap.tga')
+    shutil.copyfile(test_file('glbook/Chapter_13/ParticleSystem/smoke.tga'), 'smoke.tga')
 
     for source, reference in [
-      (os.path.join('glbook', 'Chapter_2', 'Hello_Triangle', 'Hello_Triangle_orig.c'), test_file('glbook', 'CH02_HelloTriangle.png')),
-      # (os.path.join('glbook', 'Chapter_8', 'Simple_VertexShader', 'Simple_VertexShader_orig.c'), test_file('glbook', 'CH08_SimpleVertexShader.png')), # XXX needs INT extension in WebGL
-      (os.path.join('glbook', 'Chapter_9', 'TextureWrap', 'TextureWrap_orig.c'), test_file('glbook', 'CH09_TextureWrap.png')),
-      # (os.path.join('glbook', 'Chapter_9', 'Simple_TextureCubemap', 'Simple_TextureCubemap_orig.c'), test_file('glbook', 'CH09_TextureCubemap.png')), # XXX needs INT extension in WebGL
-      (os.path.join('glbook', 'Chapter_9', 'Simple_Texture2D', 'Simple_Texture2D_orig.c'), test_file('glbook', 'CH09_SimpleTexture2D.png')),
-      (os.path.join('glbook', 'Chapter_10', 'MultiTexture', 'MultiTexture_orig.c'), test_file('glbook', 'CH10_MultiTexture.png')),
-      (os.path.join('glbook', 'Chapter_13', 'ParticleSystem', 'ParticleSystem_orig.c'), test_file('glbook', 'CH13_ParticleSystem.png')),
+      (Path('glbook/Chapter_2', 'Hello_Triangle', 'Hello_Triangle_orig.c'), test_file('glbook/CH02_HelloTriangle.png')),
+      # (Path('glbook/Chapter_8', 'Simple_VertexShader', 'Simple_VertexShader_orig.c'), test_file('glbook/CH08_SimpleVertexShader.png')), # XXX needs INT extension in WebGL
+      (Path('glbook/Chapter_9', 'TextureWrap', 'TextureWrap_orig.c'), test_file('glbook/CH09_TextureWrap.png')),
+      # (Path('glbook/Chapter_9', 'Simple_TextureCubemap', 'Simple_TextureCubemap_orig.c'), test_file('glbook/CH09_TextureCubemap.png')), # XXX needs INT extension in WebGL
+      (Path('glbook/Chapter_9', 'Simple_Texture2D', 'Simple_Texture2D_orig.c'), test_file('glbook/CH09_SimpleTexture2D.png')),
+      (Path('glbook/Chapter_10', 'MultiTexture', 'MultiTexture_orig.c'), test_file('glbook/CH10_MultiTexture.png')),
+      (Path('glbook/Chapter_13', 'ParticleSystem', 'ParticleSystem_orig.c'), test_file('glbook/CH13_ParticleSystem.png')),
     ]:
       print(source)
       self.btest(source,
                  reference=reference,
-                 args=['-I' + test_file('glbook', 'Common'),
-                       test_file('glbook', 'Common', 'esUtil.c'),
-                       test_file('glbook', 'Common', 'esShader.c'),
-                       test_file('glbook', 'Common', 'esShapes.c'),
-                       test_file('glbook', 'Common', 'esTransform.c'),
+                 args=['-I' + test_file('glbook/Common'),
+                       test_file('glbook/Common/esUtil.c'),
+                       test_file('glbook/Common/esShader.c'),
+                       test_file('glbook/Common/esShapes.c'),
+                       test_file('glbook/Common/esTransform.c'),
                        '-lGL', '-lEGL', '-lX11',
                        '--preload-file', 'basemap.tga', '--preload-file', 'lightmap.tga', '--preload-file', 'smoke.tga'] + args)
 
@@ -1804,7 +1803,7 @@ def setup():
     setup()
     ensure_dir('sub')
     self.run_process([FILE_PACKAGER, 'sub/test.data', '--preload', 'file1.txt', 'file2.txt'], stdout=open('script2.js', 'w'))
-    shutil.copyfile(os.path.join('sub', 'test.data'), 'test.data')
+    shutil.copyfile(Path('sub/test.data'), 'test.data')
     self.btest('emscripten_api_browser2.cpp', '1', args=['-s', 'EXPORTED_FUNCTIONS=_main,_set', '-s', 'FORCE_FILESYSTEM'])
 
   def test_emscripten_api_infloop(self):
@@ -1943,27 +1942,27 @@ def test_matrix_identity(self):
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_pre.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_pre.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_pre.c'), reference=Path('third_party/cubegeom', 'cubegeom_pre.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre_regal(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_pre.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_pre.png'), args=['-s', 'USE_REGAL', '-DUSE_REGAL', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_pre.c'), reference=Path('third_party/cubegeom', 'cubegeom_pre.png'), args=['-s', 'USE_REGAL', '-DUSE_REGAL', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @requires_sync_compilation
   def test_cubegeom_pre_relocatable(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_pre.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_pre.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL', '-s', 'RELOCATABLE'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_pre.c'), reference=Path('third_party/cubegeom', 'cubegeom_pre.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL', '-s', 'RELOCATABLE'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre2(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_pre2.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_pre2.png'), args=['-s', 'GL_DEBUG', '-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL']) # some coverage for GL_DEBUG not breaking the build
+    self.btest(Path('third_party/cubegeom', 'cubegeom_pre2.c'), reference=Path('third_party/cubegeom', 'cubegeom_pre2.png'), args=['-s', 'GL_DEBUG', '-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL']) # some coverage for GL_DEBUG not breaking the build
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre3(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_pre3.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_pre2.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_pre3.c'), reference=Path('third_party/cubegeom', 'cubegeom_pre2.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @parameterized({
     '': ([],),
@@ -1973,16 +1972,16 @@ def test_cubegeom_pre3(self):
   def test_cubegeom(self, args):
     # proxy only in the simple, normal case (we can't trace GL calls when
     # proxied)
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom.png'), args=['-O2', '-g', '-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'] + args, also_proxied=not args)
+    self.btest(Path('third_party/cubegeom', 'cubegeom.c'), reference=Path('third_party/cubegeom', 'cubegeom.png'), args=['-O2', '-g', '-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'] + args, also_proxied=not args)
 
   @requires_graphics_hardware
   def test_cubegeom_regal(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom.png'), args=['-O2', '-g', '-DUSE_REGAL', '-s', 'USE_REGAL', '-lGL', '-lSDL'], also_proxied=True)
+    self.btest(Path('third_party/cubegeom', 'cubegeom.c'), reference=Path('third_party/cubegeom', 'cubegeom.png'), args=['-O2', '-g', '-DUSE_REGAL', '-s', 'USE_REGAL', '-lGL', '-lSDL'], also_proxied=True)
 
   @requires_threads
   @requires_graphics_hardware
   def test_cubegeom_regal_mt(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom.png'), args=['-O2', '-g', '-pthread', '-DUSE_REGAL', '-s', 'USE_PTHREADS', '-s', 'USE_REGAL', '-lGL', '-lSDL'], also_proxied=False)
+    self.btest(Path('third_party/cubegeom', 'cubegeom.c'), reference=Path('third_party/cubegeom', 'cubegeom.png'), args=['-O2', '-g', '-pthread', '-DUSE_REGAL', '-s', 'USE_PTHREADS', '-s', 'USE_REGAL', '-lGL', '-lSDL'], also_proxied=False)
 
   @requires_graphics_hardware
   def test_cubegeom_proc(self):
@@ -1999,84 +1998,84 @@ def test_cubegeom_proc(self):
 ''')
     # also test -Os in wasm, which uses meta-dce, which should not break legacy gl emulation hacks
     for opts in [[], ['-O1'], ['-Os']]:
-      self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_proc.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom.png'), args=opts + ['side.c', '-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+      self.btest(Path('third_party/cubegeom', 'cubegeom_proc.c'), reference=Path('third_party/cubegeom', 'cubegeom.png'), args=opts + ['side.c', '-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_glew(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_glew.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom.png'), args=['-O2', '--closure=1', '-s', 'LEGACY_GL_EMULATION', '-lGL', '-lGLEW', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_glew.c'), reference=Path('third_party/cubegeom', 'cubegeom.png'), args=['-O2', '--closure=1', '-s', 'LEGACY_GL_EMULATION', '-lGL', '-lGLEW', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_color(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_color.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_color.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_color.c'), reference=Path('third_party/cubegeom', 'cubegeom_color.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_normal(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_normal.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_normal.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'], also_proxied=True)
+    self.btest(Path('third_party/cubegeom', 'cubegeom_normal.c'), reference=Path('third_party/cubegeom', 'cubegeom_normal.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'], also_proxied=True)
 
   @requires_graphics_hardware
   def test_cubegeom_normal_dap(self): # draw is given a direct pointer to clientside memory, no element array buffer
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_normal_dap.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_normal.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'], also_proxied=True)
+    self.btest(Path('third_party/cubegeom', 'cubegeom_normal_dap.c'), reference=Path('third_party/cubegeom', 'cubegeom_normal.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'], also_proxied=True)
 
   @requires_graphics_hardware
   def test_cubegeom_normal_dap_far(self): # indices do nto start from 0
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_normal_dap_far.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_normal.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_normal_dap_far.c'), reference=Path('third_party/cubegeom', 'cubegeom_normal.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_normal_dap_far_range(self): # glDrawRangeElements
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_normal_dap_far_range.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_normal.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_normal_dap_far_range.c'), reference=Path('third_party/cubegeom', 'cubegeom_normal.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_normal_dap_far_glda(self): # use glDrawArrays
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_normal_dap_far_glda.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_normal_dap_far_glda.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_normal_dap_far_glda.c'), reference=Path('third_party/cubegeom', 'cubegeom_normal_dap_far_glda.png'), args=['-s', 'LEGACY_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.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_normal_dap_far_glda_quad.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_normal_dap_far_glda_quad.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_normal_dap_far_glda_quad.c'), reference=Path('third_party/cubegeom', 'cubegeom_normal_dap_far_glda_quad.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_mt(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_mt.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_mt.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL']) # multitexture
+    self.btest(Path('third_party/cubegeom', 'cubegeom_mt.c'), reference=Path('third_party/cubegeom', 'cubegeom_mt.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL']) # multitexture
 
   @requires_graphics_hardware
   def test_cubegeom_color2(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_color2.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_color2.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'], also_proxied=True)
+    self.btest(Path('third_party/cubegeom', 'cubegeom_color2.c'), reference=Path('third_party/cubegeom', 'cubegeom_color2.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'], also_proxied=True)
 
   @requires_graphics_hardware
   def test_cubegeom_texturematrix(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_texturematrix.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_texturematrix.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_texturematrix.c'), reference=Path('third_party/cubegeom', 'cubegeom_texturematrix.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_fog(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_fog.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_fog.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_fog.c'), reference=Path('third_party/cubegeom', 'cubegeom_fog.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre_vao(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_pre_vao.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_pre_vao.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_pre_vao.c'), reference=Path('third_party/cubegeom', 'cubegeom_pre_vao.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre_vao_regal(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_pre_vao.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_pre_vao.png'), args=['-s', 'USE_REGAL', '-DUSE_REGAL', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_pre_vao.c'), reference=Path('third_party/cubegeom', 'cubegeom_pre_vao.png'), args=['-s', 'USE_REGAL', '-DUSE_REGAL', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre2_vao(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_pre2_vao.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_pre_vao.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_pre2_vao.c'), reference=Path('third_party/cubegeom', 'cubegeom_pre_vao.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_pre2_vao2(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_pre2_vao2.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_pre2_vao2.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_pre2_vao2.c'), reference=Path('third_party/cubegeom', 'cubegeom_pre2_vao2.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   @no_swiftshader
   def test_cubegeom_pre_vao_es(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_pre_vao_es.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_pre_vao.png'), args=['-s', 'FULL_ES2=1', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_pre_vao_es.c'), reference=Path('third_party/cubegeom', 'cubegeom_pre_vao.png'), args=['-s', 'FULL_ES2=1', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cubegeom_u4fv_2(self):
-    self.btest(os.path.join('third_party', 'cubegeom', 'cubegeom_u4fv_2.c'), reference=os.path.join('third_party', 'cubegeom', 'cubegeom_u4fv_2.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
+    self.btest(Path('third_party/cubegeom', 'cubegeom_u4fv_2.c'), reference=Path('third_party/cubegeom', 'cubegeom_u4fv_2.png'), args=['-s', 'LEGACY_GL_EMULATION', '-lGL', '-lSDL'])
 
   @requires_graphics_hardware
   def test_cube_explosion(self):
@@ -2411,7 +2410,7 @@ def test_runtime_misuse(self):
         self.btest(filename, expected='606', args=['--post-js', 'post.js'] + extra_args + mode, reporting=Reporting.NONE)
 
   def test_cwrap_early(self):
-    self.btest(os.path.join('browser', 'cwrap_early.cpp'), args=['-O2', '-s', 'ASSERTIONS', '--pre-js', test_file('browser', 'cwrap_early.js'), '-s', 'EXPORTED_RUNTIME_METHODS=[cwrap]'], expected='0')
+    self.btest(Path('browser/cwrap_early.cpp'), args=['-O2', '-s', 'ASSERTIONS', '--pre-js', test_file('browser/cwrap_early.js'), '-s', 'EXPORTED_RUNTIME_METHODS=[cwrap]'], expected='0')
 
   def test_worker_api(self):
     self.compile_btest([test_file('worker_api_worker.cpp'), '-o', 'worker.js', '-s', 'BUILD_AS_WORKER', '-s', 'EXPORTED_FUNCTIONS=_one'])
@@ -2493,7 +2492,7 @@ def test_uuid(self):
 
     # First run tests in Node and/or SPIDERMONKEY using self.run_js. Use closure compiler so we can check that
     # require('crypto').randomBytes and window.crypto.getRandomValues doesn't get minified out.
-    self.run_process([EMCC, '-O2', '--closure=1', test_file('uuid', 'test.c'), '-o', 'test.js', '-luuid'])
+    self.run_process([EMCC, '-O2', '--closure=1', test_file('uuid/test.c'), '-o', 'test.js', '-luuid'])
 
     test_js_closure = open('test.js').read()
 
@@ -2505,11 +2504,11 @@ def test_uuid(self):
     print(out)
 
     # Tidy up files that might have been created by this test.
-    try_delete(test_file('uuid', 'test.js'))
-    try_delete(test_file('uuid', 'test.js.map'))
+    try_delete(test_file('uuid/test.js'))
+    try_delete(test_file('uuid/test.js.map'))
 
     # Now run test in browser
-    self.btest(test_file('uuid', 'test.c'), '1', args=['-luuid'])
+    self.btest(test_file('uuid/test.c'), '1', args=['-luuid'])
 
   @requires_graphics_hardware
   def test_glew(self):
@@ -2568,7 +2567,7 @@ def test_html5_webgl_create_context2(self):
   # Verify bug https://github.com/emscripten-core/emscripten/issues/4556: creating a WebGL context to Module.canvas without an ID explicitly assigned to it.
   # (this only makes sense in the old deprecated -s DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=0 mode)
   def test_html5_special_event_targets(self):
-    self.btest(test_file('browser', 'html5_special_event_targets.cpp'), args=['-lGL'], expected='0')
+    self.btest(test_file('browser/html5_special_event_targets.cpp'), args=['-lGL'], expected='0')
 
   @requires_graphics_hardware
   def test_html5_webgl_destroy_context(self):
@@ -2664,19 +2663,19 @@ 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.btest(test_file('third_party', 'sokol', 'mipmap-emsc.c'), args=['-s', 'MAX_WEBGL_VERSION=2', '-lGL', '-O1'],
-               reference=os.path.join('third_party', 'sokol', 'mipmap-emsc.png'), reference_slack=2)
+    self.btest(test_file('third_party/sokol/mipmap-emsc.c'), args=['-s', 'MAX_WEBGL_VERSION=2', '-lGL', '-O1'],
+               reference=Path('third_party/sokol', 'mipmap-emsc.png'), reference_slack=2)
 
   @no_firefox('fails on CI likely due to GPU drivers there')
   @requires_graphics_hardware
   def test_webgl2_sokol_mrt(self):
-    self.btest(test_file('third_party', 'sokol', 'mrt-emcc.c'), args=['-s', 'MAX_WEBGL_VERSION=2', '-lGL'],
-               reference=os.path.join('third_party', 'sokol', 'mrt-emcc.png'))
+    self.btest(test_file('third_party/sokol/mrt-emcc.c'), args=['-s', 'MAX_WEBGL_VERSION=2', '-lGL'],
+               reference=Path('third_party/sokol', 'mrt-emcc.png'))
 
   @requires_graphics_hardware
   def test_webgl2_sokol_arraytex(self):
-    self.btest(test_file('third_party', 'sokol', 'arraytex-emsc.c'), args=['-s', 'MAX_WEBGL_VERSION=2', '-lGL'],
-               reference=os.path.join('third_party', 'sokol', 'arraytex-emsc.png'))
+    self.btest(test_file('third_party/sokol/arraytex-emsc.c'), args=['-s', 'MAX_WEBGL_VERSION=2', '-lGL'],
+               reference=Path('third_party/sokol', 'arraytex-emsc.png'))
 
   def test_sdl_touch(self):
     for opts in [[], ['-O2', '-g1', '--closure=1']]:
@@ -2730,10 +2729,10 @@ def test_locate_file(self):
       self.compile_btest(['src.cpp', '-O2', '-g', '--pre-js', 'pre.js', '--pre-js', 'data.js', '-o', 'page.html', '-s', 'FORCE_FILESYSTEM', '-s', 'WASM=' + str(wasm)])
       ensure_dir('sub')
       if wasm:
-        shutil.move('page.wasm', os.path.join('sub', 'page.wasm'))
+        shutil.move('page.wasm', Path('sub/page.wasm'))
       else:
-        shutil.move('page.html.mem', os.path.join('sub', 'page.html.mem'))
-      shutil.move('test.data', os.path.join('sub', 'test.data'))
+        shutil.move('page.html.mem', Path('sub/page.html.mem'))
+      shutil.move('test.data', Path('sub/test.data'))
       self.run_browser('page.html', None, '/report_result?1')
 
       # alternatively, put locateFile in the HTML
@@ -2754,9 +2753,9 @@ def test_locate_file(self):
       def in_html(expected, args=[]):
         self.compile_btest(['src.cpp', '-O2', '-g', '--shell-file', 'shell.html', '--pre-js', 'data.js', '-o', 'page.html', '-s', 'SAFE_HEAP', '-s', 'ASSERTIONS', '-s', 'FORCE_FILESYSTEM', '-s', 'WASM=' + str(wasm)] + args)
         if wasm:
-          shutil.move('page.wasm', os.path.join('sub', 'page.wasm'))
+          shutil.move('page.wasm', Path('sub/page.wasm'))
         else:
-          shutil.move('page.html.mem', os.path.join('sub', 'page.html.mem'))
+          shutil.move('page.html.mem', Path('sub/page.html.mem'))
         self.run_browser('page.html', None, '/report_result?' + expected)
 
       in_html('1')
@@ -3163,14 +3162,14 @@ def post_build(*args):
 
   @requires_graphics_hardware
   def test_sdl2_ttf(self):
-    shutil.copy2(test_file('freetype', 'LiberationSansBold.ttf'), self.get_dir())
+    shutil.copy2(test_file('freetype/LiberationSansBold.ttf'), self.get_dir())
     self.btest('sdl2_ttf.c', reference='sdl2_ttf.png',
                args=['-O2', '-s', 'USE_SDL=2', '-s', 'USE_SDL_TTF=2', '--embed-file', 'LiberationSansBold.ttf'],
                message='You should see colorful "hello" and "world" in the window')
 
   @requires_graphics_hardware
   def test_sdl2_ttf_rtl(self):
-    shutil.copy2(test_file('third_party', 'notofont', 'NotoNaskhArabic-Regular.ttf'), self.get_dir())
+    shutil.copy2(test_file('third_party/notofont/NotoNaskhArabic-Regular.ttf'), self.get_dir())
     self.btest('sdl2_ttf_rtl.c', reference='sdl2_ttf_rtl.png',
                args=['-O2', '-s', 'USE_SDL=2', '-s', 'USE_SDL_TTF=2', '--embed-file', 'NotoNaskhArabic-Regular.ttf'],
                message='You should see colorful "سلام" and "جهان" with shaped Arabic script in the window')
@@ -3197,7 +3196,7 @@ def test_sdl2_misc_via_object(self):
   })
   @requires_sound_hardware
   def test_sdl2_mixer_wav(self, flags):
-    shutil.copyfile(test_file('sounds', 'the_entertainer.wav'), 'sound.wav')
+    shutil.copyfile(test_file('sounds/the_entertainer.wav'), 'sound.wav')
     self.btest('sdl2_mixer_wav.c', expected='1', args=['--preload-file', 'sound.wav', '-s', 'INITIAL_MEMORY=33554432'] + flags)
 
   @parameterized({
@@ -3299,7 +3298,7 @@ def test_async_iostream(self):
   def test_async_returnvalue(self, args):
     if '@' in str(args):
       create_file('filey.txt', '["sync_tunnel", "sync_tunnel_bool"]')
-    self.btest('browser/async_returnvalue.cpp', '0', args=['-s', 'ASYNCIFY', '-s', 'ASYNCIFY_IGNORE_INDIRECT', '--js-library', test_file('browser', 'async_returnvalue.js')] + args + ['-s', 'ASSERTIONS'])
+    self.btest('browser/async_returnvalue.cpp', '0', args=['-s', 'ASYNCIFY', '-s', 'ASYNCIFY_IGNORE_INDIRECT', '--js-library', test_file('browser/async_returnvalue.js')] + args + ['-s', 'ASSERTIONS'])
 
   def test_async_stack_overflow(self):
     self.btest('browser/async_stack_overflow.cpp', 'abort:RuntimeError: unreachable', args=['-s', 'ASYNCIFY', '-s', 'ASYNCIFY_STACK_SIZE=4'])
@@ -3379,7 +3378,7 @@ def test_modularize_network_error(self):
     self.run_browser('a.html', '...', '/report_result?abort(both async and sync fetching of the wasm failed)')
 
   def test_modularize_init_error(self):
-    test_cpp_path = test_file('browser', 'test_modularize_init_error.cpp')
+    test_cpp_path = test_file('browser/test_modularize_init_error.cpp')
     browser_reporting_js_path = test_file('browser_reporting.js')
     self.compile_btest([test_cpp_path, '-s', 'MODULARIZE', '-s', 'EXPORT_NAME="createModule"', '--extern-pre-js', browser_reporting_js_path], reporting=Reporting.NONE)
     create_file('a.html', '''
@@ -3437,12 +3436,12 @@ def test_modularize_and_preload_files(self):
 
   def test_webidl(self):
     # see original in test_core.py
-    self.run_process([WEBIDL_BINDER, test_file('webidl', 'test.idl'), 'glue'])
+    self.run_process([WEBIDL_BINDER, test_file('webidl/test.idl'), 'glue'])
     self.assertExists('glue.cpp')
     self.assertExists('glue.js')
     for opts in [[], ['-O1'], ['-O2']]:
       print(opts)
-      self.btest(os.path.join('webidl', 'test.cpp'), '1', args=['--post-js', 'glue.js', '-I.', '-DBROWSER'] + opts)
+      self.btest(Path('webidl/test.cpp'), '1', args=['--post-js', 'glue.js', '-I.', '-DBROWSER'] + opts)
 
   @requires_sync_compilation
   def test_dynamic_link(self):
@@ -3646,27 +3645,27 @@ def prep_no_SAB(self):
 
   @requires_threads
   def test_pthread_c11_threads(self):
-    self.btest(test_file('pthread', 'test_pthread_c11_threads.c'),
+    self.btest(test_file('pthread/test_pthread_c11_threads.c'),
                expected='0',
                args=['-gsource-map', '-std=gnu11', '-xc', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'TOTAL_MEMORY=64mb'])
 
   @requires_threads
   def test_pthread_pool_size_strict(self):
     # Check that it doesn't fail with sufficient number of threads in the pool.
-    self.btest(test_file('pthread', 'test_pthread_c11_threads.c'),
+    self.btest(test_file('pthread/test_pthread_c11_threads.c'),
                expected='0',
                args=['-g2', '-xc', '-std=gnu11', '-pthread', '-s', 'PTHREAD_POOL_SIZE=4', '-s', 'PTHREAD_POOL_SIZE_STRICT=2', '-s', 'TOTAL_MEMORY=64mb'])
     # Check that it fails instead of deadlocking on insufficient number of threads in the pool.
-    self.btest(test_file('pthread', 'test_pthread_c11_threads.c'),
+    self.btest(test_file('pthread/test_pthread_c11_threads.c'),
                expected='abort:Assertion failed: thrd_create(&t4, thread_main, NULL) == thrd_success',
                args=['-g2', '-xc', '-std=gnu11', '-pthread', '-s', 'PTHREAD_POOL_SIZE=3', '-s', 'PTHREAD_POOL_SIZE_STRICT=2', '-s', 'TOTAL_MEMORY=64mb'])
 
   @requires_threads
   def test_pthread_in_pthread_pool_size_strict(self):
     # Check that it fails when there's a pthread creating another pthread.
-    self.btest(test_file('pthread', 'test_pthread_create_pthread.cpp'), expected='1', args=['-g2', '-pthread', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'PTHREAD_POOL_SIZE_STRICT=2'])
+    self.btest(test_file('pthread/test_pthread_create_pthread.cpp'), expected='1', args=['-g2', '-pthread', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'PTHREAD_POOL_SIZE_STRICT=2'])
     # Check that it fails when there's a pthread creating another pthread.
-    self.btest(test_file('pthread', 'test_pthread_create_pthread.cpp'), expected='-200', args=['-g2', '-pthread', '-s', 'PTHREAD_POOL_SIZE=1', '-s', 'PTHREAD_POOL_SIZE_STRICT=2'])
+    self.btest(test_file('pthread/test_pthread_create_pthread.cpp'), expected='-200', args=['-g2', '-pthread', '-s', 'PTHREAD_POOL_SIZE=1', '-s', 'PTHREAD_POOL_SIZE_STRICT=2'])
 
   # Test that the emscripten_ atomics api functions work.
   @parameterized({
@@ -3675,24 +3674,24 @@ def test_pthread_in_pthread_pool_size_strict(self):
   })
   @requires_threads
   def test_pthread_atomics(self, args=[]):
-    self.btest(test_file('pthread', 'test_pthread_atomics.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8', '-g1'] + args)
+    self.btest(test_file('pthread/test_pthread_atomics.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8', '-g1'] + args)
 
   # Test 64-bit atomics.
   @requires_threads
   def test_pthread_64bit_atomics(self):
-    self.btest(test_file('pthread', 'test_pthread_64bit_atomics.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest(test_file('pthread/test_pthread_64bit_atomics.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Test 64-bit C++11 atomics.
   @requires_threads
   def test_pthread_64bit_cxx11_atomics(self):
     for opt in [['-O0'], ['-O3']]:
       for pthreads in [[], ['-s', 'USE_PTHREADS']]:
-        self.btest(test_file('pthread', 'test_pthread_64bit_cxx11_atomics.cpp'), expected='0', args=opt + pthreads)
+        self.btest(test_file('pthread/test_pthread_64bit_cxx11_atomics.cpp'), expected='0', args=opt + pthreads)
 
   # Test c++ std::thread::hardware_concurrency()
   @requires_threads
   def test_pthread_hardware_concurrency(self):
-    self.btest(test_file('pthread', 'test_pthread_hardware_concurrency.cpp'), expected='0', args=['-O2', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE="navigator.hardwareConcurrency"'])
+    self.btest(test_file('pthread/test_pthread_hardware_concurrency.cpp'), expected='0', args=['-O2', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE="navigator.hardwareConcurrency"'])
 
   @parameterized({
     'join': ('join',),
@@ -3701,16 +3700,16 @@ def test_pthread_hardware_concurrency(self):
   @requires_threads
   def test_pthread_main_thread_blocking(self, name):
     print('Test that we error if not ALLOW_BLOCKING_ON_MAIN_THREAD')
-    self.btest(test_file('pthread', 'main_thread_%s.cpp' % name), expected='abort:Blocking on the main thread is not allowed by default.', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE', '-s', 'ALLOW_BLOCKING_ON_MAIN_THREAD=0'])
+    self.btest(test_file('pthread/main_thread_%s.cpp' % name), expected='abort:Blocking on the main thread is not allowed by default.', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE', '-s', 'ALLOW_BLOCKING_ON_MAIN_THREAD=0'])
     if name == 'join':
       print('Test that by default we just warn about blocking on the main thread.')
-      self.btest(test_file('pthread', 'main_thread_%s.cpp' % name), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
+      self.btest(test_file('pthread/main_thread_%s.cpp' % name), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
       print('Test that tryjoin is fine, even if not ALLOW_BLOCKING_ON_MAIN_THREAD')
-      self.btest(test_file('pthread', 'main_thread_join.cpp'), expected='2', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE', '-g', '-DTRY_JOIN', '-s', 'ALLOW_BLOCKING_ON_MAIN_THREAD=0'])
+      self.btest(test_file('pthread/main_thread_join.cpp'), expected='2', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE', '-g', '-DTRY_JOIN', '-s', 'ALLOW_BLOCKING_ON_MAIN_THREAD=0'])
       print('Test that tryjoin is fine, even if not ALLOW_BLOCKING_ON_MAIN_THREAD, and even without a pool')
-      self.btest(test_file('pthread', 'main_thread_join.cpp'), expected='2', args=['-O3', '-s', 'USE_PTHREADS', '-g', '-DTRY_JOIN', '-s', 'ALLOW_BLOCKING_ON_MAIN_THREAD=0'])
+      self.btest(test_file('pthread/main_thread_join.cpp'), expected='2', args=['-O3', '-s', 'USE_PTHREADS', '-g', '-DTRY_JOIN', '-s', 'ALLOW_BLOCKING_ON_MAIN_THREAD=0'])
       print('Test that everything works ok when we are on a pthread.')
-      self.btest(test_file('pthread', 'main_thread_%s.cpp' % name), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE', '-s', 'PROXY_TO_PTHREAD', '-s', 'ALLOW_BLOCKING_ON_MAIN_THREAD=0'])
+      self.btest(test_file('pthread/main_thread_%s.cpp' % name), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE', '-s', 'PROXY_TO_PTHREAD', '-s', 'ALLOW_BLOCKING_ON_MAIN_THREAD=0'])
 
   # Test the old GCC atomic __sync_fetch_and_op builtin operations.
   @no_firefox('https://bugzilla.mozilla.org/show_bug.cgi?id=1666568')
@@ -3720,37 +3719,37 @@ def test_pthread_gcc_atomic_fetch_and_op(self):
       for debug in [[], ['-g']]:
         args = opt + debug
         print(args)
-        self.btest(test_file('pthread', 'test_pthread_gcc_atomic_fetch_and_op.cpp'), expected='0', args=args + ['-s', 'INITIAL_MEMORY=64MB', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+        self.btest(test_file('pthread/test_pthread_gcc_atomic_fetch_and_op.cpp'), expected='0', args=args + ['-s', 'INITIAL_MEMORY=64MB', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # 64 bit version of the above test.
   @no_firefox('https://bugzilla.mozilla.org/show_bug.cgi?id=1666568')
   @requires_threads
   def test_pthread_gcc_64bit_atomic_fetch_and_op(self):
-    self.btest(test_file('pthread', 'test_pthread_gcc_64bit_atomic_fetch_and_op.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'], also_asmjs=True)
+    self.btest(test_file('pthread/test_pthread_gcc_64bit_atomic_fetch_and_op.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'], also_asmjs=True)
 
   # Test the old GCC atomic __sync_op_and_fetch builtin operations.
   @no_firefox('https://bugzilla.mozilla.org/show_bug.cgi?id=1666568')
   @requires_threads
   def test_pthread_gcc_atomic_op_and_fetch(self):
-    self.btest(test_file('pthread', 'test_pthread_gcc_atomic_op_and_fetch.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'], also_asmjs=True)
+    self.btest(test_file('pthread/test_pthread_gcc_atomic_op_and_fetch.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'], also_asmjs=True)
 
   # 64 bit version of the above test.
   @no_firefox('https://bugzilla.mozilla.org/show_bug.cgi?id=1666568')
   @requires_threads
   def test_pthread_gcc_64bit_atomic_op_and_fetch(self):
-    self.btest(test_file('pthread', 'test_pthread_gcc_64bit_atomic_op_and_fetch.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'], also_asmjs=True)
+    self.btest(test_file('pthread/test_pthread_gcc_64bit_atomic_op_and_fetch.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'], also_asmjs=True)
 
   # Tests the rest of the remaining GCC atomics after the two above tests.
   @no_firefox('https://bugzilla.mozilla.org/show_bug.cgi?id=1666568')
   @requires_threads
   def test_pthread_gcc_atomics(self):
-    self.btest(test_file('pthread', 'test_pthread_gcc_atomics.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest(test_file('pthread/test_pthread_gcc_atomics.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Test the __sync_lock_test_and_set and __sync_lock_release primitives.
   @requires_threads
   def test_pthread_gcc_spinlock(self):
     for arg in [[], ['-DUSE_EMSCRIPTEN_INTRINSICS']]:
-      self.btest(test_file('pthread', 'test_pthread_gcc_spinlock.cpp'), expected='800', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'] + arg, also_asmjs=True)
+      self.btest(test_file('pthread/test_pthread_gcc_spinlock.cpp'), expected='800', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'] + arg, also_asmjs=True)
 
   # Test that basic thread creation works.
   @no_firefox('https://bugzilla.mozilla.org/show_bug.cgi?id=1666568')
@@ -3758,7 +3757,7 @@ def test_pthread_gcc_spinlock(self):
   def test_pthread_create(self):
     def test(args):
       print(args)
-      self.btest(test_file('pthread', 'test_pthread_create.cpp'),
+      self.btest(test_file('pthread/test_pthread_create.cpp'),
                  expected='0',
                  args=['-s', 'INITIAL_MEMORY=64MB', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'] + args,
                  extra_tries=0) # this should be 100% deterministic
@@ -3772,118 +3771,118 @@ def test(args):
   # Test that preallocating worker threads work.
   @requires_threads
   def test_pthread_preallocates_workers(self):
-    self.btest(test_file('pthread', 'test_pthread_preallocates_workers.cpp'), expected='0', args=['-O3', '-s', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=4', '-s', 'PTHREAD_POOL_DELAY_LOAD'])
+    self.btest(test_file('pthread/test_pthread_preallocates_workers.cpp'), expected='0', args=['-O3', '-s', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=4', '-s', 'PTHREAD_POOL_DELAY_LOAD'])
 
   # Test that allocating a lot of threads doesn't regress. This needs to be checked manually!
   @requires_threads
   def test_pthread_large_pthread_allocation(self):
-    self.btest(test_file('pthread', 'test_large_pthread_allocation.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=128MB', '-O3', '-s', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=50'], message='Check output from test to ensure that a regression in time it takes to allocate the threads has not occurred.')
+    self.btest(test_file('pthread/test_large_pthread_allocation.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=128MB', '-O3', '-s', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=50'], message='Check output from test to ensure that a regression in time it takes to allocate the threads has not occurred.')
 
   # Tests the -s PROXY_TO_PTHREAD=1 option.
   @requires_threads
   def test_pthread_proxy_to_pthread(self):
-    self.btest(test_file('pthread', 'test_pthread_proxy_to_pthread.c'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD'])
+    self.btest(test_file('pthread/test_pthread_proxy_to_pthread.c'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD'])
 
   # Test that a pthread can spawn another pthread of its own.
   @requires_threads
   def test_pthread_create_pthread(self):
     for modularize in [[], ['-s', 'MODULARIZE', '-s', 'EXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')]]:
-      self.btest(test_file('pthread', 'test_pthread_create_pthread.cpp'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2'] + modularize)
+      self.btest(test_file('pthread/test_pthread_create_pthread.cpp'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2'] + modularize)
 
   # Test another case of pthreads spawning pthreads, but this time the callers immediately join on the threads they created.
   @requires_threads
   def test_pthread_nested_spawns(self):
-    self.btest(test_file('pthread', 'test_pthread_nested_spawns.cpp'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2'])
+    self.btest(test_file('pthread/test_pthread_nested_spawns.cpp'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2'])
 
   # Test that main thread can wait for a pthread to finish via pthread_join().
   @requires_threads
   def test_pthread_join(self):
-    self.btest(test_file('pthread', 'test_pthread_join.cpp'), expected='6765', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest(test_file('pthread/test_pthread_join.cpp'), expected='6765', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Test that threads can rejoin the pool once detached and finished
   @requires_threads
   def test_std_thread_detach(self):
-    self.btest(test_file('pthread', 'test_std_thread_detach.cpp'), expected='0', args=['-s', 'USE_PTHREADS'])
+    self.btest(test_file('pthread/test_std_thread_detach.cpp'), expected='0', args=['-s', 'USE_PTHREADS'])
 
   # Test pthread_cancel() operation
   @requires_threads
   def test_pthread_cancel(self):
-    self.btest(test_file('pthread', 'test_pthread_cancel.cpp'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest(test_file('pthread/test_pthread_cancel.cpp'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Test that pthread_cancel() cancels pthread_cond_wait() operation
   @requires_threads
   def test_pthread_cancel_cond_wait(self):
-    self.btest_exit(test_file('pthread', 'test_pthread_cancel_cond_wait.cpp'), assert_returncode=1, args=['-O3', '-s', 'USE_PTHREADS=1', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest_exit(test_file('pthread/test_pthread_cancel_cond_wait.cpp'), assert_returncode=1, args=['-O3', '-s', 'USE_PTHREADS=1', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Test pthread_kill() operation
   @no_chrome('pthread_kill hangs chrome renderer, and keep subsequent tests from passing')
   @requires_threads
   def test_pthread_kill(self):
-    self.btest(test_file('pthread', 'test_pthread_kill.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest(test_file('pthread/test_pthread_kill.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Test that pthread cleanup stack (pthread_cleanup_push/_pop) works.
   @requires_threads
   def test_pthread_cleanup(self):
-    self.btest(test_file('pthread', 'test_pthread_cleanup.cpp'), expected='907640832', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest(test_file('pthread/test_pthread_cleanup.cpp'), expected='907640832', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Tests the pthread mutex api.
   @requires_threads
   def test_pthread_mutex(self):
     for arg in [[], ['-DSPINLOCK_TEST']]:
-      self.btest(test_file('pthread', 'test_pthread_mutex.cpp'), expected='50', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'] + arg)
+      self.btest(test_file('pthread/test_pthread_mutex.cpp'), expected='50', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'] + arg)
 
   @requires_threads
   def test_pthread_attr_getstack(self):
-    self.btest(test_file('pthread', 'test_pthread_attr_getstack.cpp'), expected='0', args=['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2'])
+    self.btest(test_file('pthread/test_pthread_attr_getstack.cpp'), expected='0', args=['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2'])
 
   # Test that memory allocation is thread-safe.
   @requires_threads
   def test_pthread_malloc(self):
-    self.btest(test_file('pthread', 'test_pthread_malloc.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest(test_file('pthread/test_pthread_malloc.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Stress test pthreads allocating memory that will call to sbrk(), and main thread has to free up the data.
   @requires_threads
   def test_pthread_malloc_free(self):
-    self.btest(test_file('pthread', 'test_pthread_malloc_free.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8', '-s', 'INITIAL_MEMORY=256MB'])
+    self.btest(test_file('pthread/test_pthread_malloc_free.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8', '-s', 'INITIAL_MEMORY=256MB'])
 
   # Test that the pthread_barrier API works ok.
   @requires_threads
   def test_pthread_barrier(self):
-    self.btest(test_file('pthread', 'test_pthread_barrier.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest(test_file('pthread/test_pthread_barrier.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Test the pthread_once() function.
   @requires_threads
   def test_pthread_once(self):
-    self.btest(test_file('pthread', 'test_pthread_once.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest(test_file('pthread/test_pthread_once.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Test against a certain thread exit time handling bug by spawning tons of threads.
   @no_firefox('https://bugzilla.mozilla.org/show_bug.cgi?id=1666568')
   @requires_threads
   def test_pthread_spawns(self):
-    self.btest(test_file('pthread', 'test_pthread_spawns.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8', '--closure=1', '-s', 'ENVIRONMENT=web,worker'])
+    self.btest(test_file('pthread/test_pthread_spawns.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8', '--closure=1', '-s', 'ENVIRONMENT=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.
   @requires_threads
   def test_pthread_volatile(self):
     for arg in [[], ['-DUSE_C_VOLATILE']]:
-      self.btest(test_file('pthread', 'test_pthread_volatile.cpp'), expected='1', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'] + arg)
+      self.btest(test_file('pthread/test_pthread_volatile.cpp'), expected='1', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'] + arg)
 
   # Test thread-specific data (TLS).
   @requires_threads
   def test_pthread_thread_local_storage(self):
-    self.btest(test_file('pthread', 'test_pthread_thread_local_storage.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8', '-s', 'ASSERTIONS'])
+    self.btest(test_file('pthread/test_pthread_thread_local_storage.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8', '-s', 'ASSERTIONS'])
 
   # Test the pthread condition variable creation and waiting.
   @requires_threads
   def test_pthread_condition_variable(self):
-    self.btest(test_file('pthread', 'test_pthread_condition_variable.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.btest(test_file('pthread/test_pthread_condition_variable.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
 
   # Test that pthreads are able to do printf.
   @requires_threads
   def test_pthread_printf(self):
     def run(debug):
-       self.btest(test_file('pthread', 'test_pthread_printf.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE', '-s', 'LIBRARY_DEBUG=%d' % debug])
+       self.btest(test_file('pthread/test_pthread_printf.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE', '-s', 'LIBRARY_DEBUG=%d' % debug])
 
     run(debug=True)
     run(debug=False)
@@ -3891,31 +3890,31 @@ def run(debug):
   # Test that pthreads are able to do cout. Failed due to https://bugzilla.mozilla.org/show_bug.cgi?id=1154858.
   @requires_threads
   def test_pthread_iostream(self):
-    self.btest(test_file('pthread', 'test_pthread_iostream.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
+    self.btest(test_file('pthread/test_pthread_iostream.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
 
   @requires_threads
   def test_pthread_unistd_io_bigint(self):
-    self.btest_exit(test_file('unistd', 'io.c'), args=['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'WASM_BIGINT'])
+    self.btest_exit(test_file('unistd/io.c'), args=['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'WASM_BIGINT'])
 
   # Test that the main thread is able to use pthread_set/getspecific.
   @requires_threads
   def test_pthread_setspecific_mainthread(self):
-    self.btest(test_file('pthread', 'test_pthread_setspecific_mainthread.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS'], also_asmjs=True)
+    self.btest(test_file('pthread/test_pthread_setspecific_mainthread.cpp'), expected='0', args=['-s', 'INITIAL_MEMORY=64MB', '-O3', '-s', 'USE_PTHREADS'], also_asmjs=True)
 
   # Test that pthreads have access to filesystem.
   @requires_threads
   def test_pthread_file_io(self):
-    self.btest(test_file('pthread', 'test_pthread_file_io.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
+    self.btest(test_file('pthread/test_pthread_file_io.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
 
   # Test that the pthread_create() function operates benignly in the case that threading is not supported.
   @requires_threads
   def test_pthread_supported(self):
     for args in [[], ['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8']]:
-      self.btest(test_file('pthread', 'test_pthread_supported.cpp'), expected='0', args=['-O3'] + args)
+      self.btest(test_file('pthread/test_pthread_supported.cpp'), expected='0', args=['-O3'] + args)
 
   @requires_threads
   def test_pthread_dispatch_after_exit(self):
-    self.btest_exit(test_file('pthread', 'test_pthread_dispatch_after_exit.c'), args=['-s', 'USE_PTHREADS'])
+    self.btest_exit(test_file('pthread/test_pthread_dispatch_after_exit.c'), args=['-s', 'USE_PTHREADS'])
 
   # Test the operation of Module.pthreadMainPrefixURL variable
   @no_wasm_backend('uses js')
@@ -3949,8 +3948,8 @@ def test_pthread_custom_pthread_main_url(self):
     # Test that it is possible to define "Module.locateFile" string to locate where worker.js will be loaded from.
     create_file('shell.html', open(path_from_root('src', 'shell.html')).read().replace('var Module = {', 'var Module = { locateFile: function (path, prefix) {if (path.endsWith(".wasm")) {return prefix + path;} else {return "cdn/" + path;}}, '))
     self.compile_btest(['main.cpp', '--shell-file', 'shell.html', '-s', 'WASM=0', '-s', 'IN_TEST_HARNESS', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE', '-o', 'test.html'])
-    shutil.move('test.worker.js', os.path.join('cdn', 'test.worker.js'))
-    shutil.copyfile('test.html.mem', os.path.join('cdn', 'test.html.mem'))
+    shutil.move('test.worker.js', Path('cdn/test.worker.js'))
+    shutil.copyfile('test.html.mem', Path('cdn/test.html.mem'))
     self.run_browser('test.html', '', '/report_result?1')
 
     # Test that it is possible to define "Module.locateFile(foo)" function to locate where worker.js will be loaded from.
@@ -3962,7 +3961,7 @@ def test_pthread_custom_pthread_main_url(self):
   # Test that if the main thread is performing a futex wait while a pthread needs it to do a proxied operation (before that pthread would wake up the main thread), that it's not a deadlock.
   @requires_threads
   def test_pthread_proxying_in_futex_wait(self):
-    self.btest(test_file('pthread', 'test_pthread_proxying_in_futex_wait.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
+    self.btest(test_file('pthread/test_pthread_proxying_in_futex_wait.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
 
   # Test that sbrk() operates properly in multithreaded conditions
   @requires_threads
@@ -3971,7 +3970,7 @@ def test_pthread_sbrk(self):
       print('aborting malloc=' + str(aborting_malloc))
       # 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(test_file('pthread', 'test_pthread_sbrk.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8', '-s', 'ABORTING_MALLOC=' + str(aborting_malloc), '-DABORTING_MALLOC=' + str(aborting_malloc), '-s', 'INITIAL_MEMORY=128MB'])
+      self.btest(test_file('pthread/test_pthread_sbrk.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8', '-s', 'ABORTING_MALLOC=' + str(aborting_malloc), '-DABORTING_MALLOC=' + str(aborting_malloc), '-s', 'INITIAL_MEMORY=128MB'])
 
   # Test that -s ABORTING_MALLOC=0 works in both pthreads and non-pthreads builds. (sbrk fails gracefully)
   @requires_threads
@@ -3983,31 +3982,31 @@ def test_pthread_gauge_available_memory(self):
   # Test that the proxying operations of user code from pthreads to main thread work
   @requires_threads
   def test_pthread_run_on_main_thread(self):
-    self.btest(test_file('pthread', 'test_pthread_run_on_main_thread.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
+    self.btest(test_file('pthread/test_pthread_run_on_main_thread.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
 
   # Test how a lot of back-to-back called proxying operations behave.
   @requires_threads
   def test_pthread_run_on_main_thread_flood(self):
-    self.btest(test_file('pthread', 'test_pthread_run_on_main_thread_flood.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
+    self.btest(test_file('pthread/test_pthread_run_on_main_thread_flood.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
 
   # Test that it is possible to asynchronously call a JavaScript function on the main thread.
   @requires_threads
   def test_pthread_call_async(self):
-    self.btest(test_file('pthread', 'call_async.c'), expected='1', args=['-s', 'USE_PTHREADS'])
+    self.btest(test_file('pthread/call_async.c'), expected='1', args=['-s', 'USE_PTHREADS'])
 
   # Test that it is possible to synchronously call a JavaScript function on the main thread and get a return value back.
   @requires_threads
   def test_pthread_call_sync_on_main_thread(self):
-    self.btest(test_file('pthread', 'call_sync_on_main_thread.c'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-DPROXY_TO_PTHREAD=1', '--js-library', test_file('pthread', 'call_sync_on_main_thread.js')])
-    self.btest(test_file('pthread', 'call_sync_on_main_thread.c'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread', 'call_sync_on_main_thread.js')])
-    self.btest(test_file('pthread', 'call_sync_on_main_thread.c'), expected='1', args=['-Oz', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread', 'call_sync_on_main_thread.js'), '-s', 'EXPORTED_FUNCTIONS=_main,_malloc'])
+    self.btest(test_file('pthread/call_sync_on_main_thread.c'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-DPROXY_TO_PTHREAD=1', '--js-library', test_file('pthread/call_sync_on_main_thread.js')])
+    self.btest(test_file('pthread/call_sync_on_main_thread.c'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread/call_sync_on_main_thread.js')])
+    self.btest(test_file('pthread/call_sync_on_main_thread.c'), expected='1', args=['-Oz', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread/call_sync_on_main_thread.js'), '-s', 'EXPORTED_FUNCTIONS=_main,_malloc'])
 
   # Test that it is possible to asynchronously call a JavaScript function on the main thread.
   @requires_threads
   def test_pthread_call_async_on_main_thread(self):
-    self.btest(test_file('pthread', 'call_async_on_main_thread.c'), expected='7', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-DPROXY_TO_PTHREAD=1', '--js-library', test_file('pthread', 'call_async_on_main_thread.js')])
-    self.btest(test_file('pthread', 'call_async_on_main_thread.c'), expected='7', args=['-O3', '-s', 'USE_PTHREADS', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread', 'call_async_on_main_thread.js')])
-    self.btest(test_file('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(test_file('pthread/call_async_on_main_thread.c'), expected='7', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-DPROXY_TO_PTHREAD=1', '--js-library', test_file('pthread/call_async_on_main_thread.js')])
+    self.btest(test_file('pthread/call_async_on_main_thread.c'), expected='7', args=['-O3', '-s', 'USE_PTHREADS', '-DPROXY_TO_PTHREAD=0', '--js-library', test_file('pthread/call_async_on_main_thread.js')])
+    self.btest(test_file('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.
   @requires_threads
@@ -4015,7 +4014,7 @@ def test_pthread_global_data_initialization(self):
     mem_init_modes = [[], ['--memory-init-file', '0'], ['--memory-init-file', '1']]
     for mem_init_mode in mem_init_modes:
       for args in [['-s', 'MODULARIZE', '-s', 'EXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')], ['-O3']]:
-        self.btest(test_file('pthread', 'test_pthread_global_data_initialization.c'), expected='20', args=args + mem_init_mode + ['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'PTHREAD_POOL_SIZE'])
+        self.btest(test_file('pthread/test_pthread_global_data_initialization.c'), expected='20', args=args + mem_init_mode + ['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'PTHREAD_POOL_SIZE'])
 
   @requires_threads
   @requires_sync_compilation
@@ -4023,43 +4022,43 @@ def test_pthread_global_data_initialization_in_sync_compilation_mode(self):
     mem_init_modes = [[], ['--memory-init-file', '0'], ['--memory-init-file', '1']]
     for mem_init_mode in mem_init_modes:
       args = ['-s', 'WASM_ASYNC_COMPILATION=0']
-      self.btest(test_file('pthread', 'test_pthread_global_data_initialization.c'), expected='20', args=args + mem_init_mode + ['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'PTHREAD_POOL_SIZE'])
+      self.btest(test_file('pthread/test_pthread_global_data_initialization.c'), expected='20', args=args + mem_init_mode + ['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'PTHREAD_POOL_SIZE'])
 
   # Test that emscripten_get_now() reports coherent wallclock times across all pthreads, instead of each pthread independently reporting wallclock times since the launch of that pthread.
   @requires_threads
   def test_pthread_clock_drift(self):
-    self.btest(test_file('pthread', 'test_pthread_clock_drift.cpp'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD'])
+    self.btest(test_file('pthread/test_pthread_clock_drift.cpp'), expected='1', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD'])
 
   @requires_threads
   def test_pthread_utf8_funcs(self):
-    self.btest(test_file('pthread', 'test_pthread_utf8_funcs.cpp'), expected='0', args=['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
+    self.btest(test_file('pthread/test_pthread_utf8_funcs.cpp'), expected='0', args=['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
 
   # Test the emscripten_futex_wake(addr, INT_MAX); functionality to wake all waiters
   @requires_threads
   def test_pthread_wake_all(self):
-    self.btest(test_file('pthread', 'test_futex_wake_all.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'INITIAL_MEMORY=64MB', '-s', 'NO_EXIT_RUNTIME'], also_asmjs=True)
+    self.btest(test_file('pthread/test_futex_wake_all.cpp'), expected='0', args=['-O3', '-s', 'USE_PTHREADS', '-s', 'INITIAL_MEMORY=64MB', '-s', 'NO_EXIT_RUNTIME'], also_asmjs=True)
 
   # Test that stack base and max correctly bound the stack on pthreads.
   @requires_threads
   def test_pthread_stack_bounds(self):
-    self.btest(test_file('pthread', 'test_pthread_stack_bounds.cpp'), expected='1', args=['-s', 'USE_PTHREADS'])
+    self.btest(test_file('pthread/test_pthread_stack_bounds.cpp'), expected='1', args=['-s', 'USE_PTHREADS'])
 
   # Test that real `thread_local` works.
   @requires_threads
   def test_pthread_tls(self):
-    self.btest(test_file('pthread', 'test_pthread_tls.cpp'), expected='1337', args=['-s', 'PROXY_TO_PTHREAD', '-s', 'USE_PTHREADS'])
+    self.btest(test_file('pthread/test_pthread_tls.cpp'), expected='1337', args=['-s', 'PROXY_TO_PTHREAD', '-s', 'USE_PTHREADS'])
 
   # Test that real `thread_local` works in main thread without PROXY_TO_PTHREAD.
   @requires_threads
   def test_pthread_tls_main(self):
-    self.btest(test_file('pthread', 'test_pthread_tls_main.cpp'), expected='1337', args=['-s', 'USE_PTHREADS'])
+    self.btest(test_file('pthread/test_pthread_tls_main.cpp'), expected='1337', args=['-s', 'USE_PTHREADS'])
 
   @requires_threads
   def test_pthread_safe_stack(self):
     # Note that as the test runs with PROXY_TO_PTHREAD, we set TOTAL_STACK,
     # and not DEFAULT_PTHREAD_STACK_SIZE, as the pthread for main() gets the
     # same stack size as the main thread normally would.
-    self.btest(test_file('core', 'test_safe_stack.c'), expected='abort:stack overflow', args=['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'STACK_OVERFLOW_CHECK=2', '-s', 'TOTAL_STACK=64KB'])
+    self.btest(test_file('core/test_safe_stack.c'), expected='abort:stack overflow', args=['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'STACK_OVERFLOW_CHECK=2', '-s', 'TOTAL_STACK=64KB'])
 
   @parameterized({
     'leak': ['test_pthread_lsan_leak', ['-gsource-map']],
@@ -4080,7 +4079,7 @@ def test_pthread_asan(self, name, args=[]):
 
   @requires_threads
   def test_pthread_asan_use_after_free(self):
-    self.btest(test_file('pthread', 'test_pthread_asan_use_after_free.cpp'), expected='1', args=['-fsanitize=address', '-s', 'INITIAL_MEMORY=256MB', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '--pre-js', test_file('pthread', 'test_pthread_asan_use_after_free.js')])
+    self.btest(test_file('pthread/test_pthread_asan_use_after_free.cpp'), expected='1', args=['-fsanitize=address', '-s', 'INITIAL_MEMORY=256MB', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '--pre-js', test_file('pthread/test_pthread_asan_use_after_free.js')])
 
   @requires_threads
   def test_pthread_exit_process(self):
@@ -4090,8 +4089,8 @@ def test_pthread_exit_process(self):
             '-s', 'EXIT_RUNTIME',
             '-DEXIT_RUNTIME',
             '-O0']
-    args += ['--pre-js', test_file('core', 'pthread', 'test_pthread_exit_runtime.pre.js')]
-    self.btest(test_file('core', 'pthread', 'test_pthread_exit_runtime.c'), expected='onExit status: 42', args=args)
+    args += ['--pre-js', test_file('core/pthread/test_pthread_exit_runtime.pre.js')]
+    self.btest(test_file('core/pthread/test_pthread_exit_runtime.c'), expected='onExit status: 42', args=args)
 
   @requires_threads
   def test_pthread_no_exit_process(self):
@@ -4101,26 +4100,26 @@ def test_pthread_no_exit_process(self):
             '-s', 'PROXY_TO_PTHREAD',
             '-s', 'PTHREAD_POOL_SIZE=2',
             '-O0']
-    args += ['--pre-js', test_file('core', 'pthread', 'test_pthread_exit_runtime.pre.js')]
-    self.btest(test_file('core', 'pthread', 'test_pthread_exit_runtime.c'), expected='43', args=args)
+    args += ['--pre-js', test_file('core/pthread/test_pthread_exit_runtime.pre.js')]
+    self.btest(test_file('core/pthread/test_pthread_exit_runtime.c'), expected='43', args=args)
 
   # Tests MAIN_THREAD_EM_ASM_INT() function call signatures.
   def test_main_thread_em_asm_signatures(self):
-    self.btest_exit(test_file('core', 'test_em_asm_signatures.cpp'), assert_returncode=121, args=[])
+    self.btest_exit(test_file('core/test_em_asm_signatures.cpp'), assert_returncode=121, args=[])
 
   @requires_threads
   def test_main_thread_em_asm_signatures_pthreads(self):
-    self.btest_exit(test_file('core', 'test_em_asm_signatures.cpp'), assert_returncode=121, args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'ASSERTIONS'])
+    self.btest_exit(test_file('core/test_em_asm_signatures.cpp'), assert_returncode=121, args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'ASSERTIONS'])
 
   @requires_threads
   def test_main_thread_async_em_asm(self):
-    self.btest_exit(test_file('core', 'test_main_thread_async_em_asm.cpp'), args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'ASSERTIONS'])
+    self.btest_exit(test_file('core/test_main_thread_async_em_asm.cpp'), args=['-O3', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'ASSERTIONS'])
 
   @requires_threads
   def test_main_thread_em_asm_blocking(self):
-    create_file('page.html', open(test_file('browser', 'test_em_asm_blocking.html')).read())
+    create_file('page.html', open(test_file('browser/test_em_asm_blocking.html')).read())
 
-    self.compile_btest([test_file('browser', 'test_em_asm_blocking.cpp'), '-O2', '-o', 'wasm.js', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD'])
+    self.compile_btest([test_file('browser/test_em_asm_blocking.cpp'), '-O2', '-o', 'wasm.js', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD'])
     self.run_browser('page.html', '', '/report_result?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);
@@ -4216,7 +4215,7 @@ def test_wasm_locate_file(self):
     ensure_dir('cdn')
     create_file('shell2.html', open(path_from_root('src', 'shell.html')).read().replace('var Module = {', 'var Module = { locateFile: function(filename) { if (filename == "test.wasm") return "cdn/test.wasm"; else return filename; }, '))
     self.compile_btest([test_file('browser_test_hello_world.c'), '--shell-file', 'shell2.html', '-o', 'test.html'])
-    shutil.move('test.wasm', os.path.join('cdn', 'test.wasm'))
+    shutil.move('test.wasm', Path('cdn/test.wasm'))
     self.run_browser('test.html', '', '/report_result?0')
 
   def test_utf8_textdecoder(self):
@@ -4526,13 +4525,13 @@ def test_fetch_idb_delete(self):
   def test_asmfs_hello_file(self):
     # Test basic file loading and the valid character set for files.
     ensure_dir('dirrey')
-    shutil.copyfile(test_file('asmfs', 'hello_file.txt'), os.path.join(self.get_dir(), 'dirrey', 'hello file !#$%&\'()+,-.;=@[]^_`{}~ %%.txt'))
+    shutil.copyfile(test_file('asmfs/hello_file.txt'), Path('dirrey', 'hello file !#$%&\'()+,-.;=@[]^_`{}~ %%.txt'))
     self.btest_exit('asmfs/hello_file.cpp', args=['-s', 'ASMFS', '-s', 'WASM=0', '-s', 'USE_PTHREADS', '-s', 'FETCH_DEBUG', '-s', 'PROXY_TO_PTHREAD'])
 
   @requires_asmfs
   @requires_threads
   def test_asmfs_read_file_twice(self):
-    shutil.copyfile(test_file('asmfs', 'hello_file.txt'), 'hello_file.txt')
+    shutil.copyfile(test_file('asmfs/hello_file.txt'), 'hello_file.txt')
     self.btest_exit('asmfs/read_file_twice.cpp', args=['-s', 'ASMFS', '-s', 'WASM=0', '-s', 'USE_PTHREADS', '-s', 'FETCH_DEBUG', '-s', 'PROXY_TO_PTHREAD'])
 
   @requires_asmfs
@@ -4558,18 +4557,18 @@ def test_asmfs_dirent_test_readdir_empty(self):
   @requires_asmfs
   @requires_threads
   def test_asmfs_unistd_close(self):
-    self.btest_exit(test_file('unistd', 'close.c'), 0, args=['-s', 'ASMFS', '-s', 'WASM=0', '-s', 'USE_PTHREADS', '-s', 'FETCH_DEBUG'])
+    self.btest_exit(test_file('unistd/close.c'), 0, args=['-s', 'ASMFS', '-s', 'WASM=0', '-s', 'USE_PTHREADS', '-s', 'FETCH_DEBUG'])
 
   @requires_asmfs
   @requires_threads
   def test_asmfs_unistd_access(self):
-    self.btest_exit(test_file('unistd', 'access.c'), 0, args=['-s', 'ASMFS', '-s', 'WASM=0', '-s', 'USE_PTHREADS', '-s', 'FETCH_DEBUG'])
+    self.btest_exit(test_file('unistd/access.c'), 0, args=['-s', 'ASMFS', '-s', 'WASM=0', '-s', 'USE_PTHREADS', '-s', 'FETCH_DEBUG'])
 
   @requires_asmfs
   @requires_threads
   def test_asmfs_unistd_unlink(self):
     # TODO: Once symlinks are supported, remove -DNO_SYMLINK=1
-    self.btest_exit(test_file('unistd', 'unlink.c'), 0, args=['-s', 'ASMFS', '-s', 'WASM=0', '-s', 'USE_PTHREADS', '-s', 'FETCH_DEBUG', '-DNO_SYMLINK=1'])
+    self.btest_exit(test_file('unistd/unlink.c'), 0, args=['-s', 'ASMFS', '-s', 'WASM=0', '-s', 'USE_PTHREADS', '-s', 'FETCH_DEBUG', '-DNO_SYMLINK=1'])
 
   @requires_asmfs
   @requires_threads
@@ -4604,7 +4603,7 @@ def test_emscripten_get_device_pixel_ratio(self):
   @requires_threads
   def test_pthread_run_script(self):
     for args in [[], ['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD']]:
-      self.btest(test_file('pthread', 'test_pthread_run_script.cpp'), expected='1', args=['-O3'] + args)
+      self.btest(test_file('pthread/test_pthread_run_script.cpp'), expected='1', args=['-O3'] + args)
 
   # Tests emscripten_set_canvas_element_size() and OffscreenCanvas functionality in different build configurations.
   @requires_threads
@@ -4627,13 +4626,13 @@ def test_emscripten_animate_canvas_element_size(self):
   def test_pthread_hello_thread(self):
     for opts in [[], ['-O3']]:
       for modularize in [[], ['-s', 'MODULARIZE', '-s', 'EXPORT_NAME=MyModule', '--shell-file', test_file('shell_that_launches_modularize.html')]]:
-        self.btest(test_file('pthread', 'hello_thread.c'), expected='1', args=['-s', 'USE_PTHREADS'] + modularize + opts)
+        self.btest(test_file('pthread/hello_thread.c'), expected='1', args=['-s', 'USE_PTHREADS'] + modularize + opts)
 
   # Tests that a pthreads build of -s MINIMAL_RUNTIME=1 works well in different build modes
   def test_minimal_runtime_hello_pthread(self):
     for opts in [[], ['-O3']]:
       for modularize in [[], ['-s', 'MODULARIZE', '-s', 'EXPORT_NAME=MyModule']]:
-        self.btest(test_file('pthread', 'hello_thread.c'), expected='1', args=['-s', 'MINIMAL_RUNTIME', '-s', 'USE_PTHREADS'] + modularize + opts)
+        self.btest(test_file('pthread/hello_thread.c'), expected='1', args=['-s', 'MINIMAL_RUNTIME', '-s', 'USE_PTHREADS'] + modularize + opts)
 
   # Tests memory growth in pthreads mode, but still on the main thread.
   @requires_threads
@@ -4641,7 +4640,7 @@ def test_pthread_growth_mainthread(self):
     self.emcc_args.remove('-Werror')
 
     def run(emcc_args=[]):
-      self.btest(test_file('pthread', 'test_pthread_memory_growth_mainthread.c'), expected='1', args=['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'ALLOW_MEMORY_GROWTH', '-s', 'INITIAL_MEMORY=32MB', '-s', 'MAXIMUM_MEMORY=256MB'] + emcc_args, also_asmjs=False)
+      self.btest(test_file('pthread/test_pthread_memory_growth_mainthread.c'), expected='1', args=['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'ALLOW_MEMORY_GROWTH', '-s', 'INITIAL_MEMORY=32MB', '-s', 'MAXIMUM_MEMORY=256MB'] + emcc_args, also_asmjs=False)
 
     run()
     run(['-s', 'PROXY_TO_PTHREAD'])
@@ -4652,7 +4651,7 @@ def test_pthread_growth(self):
     self.emcc_args.remove('-Werror')
 
     def run(emcc_args=[]):
-      self.btest(test_file('pthread', 'test_pthread_memory_growth.c'), expected='1', args=['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'ALLOW_MEMORY_GROWTH', '-s', 'INITIAL_MEMORY=32MB', '-s', 'MAXIMUM_MEMORY=256MB', '-g'] + emcc_args, also_asmjs=False)
+      self.btest(test_file('pthread/test_pthread_memory_growth.c'), expected='1', args=['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'ALLOW_MEMORY_GROWTH', '-s', 'INITIAL_MEMORY=32MB', '-s', 'MAXIMUM_MEMORY=256MB', '-g'] + emcc_args, also_asmjs=False)
 
     run()
     run(['-s', 'ASSERTIONS'])
@@ -4663,14 +4662,14 @@ def run(emcc_args=[]):
   # clock.
   @requires_threads
   def test_pthread_reltime(self):
-    self.btest(test_file('pthread', 'test_pthread_reltime.cpp'), expected='3', args=['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
+    self.btest(test_file('pthread/test_pthread_reltime.cpp'), expected='3', args=['-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE'])
 
   # Tests that it is possible to load the main .js file of the application manually via a Blob URL, and still use pthreads.
   @requires_threads
   def test_load_js_from_blob_with_pthreads(self):
     # TODO: enable this with wasm, currently pthreads/atomics have limitations
-    self.compile_btest([test_file('pthread', 'hello_thread.c'), '-s', 'USE_PTHREADS', '-o', 'hello_thread_with_blob_url.js'])
-    shutil.copyfile(test_file('pthread', 'main_js_as_blob_loader.html'), 'hello_thread_with_blob_url.html')
+    self.compile_btest([test_file('pthread/hello_thread.c'), '-s', 'USE_PTHREADS', '-o', 'hello_thread_with_blob_url.js'])
+    shutil.copyfile(test_file('pthread/main_js_as_blob_loader.html'), 'hello_thread_with_blob_url.html')
     self.run_browser('hello_thread_with_blob_url.html', 'hello from thread!', '/report_result?1')
 
   # Tests that base64 utils work in browser with no native atob function
@@ -4765,7 +4764,7 @@ def test_single_file_worker_js(self):
   # are all inside Web Workers).
   @requires_threads
   def test_pthreads_started_in_worker(self):
-    self.compile_btest([test_file('pthread', 'test_pthread_atomics.cpp'), '-o', 'test.js', '-s', 'INITIAL_MEMORY=64MB', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
+    self.compile_btest([test_file('pthread/test_pthread_atomics.cpp'), '-o', 'test.js', '-s', 'INITIAL_MEMORY=64MB', '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=8'])
     create_file('test.html', '''
       <script>
         new Worker('test.js');
@@ -4797,15 +4796,15 @@ def test_unicode_html_shell(self):
   # Tests the functionality of the emscripten_thread_sleep() function.
   @requires_threads
   def test_emscripten_thread_sleep(self):
-    self.btest(test_file('pthread', 'emscripten_thread_sleep.c'), expected='1', args=['-s', 'USE_PTHREADS', '-s', 'EXPORTED_RUNTIME_METHODS=[print]'])
+    self.btest(test_file('pthread/emscripten_thread_sleep.c'), expected='1', args=['-s', 'USE_PTHREADS', '-s', 'EXPORTED_RUNTIME_METHODS=[print]'])
 
   # Tests that Emscripten-compiled applications can be run from a relative path in browser that is different than the address of the current page
   def test_browser_run_from_different_directory(self):
     self.compile_btest([test_file('browser_test_hello_world.c'), '-o', 'test.html', '-O3'])
 
     ensure_dir('subdir')
-    shutil.move('test.js', os.path.join('subdir', 'test.js'))
-    shutil.move('test.wasm', os.path.join('subdir', 'test.wasm'))
+    shutil.move('test.js', Path('subdir/test.js'))
+    shutil.move('test.wasm', Path('subdir/test.wasm'))
     src = open('test.html').read()
     # Make sure JS is loaded from subdirectory
     create_file('test-subdir.html', src.replace('test.js', 'subdir/test.js'))
@@ -4823,8 +4822,8 @@ def test_browser_run_from_different_directory_async(self):
       # compile the code with the modularize feature and the preload-file option enabled
       self.compile_btest([test_file('browser_test_hello_world.c'), '-o', 'test.js', '-O3'] + args)
       ensure_dir('subdir')
-      shutil.move('test.js', os.path.join('subdir', 'test.js'))
-      shutil.move('test.wasm', os.path.join('subdir', 'test.wasm'))
+      shutil.move('test.js', Path('subdir/test.js'))
+      shutil.move('test.wasm', Path('subdir/test.wasm'))
       for creation in creations:
         print(creation)
         # Make sure JS is loaded from subdirectory
@@ -4852,9 +4851,9 @@ def test_browser_modularize_no_current_script(self):
       ensure_dir(filesystem_path)
       # compile the code with the modularize feature and the preload-file option enabled
       self.compile_btest([test_file('browser_test_hello_world.c'), '-o', 'test.js'] + args)
-      shutil.move('test.js', os.path.join(filesystem_path, 'test.js'))
-      shutil.move('test.wasm', os.path.join(filesystem_path, 'test.wasm'))
-      open(os.path.join(filesystem_path, 'test.html'), 'w').write('''
+      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'), '''
         <script>
           setTimeout(function() {
             var xhr = new XMLHttpRequest();
@@ -4947,11 +4946,11 @@ def test_minimal_runtime_hello_world(self):
 
   @requires_threads
   def test_offset_converter(self, *args):
-    self.btest_exit(test_file('browser', 'test_offset_converter.c'), assert_returncode=1, args=['-s', 'USE_OFFSET_CONVERTER', '-gsource-map', '-s', 'PROXY_TO_PTHREAD', '-s', 'USE_PTHREADS'])
+    self.btest_exit(test_file('browser/test_offset_converter.c'), assert_returncode=1, args=['-s', 'USE_OFFSET_CONVERTER', '-gsource-map', '-s', 'PROXY_TO_PTHREAD', '-s', 'USE_PTHREADS'])
 
   # Tests emscripten_unwind_to_js_event_loop() behavior
   def test_emscripten_unwind_to_js_event_loop(self, *args):
-    self.btest(test_file('browser', 'test_emscripten_unwind_to_js_event_loop.c'), '1', args=['-s', 'NO_EXIT_RUNTIME'])
+    self.btest(test_file('browser/test_emscripten_unwind_to_js_event_loop.c'), '1', args=['-s', 'NO_EXIT_RUNTIME'])
 
   def test_wasm2js_fallback(self):
     for args in [[], ['-s', 'MINIMAL_RUNTIME']]:
@@ -5038,7 +5037,7 @@ def test(args):
 
   @no_firefox('no 4GB support yet')
   def test_zzz_zzz_emmalloc_memgrowth(self, *args):
-    self.btest(test_file('browser', 'emmalloc_memgrowth.cpp'), expected='0', args=['-s', 'MALLOC=emmalloc', '-s', 'ALLOW_MEMORY_GROWTH=1', '-s', 'ABORTING_MALLOC=0', '-s', 'ASSERTIONS=2', '-s', 'MINIMAL_RUNTIME=1', '-s', 'MAXIMUM_MEMORY=4GB'])
+    self.btest(test_file('browser/emmalloc_memgrowth.cpp'), expected='0', args=['-s', 'MALLOC=emmalloc', '-s', 'ALLOW_MEMORY_GROWTH=1', '-s', 'ABORTING_MALLOC=0', '-s', 'ASSERTIONS=2', '-s', 'MINIMAL_RUNTIME=1', '-s', 'MAXIMUM_MEMORY=4GB'])
 
   @no_firefox('no 4GB support yet')
   def test_zzz_zzz_2gb_fail(self):
@@ -5076,7 +5075,7 @@ 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(test_file('pthread', 'test_pthread_proxy_hammer.cpp'),
+    self.btest(test_file('pthread/test_pthread_proxy_hammer.cpp'),
                expected='0',
                args=['-s', 'USE_PTHREADS', '-O2', '-s', 'PROXY_TO_PTHREAD',
                      '-DITERATIONS=1024', '-g1'] + args,
@@ -5086,7 +5085,7 @@ def test_manual_pthread_proxy_hammer(self, args):
                extra_tries=0)
 
   def test_assert_failure(self):
-    self.btest(test_file('browser', 'test_assert_failure.c'), 'abort:Assertion failed: false && "this is a test"')
+    self.btest(test_file('browser/test_assert_failure.c'), 'abort:Assertion failed: false && "this is a test"')
 
   def test_full_js_library_strict(self):
     self.btest_exit(test_file('hello_world.c'), args=['-sINCLUDE_FULL_LIBRARY', '-sSTRICT_JS'])
diff --git a/tests/test_core.py b/tests/test_core.py
index 81e1e817a2f8b..8dfc6db7d04aa 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -14,6 +14,7 @@
 import sys
 import time
 import unittest
+from pathlib import Path
 from functools import wraps
 
 if __name__ == '__main__':
@@ -289,7 +290,7 @@ def verify_in_strict_mode(self, filename):
     self.run_js(filename)
 
   def do_core_test(self, testname, **kwargs):
-    self.do_run_in_out_file_test('core', testname, **kwargs)
+    self.do_run_in_out_file_test(Path('core', testname), **kwargs)
 
   def get_bullet_library(self, use_cmake):
     if use_cmake:
@@ -297,9 +298,9 @@ def get_bullet_library(self, use_cmake):
       configure_args = ['-DBUILD_DEMOS=OFF', '-DBUILD_EXTRAS=OFF', '-DUSE_GLUT=OFF']
       # Depending on whether 'configure' or 'cmake' is used to build, Bullet
       # places output files in different directory structures.
-      generated_libs = [os.path.join('src', 'BulletDynamics', 'libBulletDynamics.a'),
-                        os.path.join('src', 'BulletCollision', 'libBulletCollision.a'),
-                        os.path.join('src', 'LinearMath', 'libLinearMath.a')]
+      generated_libs = [Path('src/BulletDynamics/libBulletDynamics.a'),
+                        Path('src/BulletCollision/libBulletCollision.a'),
+                        Path('src/LinearMath/libLinearMath.a')]
     else:
       configure_commands = ['sh', './configure']
       # Force a nondefault --host= so that the configure script will interpret
@@ -308,11 +309,11 @@ def get_bullet_library(self, use_cmake):
       # which would fail since we are building a .js file.
       configure_args = ['--disable-shared', '--host=i686-pc-linux-gnu',
                         '--disable-demos', '--disable-dependency-tracking']
-      generated_libs = [os.path.join('src', '.libs', 'libBulletDynamics.a'),
-                        os.path.join('src', '.libs', 'libBulletCollision.a'),
-                        os.path.join('src', '.libs', 'libLinearMath.a')]
+      generated_libs = [Path('src/.libs/libBulletDynamics.a'),
+                        Path('src/.libs/libBulletCollision.a'),
+                        Path('src/.libs/libLinearMath.a')]
 
-    return self.get_library(os.path.join('third_party', 'bullet'), generated_libs,
+    return self.get_library('third_party/bullet', generated_libs,
                             configure=configure_commands,
                             configure_args=configure_args,
                             cache_name_extra=configure_commands[0])
@@ -406,7 +407,7 @@ def test_i64_invoke_bigint(self):
     self.do_core_test('test_i64_invoke_bigint.cpp', js_engines=[config.NODE_JS])
 
   def test_vararg_copy(self):
-    self.do_run_in_out_file_test('va_arg', 'test_va_copy.c')
+    self.do_run_in_out_file_test('va_arg/test_va_copy.c')
 
   def test_llvm_fabs(self):
     self.do_core_test('test_llvm_fabs.c')
@@ -467,8 +468,8 @@ def test_cube2md5(self):
   def test_cube2hash(self):
     # A good test of i64 math
     self.do_run('// empty file', 'Usage: hashstring <seed>',
-                libraries=self.get_library(os.path.join('third_party', 'cube2hash'), ['libcube2hash.a'], configure=None),
-                includes=[test_file('third_party', 'cube2hash')], assert_returncode=NON_ZERO)
+                libraries=self.get_library('third_party/cube2hash', ['libcube2hash.a'], configure=None),
+                includes=[test_file('third_party/cube2hash')], assert_returncode=NON_ZERO)
 
     for text, output in [('fleefl', '892BDB6FD3F62E863D63DA55851700FDE3ACF30204798CE9'),
                          ('fleefl2', 'AA2CC5F96FC9D540CA24FDAF1F71E2942753DB83E8A81B61'),
@@ -715,10 +716,10 @@ def test_math_hyperbolic(self):
     self.do_core_test('test_math_hyperbolic.c')
 
   def test_math_lgamma(self):
-    self.do_run_in_out_file_test('math', 'lgamma.c', assert_returncode=NON_ZERO)
+    self.do_run_in_out_file_test('math/lgamma.c', assert_returncode=NON_ZERO)
 
   def test_math_fmodf(self):
-    self.do_run_in_out_file_test('math', 'fmodf.c')
+    self.do_run_in_out_file_test('math/fmodf.c')
 
   def test_frexp(self):
     self.do_core_test('test_frexp.c')
@@ -783,7 +784,7 @@ def test_stack(self):
     self.do_core_test('test_stack.c')
 
   def test_stack_align(self):
-    src = test_file('core', 'test_stack_align.cpp')
+    src = test_file('core/test_stack_align.cpp')
 
     def test():
       self.do_runf(src, ['''align 4: 0
@@ -869,8 +870,8 @@ def test_emmalloc(self, *args):
 
     self.do_run(open(path_from_root('system', 'lib', 'emmalloc.cpp')).read() +
                 open(path_from_root('system', 'lib', 'sbrk.c')).read() +
-                open(test_file('core', 'test_emmalloc.cpp')).read(),
-                open(test_file('core', 'test_emmalloc.out')).read())
+                open(test_file('core/test_emmalloc.cpp')).read(),
+                open(test_file('core/test_emmalloc.out')).read())
 
   @no_asan('ASan does not support custom memory allocators')
   @no_lsan('LSan does not support custom memory allocators')
@@ -1118,12 +1119,12 @@ def test_exceptions(self):
     self.maybe_closure()
     for support_longjmp in [0, 1]:
       self.set_setting('SUPPORT_LONGJMP', support_longjmp)
-      self.do_run_from_file(test_file('core', 'test_exceptions.cpp'), test_file('core', 'test_exceptions_caught.out'))
+      self.do_run_from_file(test_file('core/test_exceptions.cpp'), test_file('core/test_exceptions_caught.out'))
 
   def test_exceptions_off(self):
     for support_longjmp in [0, 1]:
       self.set_setting('DISABLE_EXCEPTION_CATCHING')
-      self.do_run_from_file(test_file('core', 'test_exceptions.cpp'), test_file('core', 'test_exceptions_uncaught.out'), assert_returncode=NON_ZERO)
+      self.do_run_from_file(test_file('core/test_exceptions.cpp'), test_file('core/test_exceptions_uncaught.out'), assert_returncode=NON_ZERO)
 
   @no_asan('TODO: ASan support in minimal runtime')
   def test_exceptions_minimal_runtime(self):
@@ -1135,7 +1136,7 @@ def test_exceptions_minimal_runtime(self):
       self.set_setting('SUPPORT_LONGJMP', support_longjmp)
 
       self.set_setting('DISABLE_EXCEPTION_CATCHING', 0)
-      self.do_run_from_file(test_file('core', 'test_exceptions.cpp'), test_file('core', 'test_exceptions_caught.out'))
+      self.do_run_from_file(test_file('core/test_exceptions.cpp'), test_file('core/test_exceptions_caught.out'))
 
       self.set_setting('DISABLE_EXCEPTION_CATCHING')
       # TODO: Node currently returns 0 for unhandled promise rejections.
@@ -1143,7 +1144,7 @@ def test_exceptions_minimal_runtime(self):
       expect_fail = False
       if not self.is_wasm():
         expect_fail = True
-      self.do_run_from_file(test_file('core', 'test_exceptions.cpp'), test_file('core', 'test_exceptions_uncaught.out'), assert_returncode=NON_ZERO if expect_fail else 0)
+      self.do_run_from_file(test_file('core/test_exceptions.cpp'), test_file('core/test_exceptions_uncaught.out'), assert_returncode=NON_ZERO if expect_fail else 0)
 
   @with_both_exception_handling
   def test_exceptions_custom(self):
@@ -1258,8 +1259,8 @@ def test_exceptions_allowed(self):
     shutil.copyfile('test_exceptions_allowed.js', 'orig.js')
 
     # check that an empty allow list works properly (as in, same as exceptions disabled)
-    src = test_file('core', 'test_exceptions_allowed.cpp')
-    empty_output = test_file('core', 'test_exceptions_allowed_empty.out')
+    src = test_file('core/test_exceptions_allowed.cpp')
+    empty_output = test_file('core/test_exceptions_allowed_empty.out')
 
     self.set_setting('EXCEPTION_CATCHING_ALLOWED', [])
     self.do_run_from_file(src, empty_output, assert_returncode=NON_ZERO)
@@ -1615,12 +1616,12 @@ def test_alloca(self):
     self.do_core_test('test_alloca.c')
 
   def test_rename(self):
-    self.do_run_in_out_file_test('stdio', 'test_rename.c')
+    self.do_run_in_out_file_test('stdio/test_rename.c')
 
   def test_remove(self):
    # needs to flush stdio streams
    self.set_setting('EXIT_RUNTIME')
-   self.do_run_in_out_file_test('cstdio', 'test_remove.cpp')
+   self.do_run_in_out_file_test('cstdio/test_remove.cpp')
 
   def test_alloca_stack(self):
     self.do_core_test('test_alloca_stack.c')
@@ -1821,7 +1822,7 @@ def test_emscripten_get_now(self):
     self.do_runf(test_file('emscripten_get_now.cpp'), 'Timer resolution is good')
 
   def test_emscripten_get_compiler_setting(self):
-    src = test_file('core', 'emscripten_get_compiler_setting.c')
+    src = test_file('core/emscripten_get_compiler_setting.c')
     output = shared.unsuffixed(src) + '.out'
     # with assertions, a nice message is shown
     self.set_setting('ASSERTIONS')
@@ -1867,7 +1868,7 @@ def test_inlinejs3(self):
     if self.is_wasm():
       self.skipTest('wasm requires a proper asm module')
 
-    src = test_file('core', 'test_inlinejs3.c')
+    src = test_file('core/test_inlinejs3.c')
     output = shared.unsuffixed(src) + '.out'
 
     self.do_core_test('test_inlinejs3.c')
@@ -1913,10 +1914,10 @@ def test_em_asm_2(self):
   # test cases are added to test_em_asm_2.cpp for EM_ASM, they will also get tested in MAIN_THREAD_EM_ASM form.
   @no_asan('Cannot use ASan: test depends exactly on heap size')
   def test_main_thread_em_asm(self):
-    src = open(test_file('core', 'test_em_asm_2.cpp')).read()
+    src = open(test_file('core/test_em_asm_2.cpp')).read()
     create_file('src.cpp', src.replace('EM_ASM', 'MAIN_THREAD_EM_ASM'))
 
-    expected_result = open(test_file('core', 'test_em_asm_2.out')).read()
+    expected_result = open(test_file('core/test_em_asm_2.out')).read()
     create_file('result.out', expected_result.replace('EM_ASM', 'MAIN_THREAD_EM_ASM'))
 
     self.do_run_from_file('src.cpp', 'result.out')
@@ -1972,14 +1973,14 @@ def test_em_js(self, args, force_c):
     self.assertContained("no args returning int", open('test_em_js.js').read())
 
   def test_runtime_stacksave(self):
-    self.do_runf(test_file('core', 'test_runtime_stacksave.c'), 'success')
+    self.do_runf(test_file('core/test_runtime_stacksave.c'), 'success')
 
   # Tests that -s MINIMAL_RUNTIME=1 builds can utilize -s ALLOW_MEMORY_GROWTH=1 option.
   def test_minimal_runtime_memorygrowth(self):
     if self.has_changed_setting('ALLOW_MEMORY_GROWTH'):
       self.skipTest('test needs to modify memory growth')
     self.set_setting('MINIMAL_RUNTIME')
-    src = test_file('core', 'test_memorygrowth.c')
+    src = test_file('core/test_memorygrowth.c')
     # Fail without memory growth
     expect_fail = False
     if not self.is_wasm():
@@ -1997,7 +1998,7 @@ def test_memorygrowth(self):
       self.set_setting('DYNAMIC_EXECUTION', 0)
     # With typed arrays in particular, it is dangerous to use more memory than INITIAL_MEMORY,
     # since we then need to enlarge the heap(s).
-    src = test_file('core', 'test_memorygrowth.c')
+    src = test_file('core/test_memorygrowth.c')
 
     # Fail without memory growth
     self.do_runf(src, 'OOM', assert_returncode=NON_ZERO)
@@ -2035,7 +2036,7 @@ def test_memorygrowth_2(self):
 
     # With typed arrays in particular, it is dangerous to use more memory than INITIAL_MEMORY,
     # since we then need to enlarge the heap(s).
-    src = test_file('core', 'test_memorygrowth_2.c')
+    src = test_file('core/test_memorygrowth_2.c')
 
     # Fail without memory growth
     self.do_runf(src, 'OOM', assert_returncode=NON_ZERO)
@@ -2112,9 +2113,9 @@ def test_aborting_new(self, args):
   @no_wasm2js('no WebAssembly.Memory()')
   @no_asan('ASan alters the memory size')
   def test_module_wasm_memory(self):
-    self.emcc_args += ['--pre-js', test_file('core', 'test_module_wasm_memory.js')]
+    self.emcc_args += ['--pre-js', test_file('core/test_module_wasm_memory.js')]
     self.set_setting('IMPORTED_MEMORY')
-    self.do_runf(test_file('core', 'test_module_wasm_memory.c'), 'success')
+    self.do_runf(test_file('core/test_module_wasm_memory.c'), 'success')
 
   def test_ssr(self): # struct self-ref
       src = '''
@@ -2405,14 +2406,14 @@ def test_atexit_threads(self):
 
   @no_asan('test relies on null pointer reads')
   def test_pthread_specific(self):
-    self.do_run_in_out_file_test('pthread', 'specific.c')
+    self.do_run_in_out_file_test('pthread/specific.c')
 
   def test_pthread_equal(self):
-    self.do_run_in_out_file_test('pthread', 'test_pthread_equal.cpp')
+    self.do_run_in_out_file_test('pthread/test_pthread_equal.cpp')
 
   @node_pthreads
   def test_pthread_dispatch_after_exit(self):
-    self.do_run_in_out_file_test('pthread', 'test_pthread_dispatch_after_exit.c')
+    self.do_run_in_out_file_test('pthread/test_pthread_dispatch_after_exit.c')
 
   @node_pthreads
   def test_pthread_thread_local_storage(self):
@@ -2420,10 +2421,10 @@ def test_pthread_thread_local_storage(self):
     self.set_setting('EXIT_RUNTIME')
     self.set_setting('PTHREAD_POOL_SIZE', 8)
     self.set_setting('INITIAL_MEMORY', '300mb')
-    self.do_run_in_out_file_test('pthread', 'test_pthread_thread_local_storage.cpp')
+    self.do_run_in_out_file_test('pthread/test_pthread_thread_local_storage.cpp')
 
   def test_tcgetattr(self):
-    self.do_runf(test_file('termios', 'test_tcgetattr.c'), 'success')
+    self.do_runf(test_file('termios/test_tcgetattr.c'), 'success')
 
   def test_time(self):
     self.do_core_test('test_time.cpp')
@@ -2520,7 +2521,7 @@ def test_bsearch(self):
 
   def test_stack_overflow(self):
     self.set_setting('ASSERTIONS', 2)
-    self.do_runf(test_file('core', 'stack_overflow.cpp'), 'stack overflow', assert_returncode=NON_ZERO)
+    self.do_runf(test_file('core/stack_overflow.cpp'), 'stack overflow', assert_returncode=NON_ZERO)
 
   def test_stackAlloc(self):
     self.do_core_test('stackAlloc.cpp')
@@ -4536,23 +4537,23 @@ def test_dylink_spaghetti(self):
   @needs_make('mingw32-make')
   @needs_dylink
   def test_dylink_zlib(self):
-    self.emcc_args += ['-Wno-shift-negative-value', '-I' + test_file('third_party', 'zlib')]
+    self.emcc_args += ['-Wno-shift-negative-value', '-I' + test_file('third_party/zlib')]
     self.set_setting('RELOCATABLE')
     zlib_archive = self.get_zlib_library()
-    self.dylink_test(main=open(test_file('third_party', 'zlib', 'example.c')).read(),
+    self.dylink_test(main=open(test_file('third_party/zlib/example.c')).read(),
                      side=zlib_archive,
-                     expected=open(test_file('core', 'test_zlib.out')).read(),
+                     expected=open(test_file('core/test_zlib.out')).read(),
                      force_c=True)
 
   # @needs_dylink
   # def test_dylink_bullet(self):
-  #   self.emcc_args += ['-I' + test_file('bullet', 'src')]
+  #   self.emcc_args += ['-I' + test_file('bullet/src')]
   #   side = self.get_bullet_library(self, True)
-  #   self.dylink_test(main=open(test_file('bullet', 'Demos', 'HelloWorld', 'HelloWorld.cpp')).read(),
+  #   self.dylink_test(main=open(test_file('bullet/Demos/HelloWorld/HelloWorld.cpp')).read(),
   #                    side=side,
-  #                    expected=[open(test_file('bullet', 'output.txt')).read(), # different roundings
-  #                              open(test_file('bullet', 'output2.txt')).read(),
-  #                              open(test_file('bullet', 'output3.txt')).read()])
+  #                    expected=[open(test_file('bullet/output.txt')).read(), # different roundings
+  #                              open(test_file('bullet/output2.txt')).read(),
+  #                              open(test_file('bullet/output3.txt')).read()])
 
   @needs_dylink
   def test_dylink_rtti(self):
@@ -4635,8 +4636,8 @@ def test_dylink_argv_argc(self):
   def test_dylink_weak(self):
     # Verify that weakly symbols can be defined in both side module and main
     # module
-    main = test_file('core', 'test_dylink_weak_main.c')
-    side = test_file('core', 'test_dylink_weak_side.c')
+    main = test_file('core/test_dylink_weak_main.c')
+    side = test_file('core/test_dylink_weak_side.c')
     self.dylink_testf(main, side, force_c=True, need_reverse=False)
 
   @node_pthreads
@@ -4772,16 +4773,16 @@ def test_printf(self):
     # needs to flush stdio streams
     self.emcc_args.append('-Wno-format')
     self.set_setting('EXIT_RUNTIME')
-    self.do_run_in_out_file_test('printf', 'test.c')
+    self.do_run_in_out_file_test('printf/test.c')
 
   def test_printf_2(self):
     self.do_core_test('test_printf_2.c')
 
   def test_printf_float(self):
-    self.do_run_in_out_file_test('printf', 'test_float.c')
+    self.do_run_in_out_file_test('printf/test_float.c')
 
   def test_printf_octal(self):
-    self.do_run_in_out_file_test('printf', 'test_octal.c')
+    self.do_run_in_out_file_test('printf/test_octal.c')
 
   def test_vprintf(self):
     self.do_core_test('test_vprintf.c')
@@ -4984,23 +4985,23 @@ def clean(out, err):
 
   def test_mount(self):
     self.set_setting('FORCE_FILESYSTEM')
-    self.do_runf(test_file('fs', 'test_mount.c'), 'success')
+    self.do_runf(test_file('fs/test_mount.c'), 'success')
 
   def test_getdents64(self):
-    self.do_runf(test_file('fs', 'test_getdents64.cpp'), '..')
+    self.do_runf(test_file('fs/test_getdents64.cpp'), '..')
 
   def test_getdents64_special_cases(self):
     # https://bugs.chromium.org/p/v8/issues/detail?id=6881
     self.banned_js_engines = [config.V8_ENGINE]
-    self.do_run_in_out_file_test('fs', 'test_getdents64_special_cases.cpp')
+    self.do_run_in_out_file_test('fs/test_getdents64_special_cases.cpp')
 
   def test_getcwd_with_non_ascii_name(self):
     # https://bugs.chromium.org/p/v8/issues/detail?id=6881
     self.banned_js_engines = [config.V8_ENGINE]
-    self.do_run_in_out_file_test('fs', 'test_getcwd_with_non_ascii_name.cpp')
+    self.do_run_in_out_file_test('fs/test_getcwd_with_non_ascii_name.cpp')
 
   def test_proc_self_fd(self):
-    self.do_run_in_out_file_test('fs', 'test_proc_self_fd.c')
+    self.do_run_in_out_file_test('fs/test_proc_self_fd.c')
 
   def test_fwrite_0(self):
     self.do_core_test('test_fwrite_0.c')
@@ -5013,7 +5014,7 @@ def test_fgetc_ungetc(self):
       self.emcc_args = orig_compiler_opts + ['-D' + fs]
       if fs == 'NODEFS':
         self.emcc_args += ['-lnodefs.js']
-      self.do_runf(test_file('stdio', 'test_fgetc_ungetc.c'), 'success', js_engines=[config.NODE_JS])
+      self.do_runf(test_file('stdio/test_fgetc_ungetc.c'), 'success', js_engines=[config.NODE_JS])
 
   def test_fgetc_unsigned(self):
     src = r'''
@@ -5122,35 +5123,35 @@ def test_fileno(self):
     self.do_run(src, '3\n')
 
   def test_readdir(self):
-    self.do_run_in_out_file_test('dirent', 'test_readdir.c')
+    self.do_run_in_out_file_test('dirent/test_readdir.c')
 
   def test_readdir_empty(self):
-    self.do_run_in_out_file_test('dirent', 'test_readdir_empty.c')
+    self.do_run_in_out_file_test('dirent/test_readdir_empty.c')
 
   def test_stat(self):
-    self.do_runf(test_file('stat', 'test_stat.c'), 'success')
+    self.do_runf(test_file('stat/test_stat.c'), 'success')
     self.verify_in_strict_mode('test_stat.js')
 
   def test_fstatat(self):
-    self.do_runf(test_file('stat', 'test_fstatat.c'), 'success')
+    self.do_runf(test_file('stat/test_fstatat.c'), 'success')
 
   def test_stat_chmod(self):
-    self.do_runf(test_file('stat', 'test_chmod.c'), 'success')
+    self.do_runf(test_file('stat/test_chmod.c'), 'success')
 
   def test_stat_mknod(self):
-    self.do_runf(test_file('stat', 'test_mknod.c'), 'success')
+    self.do_runf(test_file('stat/test_mknod.c'), 'success')
 
   def test_fcntl(self):
     self.add_pre_run("FS.createDataFile('/', 'test', 'abcdef', true, true, false);")
-    self.do_run_in_out_file_test('fcntl', 'test_fcntl.c')
+    self.do_run_in_out_file_test('fcntl/test_fcntl.c')
 
   def test_fcntl_open(self):
-    self.do_run_in_out_file_test('fcntl', 'test_fcntl_open.c')
+    self.do_run_in_out_file_test('fcntl/test_fcntl_open.c')
 
   @also_with_wasm_bigint
   def test_fcntl_misc(self):
     self.add_pre_run("FS.createDataFile('/', 'test', 'abcdef', true, true, false);")
-    self.do_run_in_out_file_test('fcntl', 'test_fcntl_misc.c')
+    self.do_run_in_out_file_test('fcntl/test_fcntl_misc.c')
 
   def test_poll(self):
     self.add_pre_run('''
@@ -5169,10 +5170,10 @@ def test_libgen(self):
     self.do_core_test('test_libgen.c')
 
   def test_utime(self):
-    self.do_runf(test_file('utime', 'test_utime.c'), 'success')
+    self.do_runf(test_file('utime/test_utime.c'), 'success')
 
   def test_futimens(self):
-    self.do_runf(path_from_root('tests', 'utime', 'test_futimens.c'), 'success')
+    self.do_runf(test_file('utime', 'test_futimens.c'), 'success')
 
   @no_minimal_runtime('MINIMAL_RUNTIME does not have getValue() and setValue() (TODO add it to a JS library function to get it in)')
   def test_utf(self):
@@ -5190,7 +5191,7 @@ def test_utf32(self):
     self.do_runf(test_file('utf32.cpp'), 'OK.', args=['-fshort-wchar'])
 
   def test_utf16(self):
-    self.do_runf(test_file('core', 'test_utf16.cpp'), 'OK.')
+    self.do_runf(test_file('core/test_utf16.cpp'), 'OK.')
 
   def test_utf8(self):
     if self.get_setting('MINIMAL_RUNTIME'):
@@ -5260,9 +5261,9 @@ def test_istream(self):
   def test_fs_base(self):
     self.set_setting('DEFAULT_LIBRARY_FUNCS_TO_INCLUDE', ['$FS'])
     self.uses_es6 = True
-    self.add_pre_run(open(test_file('filesystem', 'src.js')).read())
+    self.add_pre_run(open(test_file('filesystem/src.js')).read())
     src = 'int main() {return 0;}\n'
-    expected = open(test_file('filesystem', 'output.txt')).read()
+    expected = open(test_file('filesystem/output.txt')).read()
     self.do_run(src, expected)
 
   @also_with_noderawfs
@@ -5274,44 +5275,44 @@ def test_fs_nodefs_rw(self):
     self.uses_es6 = True
     self.emcc_args += ['-lnodefs.js']
     self.set_setting('SYSCALL_DEBUG')
-    self.do_runf(test_file('fs', 'test_nodefs_rw.c'), 'success')
+    self.do_runf(test_file('fs/test_nodefs_rw.c'), 'success')
     if '-g' not in self.emcc_args:
       print('closure')
       self.emcc_args += ['--closure=1']
-      self.do_runf(test_file('fs', 'test_nodefs_rw.c'), 'success')
+      self.do_runf(test_file('fs/test_nodefs_rw.c'), 'success')
 
   @also_with_noderawfs
   def test_fs_nodefs_cloexec(self):
     self.emcc_args += ['-lnodefs.js']
-    self.do_runf(test_file('fs', 'test_nodefs_cloexec.c'), 'success')
+    self.do_runf(test_file('fs/test_nodefs_cloexec.c'), 'success')
 
   def test_fs_nodefs_home(self):
     self.set_setting('FORCE_FILESYSTEM')
     self.emcc_args += ['-lnodefs.js']
-    self.do_runf(test_file('fs', 'test_nodefs_home.c'), 'success', js_engines=[config.NODE_JS])
+    self.do_runf(test_file('fs/test_nodefs_home.c'), 'success', js_engines=[config.NODE_JS])
 
   def test_fs_nodefs_nofollow(self):
     self.emcc_args += ['-lnodefs.js']
-    self.do_runf(test_file('fs', 'test_nodefs_nofollow.c'), 'success', js_engines=[config.NODE_JS])
+    self.do_runf(test_file('fs/test_nodefs_nofollow.c'), 'success', js_engines=[config.NODE_JS])
 
   def test_fs_trackingdelegate(self):
-    self.do_run_in_out_file_test('fs', 'test_trackingdelegate.c')
+    self.do_run_in_out_file_test('fs/test_trackingdelegate.c')
 
   @also_with_noderawfs
   def test_fs_writeFile(self):
     self.set_setting('DISABLE_EXCEPTION_CATCHING') # see issue 2334
-    self.do_run_in_out_file_test('fs', 'test_writeFile.cpp')
+    self.do_run_in_out_file_test('fs/test_writeFile.cpp')
 
   def test_fs_write(self):
-    self.do_run_in_out_file_test('fs', 'test_write.cpp')
+    self.do_run_in_out_file_test('fs/test_write.cpp')
 
   @also_with_noderawfs
   def test_fs_emptyPath(self):
-    self.do_run_in_out_file_test('fs', 'test_emptyPath.c')
+    self.do_run_in_out_file_test('fs/test_emptyPath.c')
 
   @also_with_noderawfs
   def test_fs_append(self):
-    self.do_runf(test_file('fs', 'test_append.c'), 'success')
+    self.do_runf(test_file('fs/test_append.c'), 'success')
 
   def test_fs_mmap(self):
     self.uses_es6 = True
@@ -5322,7 +5323,7 @@ def test_fs_mmap(self):
         self.emcc_args += ['-lnodefs.js']
       if fs == 'NODERAWFS':
         self.emcc_args += ['-lnodefs.js', '-lnoderawfs.js']
-      self.do_run_in_out_file_test('fs', 'test_mmap.c')
+      self.do_run_in_out_file_test('fs/test_mmap.c')
 
   @also_with_noderawfs
   def test_fs_errorstack(self):
@@ -5353,10 +5354,10 @@ def test_fs_errorstack(self):
   @also_with_noderawfs
   def test_fs_llseek(self):
     self.set_setting('FORCE_FILESYSTEM')
-    self.do_runf(test_file('fs', 'test_llseek.c'), 'success')
+    self.do_runf(test_file('fs/test_llseek.c'), 'success')
 
   def test_fs_64bit(self):
-    self.do_runf(test_file('fs', 'test_64bit.c'), 'success')
+    self.do_runf(test_file('fs/test_64bit.c'), 'success')
 
   def test_sigalrm(self):
     self.do_runf(test_file('sigalrm.cpp'), '')
@@ -5369,37 +5370,37 @@ def test_unistd_access(self):
       self.emcc_args = orig_compiler_opts + ['-D' + fs]
       if fs == 'NODEFS':
         self.emcc_args += ['-lnodefs.js']
-      self.do_run_in_out_file_test('unistd', 'access.c', js_engines=[config.NODE_JS])
+      self.do_run_in_out_file_test('unistd/access.c', js_engines=[config.NODE_JS])
     # Node.js fs.chmod is nearly no-op on Windows
     if not WINDOWS:
       self.emcc_args = orig_compiler_opts
       self.set_setting('NODERAWFS')
-      self.do_run_in_out_file_test('unistd', 'access.c', js_engines=[config.NODE_JS])
+      self.do_run_in_out_file_test('unistd/access.c', js_engines=[config.NODE_JS])
 
   def test_unistd_curdir(self):
     self.uses_es6 = True
-    self.do_run_in_out_file_test('unistd', 'curdir.c')
+    self.do_run_in_out_file_test('unistd/curdir.c')
 
   @also_with_noderawfs
   def test_unistd_close(self):
-    self.do_run_in_out_file_test('unistd', 'close.c')
+    self.do_run_in_out_file_test('unistd/close.c')
 
   def test_unistd_confstr(self):
-    self.do_run_in_out_file_test('unistd', 'confstr.c')
+    self.do_run_in_out_file_test('unistd/confstr.c')
 
   def test_unistd_ttyname(self):
-    self.do_runf(test_file('unistd', 'ttyname.c'), 'success')
+    self.do_runf(test_file('unistd/ttyname.c'), 'success')
 
   @also_with_noderawfs
   def test_unistd_pipe(self):
-    self.do_runf(test_file('unistd', 'pipe.c'), 'success')
+    self.do_runf(test_file('unistd/pipe.c'), 'success')
 
   @also_with_noderawfs
   def test_unistd_dup(self):
-    self.do_run_in_out_file_test('unistd', 'dup.c')
+    self.do_run_in_out_file_test('unistd/dup.c')
 
   def test_unistd_pathconf(self):
-    self.do_run_in_out_file_test('unistd', 'pathconf.c')
+    self.do_run_in_out_file_test('unistd/pathconf.c')
 
   def test_unistd_truncate(self):
     self.uses_es6 = True
@@ -5408,28 +5409,28 @@ def test_unistd_truncate(self):
       self.emcc_args = orig_compiler_opts + ['-D' + fs]
       if fs == 'NODEFS':
         self.emcc_args += ['-lnodefs.js']
-      self.do_run_in_out_file_test('unistd', 'truncate.c', js_engines=[config.NODE_JS])
+      self.do_run_in_out_file_test('unistd/truncate.c', js_engines=[config.NODE_JS])
 
   @no_windows("Windows throws EPERM rather than EACCES or EINVAL")
   @unittest.skipIf(WINDOWS or os.geteuid() == 0, "Root access invalidates this test by being able to write on readonly files")
   def test_unistd_truncate_noderawfs(self):
     self.uses_es6 = True
     self.set_setting('NODERAWFS')
-    self.do_run_in_out_file_test('unistd', 'truncate.c', js_engines=[config.NODE_JS])
+    self.do_run_in_out_file_test('unistd/truncate.c', js_engines=[config.NODE_JS])
 
   def test_unistd_swab(self):
-    self.do_run_in_out_file_test('unistd', 'swab.c')
+    self.do_run_in_out_file_test('unistd/swab.c')
 
   def test_unistd_isatty(self):
-    self.do_runf(test_file('unistd', 'isatty.c'), 'success')
+    self.do_runf(test_file('unistd/isatty.c'), 'success')
 
   @also_with_standalone_wasm()
   def test_unistd_sysconf(self):
-    self.do_run_in_out_file_test('unistd', 'sysconf.c')
+    self.do_run_in_out_file_test('unistd/sysconf.c')
 
   @no_asan('ASan alters memory layout')
   def test_unistd_sysconf_phys_pages(self):
-    filename = test_file('unistd', 'sysconf_phys_pages.c')
+    filename = test_file('unistd/sysconf_phys_pages.c')
     if self.get_setting('ALLOW_MEMORY_GROWTH'):
       expected = (2 * 1024 * 1024 * 1024) // webassembly.WASM_PAGE_SIZE
     else:
@@ -5437,7 +5438,7 @@ def test_unistd_sysconf_phys_pages(self):
     self.do_runf(filename, str(expected) + ', errno: 0')
 
   def test_unistd_login(self):
-    self.do_run_in_out_file_test('unistd', 'login.c')
+    self.do_run_in_out_file_test('unistd/login.c')
 
   @no_windows('https://github.com/emscripten-core/emscripten/issues/8882')
   def test_unistd_unlink(self):
@@ -5453,7 +5454,7 @@ def test_unistd_unlink(self):
           self.emcc_args += ['-DNO_SYMLINK=1']
         if MACOS:
           continue
-      self.do_runf(test_file('unistd', 'unlink.c'), 'success', js_engines=[config.NODE_JS])
+      self.do_runf(test_file('unistd/unlink.c'), 'success', js_engines=[config.NODE_JS])
     # Several differences/bugs on non-linux including https://github.com/nodejs/node/issues/18014
     if not WINDOWS and not MACOS:
       self.emcc_args = orig_compiler_opts + ['-DNODERAWFS']
@@ -5461,7 +5462,7 @@ def test_unistd_unlink(self):
       if os.geteuid() == 0:
         self.emcc_args += ['-DSKIP_ACCESS_TESTS']
       self.set_setting('NODERAWFS')
-      self.do_runf(test_file('unistd', 'unlink.c'), 'success', js_engines=[config.NODE_JS])
+      self.do_runf(test_file('unistd/unlink.c'), 'success', js_engines=[config.NODE_JS])
 
   def test_unistd_links(self):
     self.clear()
@@ -5476,7 +5477,7 @@ def test_unistd_links(self):
       self.emcc_args = orig_compiler_opts + ['-D' + fs]
       if fs == 'NODEFS':
         self.emcc_args += ['-lnodefs.js']
-      self.do_run_in_out_file_test('unistd', 'links.c', js_engines=[config.NODE_JS])
+      self.do_run_in_out_file_test('unistd/links.c', js_engines=[config.NODE_JS])
 
   @no_windows('Skipping NODEFS test, since it would require administrative privileges.')
   def test_unistd_symlink_on_nodefs(self):
@@ -5484,10 +5485,10 @@ def test_unistd_symlink_on_nodefs(self):
     # test expects /, but Windows gives \ as path slashes.
     # Calling readlink() on a non-link gives error 22 EINVAL on Unix, but simply error 0 OK on Windows.
     self.emcc_args += ['-lnodefs.js']
-    self.do_run_in_out_file_test('unistd', 'symlink_on_nodefs.c', js_engines=[config.NODE_JS])
+    self.do_run_in_out_file_test('unistd/symlink_on_nodefs.c', js_engines=[config.NODE_JS])
 
   def test_unistd_sleep(self):
-    self.do_run_in_out_file_test('unistd', 'sleep.c')
+    self.do_run_in_out_file_test('unistd/sleep.c')
 
   @also_with_wasm_bigint
   def test_unistd_io(self):
@@ -5498,7 +5499,7 @@ def test_unistd_io(self):
       self.emcc_args = orig_compiler_opts + ['-D' + fs]
       if fs == 'NODEFS':
         self.emcc_args += ['-lnodefs.js']
-      self.do_run_in_out_file_test('unistd', 'io.c')
+      self.do_run_in_out_file_test('unistd/io.c')
 
   @no_windows('https://github.com/emscripten-core/emscripten/issues/8882')
   def test_unistd_misc(self):
@@ -5507,7 +5508,7 @@ def test_unistd_misc(self):
       self.emcc_args = orig_compiler_opts + ['-D' + fs]
       if fs == 'NODEFS':
         self.emcc_args += ['-lnodefs.js']
-      self.do_run_in_out_file_test('unistd', 'misc.c', js_engines=[config.NODE_JS])
+      self.do_run_in_out_file_test('unistd/misc.c', js_engines=[config.NODE_JS])
 
   # i64s in the API, which we'd need to legalize for JS, so in standalone mode
   # all we can test is wasm VMs
@@ -5523,15 +5524,15 @@ def test_unary_literal(self):
     self.do_core_test('test_unary_literal.cpp')
 
   def test_env(self):
-    expected = open(test_file('env', 'output.txt')).read()
-    self.do_runf(test_file('env', 'src.c'), [
+    expected = open(test_file('env/output.txt')).read()
+    self.do_runf(test_file('env/src.c'), [
       expected.replace('{{{ THIS_PROGRAM }}}', self.in_dir('src.js')).replace('\\', '/'), # node, can find itself properly
       expected.replace('{{{ THIS_PROGRAM }}}', './this.program') # spidermonkey, v8
     ])
 
   def test_environ(self):
-    expected = open(test_file('env', 'output-mini.txt')).read()
-    self.do_runf(test_file('env', 'src-mini.c'), [
+    expected = open(test_file('env/output-mini.txt')).read()
+    self.do_runf(test_file('env/src-mini.c'), [
       expected.replace('{{{ THIS_PROGRAM }}}', self.in_dir('src-mini.js')).replace('\\', '/'), # node, can find itself properly
       expected.replace('{{{ THIS_PROGRAM }}}', './this.program') # spidermonkey, v8
     ])
@@ -5575,7 +5576,7 @@ def test_phiundef(self):
     self.do_core_test('test_phiundef.c')
 
   def test_netinet_in(self):
-    self.do_run_in_out_file_test('netinet', 'in.cpp')
+    self.do_run_in_out_file_test('netinet/in.cpp')
 
   @needs_dylink
   def test_main_module_static_align(self):
@@ -5672,7 +5673,7 @@ def test_unicode_js_library(self):
     self.do_runf('main.cpp', u'Unicode snowman \u2603 says hello!')
 
   def test_funcptr_import_type(self):
-    self.emcc_args += ['--js-library', test_file('core', 'test_funcptr_import_type.js')]
+    self.emcc_args += ['--js-library', test_file('core/test_funcptr_import_type.js')]
     self.do_core_test('test_funcptr_import_type.cpp')
 
   @no_asan('ASan does not work with EXPORT_ALL')
@@ -5802,7 +5803,7 @@ def test_dlmalloc(self):
   @no_asan('the memory size limit here is too small for asan')
   def test_dlmalloc_large(self):
     self.emcc_args += ['-s', 'ABORTING_MALLOC=0', '-s', 'ALLOW_MEMORY_GROWTH=1', '-s', 'MAXIMUM_MEMORY=128MB']
-    self.do_runf(path_from_root('tests', 'dlmalloc_test_large.c'), '0 0 0 1')
+    self.do_runf(test_file('dlmalloc_test_large.c'), '0 0 0 1')
 
   @no_asan('asan also changes malloc, and that ends up linking in new twice')
   def test_dlmalloc_partial(self):
@@ -5879,10 +5880,10 @@ def test_cubescript(self):
     # uses register keyword
     self.emcc_args += ['-std=c++03', '-Wno-dynamic-class-memaccess']
     self.maybe_closure()
-    self.emcc_args += ['-I', test_file('third_party', 'cubescript')]
+    self.emcc_args += ['-I', test_file('third_party/cubescript')]
 
     def test():
-      src = test_file('third_party', 'cubescript', 'command.cpp')
+      src = test_file('third_party/cubescript/command.cpp')
       self.do_runf(src, '*\nTemp is 33\n9\n5\nhello, everyone\n*')
 
     test()
@@ -5913,14 +5914,14 @@ def test_neon_wasm_simd(self):
     self.emcc_args.append('-Wno-c++11-narrowing')
     self.emcc_args.append('-mfpu=neon')
     self.emcc_args.append('-msimd128')
-    self.do_runf(test_file('neon', 'test_neon_wasm_simd.cpp'), 'Success!')
+    self.do_runf(test_file('neon/test_neon_wasm_simd.cpp'), 'Success!')
 
   # Tests invoking the SIMD API via x86 SSE1 xmmintrin.h header (_mm_x() functions)
   @wasm_simd
   @requires_native_clang
   @no_safe_heap('has unaligned 64-bit operations in wasm')
   def test_sse1(self):
-    src = test_file('sse', 'test_sse1.cpp')
+    src = test_file('sse/test_sse1.cpp')
     self.run_process([shared.CLANG_CXX, src, '-msse', '-o', 'test_sse1', '-D_CRT_SECURE_NO_WARNINGS=1'] + clang_native.get_clang_native_args(), stdout=PIPE)
     native_result = self.run_process('./test_sse1', stdout=PIPE).stdout
 
@@ -5935,7 +5936,7 @@ def test_sse1(self):
   @no_safe_heap('has unaligned 64-bit operations in wasm')
   @is_slow_test
   def test_sse2(self):
-    src = test_file('sse', 'test_sse2.cpp')
+    src = test_file('sse/test_sse2.cpp')
     self.run_process([shared.CLANG_CXX, src, '-msse2', '-Wno-argument-outside-range', '-o', 'test_sse2', '-D_CRT_SECURE_NO_WARNINGS=1'] + clang_native.get_clang_native_args(), stdout=PIPE)
     native_result = self.run_process('./test_sse2', stdout=PIPE).stdout
 
@@ -5947,7 +5948,7 @@ def test_sse2(self):
   @wasm_simd
   @requires_native_clang
   def test_sse3(self):
-    src = test_file('sse', 'test_sse3.cpp')
+    src = test_file('sse/test_sse3.cpp')
     self.run_process([shared.CLANG_CXX, src, '-msse3', '-Wno-argument-outside-range', '-o', 'test_sse3', '-D_CRT_SECURE_NO_WARNINGS=1'] + clang_native.get_clang_native_args(), stdout=PIPE)
     native_result = self.run_process('./test_sse3', stdout=PIPE).stdout
 
@@ -5959,7 +5960,7 @@ def test_sse3(self):
   @wasm_simd
   @requires_native_clang
   def test_ssse3(self):
-    src = test_file('sse', 'test_ssse3.cpp')
+    src = test_file('sse/test_ssse3.cpp')
     self.run_process([shared.CLANG_CXX, src, '-mssse3', '-Wno-argument-outside-range', '-o', 'test_ssse3', '-D_CRT_SECURE_NO_WARNINGS=1'] + clang_native.get_clang_native_args(), stdout=PIPE)
     native_result = self.run_process('./test_ssse3', stdout=PIPE).stdout
 
@@ -5972,7 +5973,7 @@ def test_ssse3(self):
   @requires_native_clang
   @is_slow_test
   def test_sse4_1(self):
-    src = test_file('sse', 'test_sse4_1.cpp')
+    src = test_file('sse/test_sse4_1.cpp')
     self.run_process([shared.CLANG_CXX, src, '-msse4.1', '-Wno-argument-outside-range', '-o', 'test_sse4_1', '-D_CRT_SECURE_NO_WARNINGS=1'] + clang_native.get_clang_native_args(), stdout=PIPE)
     native_result = self.run_process('./test_sse4_1', stdout=PIPE).stdout
 
@@ -5984,7 +5985,7 @@ def test_sse4_1(self):
   @wasm_simd
   @requires_native_clang
   def test_sse4_2(self):
-    src = test_file('sse', 'test_sse4_2.cpp')
+    src = test_file('sse/test_sse4_2.cpp')
     self.run_process([shared.CLANG_CXX, src, '-msse4.2', '-Wno-argument-outside-range', '-o', 'test_sse4_2', '-D_CRT_SECURE_NO_WARNINGS=1'] + clang_native.get_clang_native_args(), stdout=PIPE)
     native_result = self.run_process('./test_sse4_2', stdout=PIPE).stdout
 
@@ -5996,7 +5997,7 @@ def test_sse4_2(self):
   @wasm_simd
   @requires_native_clang
   def test_avx(self):
-    src = test_file('sse', 'test_avx.cpp')
+    src = test_file('sse/test_avx.cpp')
     self.run_process([shared.CLANG_CXX, src, '-mavx', '-Wno-argument-outside-range', '-o', 'test_avx', '-D_CRT_SECURE_NO_WARNINGS=1'] + clang_native.get_clang_native_args(), stdout=PIPE)
     native_result = self.run_process('./test_avx', stdout=PIPE).stdout
 
@@ -6007,7 +6008,7 @@ def test_avx(self):
   @wasm_simd
   def test_sse_diagnostics(self):
     self.emcc_args.remove('-Werror')
-    src = test_file('sse', 'test_sse_diagnostic.cpp')
+    src = test_file('sse/test_sse_diagnostic.cpp')
 
     p = self.run_process(
       [shared.EMXX, src, '-msse', '-DWASM_SIMD_COMPAT_SLOW'] + self.get_emcc_args(),
@@ -6016,9 +6017,9 @@ def test_sse_diagnostics(self):
 
   @no_asan('call stack exceeded on some versions of node')
   def test_gcc_unmangler(self):
-    self.emcc_args += ['-I' + test_file('third_party', 'libiberty')]
+    self.emcc_args += ['-I' + test_file('third_party/libiberty')]
 
-    self.do_runf(test_file('third_party', 'libiberty', 'cp-demangle.c'), '*d_demangle(char const*, int, unsigned int*)*', args=['_ZL10d_demanglePKciPj'])
+    self.do_runf(test_file('third_party/libiberty/cp-demangle.c'), '*d_demangle(char const*, int, unsigned int*)*', args=['_ZL10d_demanglePKciPj'])
 
   @needs_make('make')
   def test_lua(self):
@@ -6027,7 +6028,7 @@ def test_lua(self):
     self.do_run('',
                 'hello lua world!\n17\n1\n2\n3\n4\n7',
                 args=['-e', '''print("hello lua world!");print(17);for x = 1,4 do print(x) end;print(10-3)'''],
-                libraries=self.get_library(os.path.join('third_party', 'lua'), [os.path.join('src', 'lua.o'), os.path.join('src', 'liblua.a')], make=['make', 'generic'], configure=None),
+                libraries=self.get_library('third_party/lua', [Path('src/lua.o'), Path('src/liblua.a')], make=['make', 'generic'], configure=None),
                 includes=[test_file('lua')],
                 output_nicerizer=lambda string, err: (string + err).replace('\n\n', '\n').replace('\n\n', '\n'))
 
@@ -6036,37 +6037,37 @@ def test_lua(self):
   @is_slow_test
   def test_freetype(self):
     self.add_pre_run("FS.createDataFile('/', 'font.ttf', %s, true, false, false);" % str(
-      list(bytearray(open(test_file('freetype', 'LiberationSansBold.ttf'), 'rb').read()))
+      list(bytearray(open(test_file('freetype/LiberationSansBold.ttf'), 'rb').read()))
     ))
 
     # Not needed for js, but useful for debugging
-    shutil.copyfile(test_file('freetype', 'LiberationSansBold.ttf'), 'font.ttf')
+    shutil.copyfile(test_file('freetype/LiberationSansBold.ttf'), 'font.ttf')
 
     # Main
-    self.do_run_from_file(test_file('freetype', 'main.c'),
-                          test_file('freetype', 'ref.txt'),
+    self.do_run_from_file(test_file('freetype/main.c'),
+                          test_file('freetype/ref.txt'),
                           args=['font.ttf', 'test!', '150', '120', '25'],
                           libraries=self.get_freetype_library(),
-                          includes=[test_file('third_party', 'freetype', 'include')])
+                          includes=[test_file('third_party/freetype/include')])
 
     # github issue 324
     print('[issue 324]')
-    self.do_run_from_file(test_file('freetype', 'main_2.c'),
-                          test_file('freetype', 'ref_2.txt'),
+    self.do_run_from_file(test_file('freetype/main_2.c'),
+                          test_file('freetype/ref_2.txt'),
                           args=['font.ttf', 'w', '32', '32', '25'],
                           libraries=self.get_freetype_library(),
-                          includes=[test_file('third_party', 'freetype', 'include')])
+                          includes=[test_file('third_party/freetype/include')])
 
     print('[issue 324 case 2]')
-    self.do_run_from_file(test_file('freetype', 'main_3.c'),
-                          test_file('freetype', 'ref_3.txt'),
+    self.do_run_from_file(test_file('freetype/main_3.c'),
+                          test_file('freetype/ref_3.txt'),
                           args=['font.ttf', 'W', '32', '32', '0'],
                           libraries=self.get_freetype_library(),
-                          includes=[test_file('third_party', 'freetype', 'include')])
+                          includes=[test_file('third_party/freetype/include')])
 
     print('[issue 324 case 3]')
     self.do_run('main_3.js',
-                open(test_file('freetype', 'ref_4.txt')).read(),
+                open(test_file('freetype/ref_4.txt')).read(),
                 args=['font.ttf', 'ea', '40', '32', '0'],
                 no_build=True)
 
@@ -6091,7 +6092,7 @@ def test_sqlite(self):
     self.emcc_args += ['-Wno-unknown-warning-option']
     self.emcc_args += ['-Wno-pointer-bool-conversion']
 
-    self.emcc_args += ['-I' + test_file('third_party', 'sqlite')]
+    self.emcc_args += ['-I' + test_file('third_party/sqlite')]
 
     src = '''
        #define SQLITE_DISABLE_LFS
@@ -6099,10 +6100,10 @@ def test_sqlite(self):
        #define SQLITE_INT64_TYPE long long int
        #define SQLITE_THREADSAFE 0
     '''
-    src += open(test_file('third_party', 'sqlite', 'sqlite3.c')).read()
-    src += open(test_file('sqlite', 'benchmark.c')).read()
+    src += open(test_file('third_party/sqlite/sqlite3.c')).read()
+    src += open(test_file('sqlite/benchmark.c')).read()
     self.do_run(src,
-                open(test_file('sqlite', 'benchmark.txt')).read(),
+                open(test_file('sqlite/benchmark.txt')).read(),
                 includes=[test_file('sqlite')],
                 force_c=True)
 
@@ -6130,10 +6131,10 @@ def test_zlib(self, use_cmake):
       configure = ['sh', './configure']
 
     self.do_run_from_file(
-        test_file('third_party', 'zlib', 'example.c'),
-        test_file('core', 'test_zlib.out'),
-        libraries=self.get_library(os.path.join('third_party', 'zlib'), 'libz.a', make_args=make_args, configure=configure),
-        includes=[test_file('third_party', 'zlib'), 'building', 'zlib'])
+        test_file('third_party/zlib/example.c'),
+        test_file('core/test_zlib.out'),
+        libraries=self.get_library('third_party/zlib', 'libz.a', make_args=make_args, configure=configure),
+        includes=[test_file('third_party/zlib'), 'building', 'zlib'])
 
   @needs_make('make')
   @is_slow_test
@@ -6159,19 +6160,19 @@ def test_bullet(self, use_cmake):
       self.set_setting('ASSERTIONS', 2)
       self.emcc_args.append('-Wno-unused-command-line-argument')
 
-    self.do_runf(test_file('third_party', 'bullet', 'Demos', 'HelloWorld', 'HelloWorld.cpp'),
-                 [open(test_file('bullet', 'output.txt')).read(), # different roundings
-                  open(test_file('bullet', 'output2.txt')).read(),
-                  open(test_file('bullet', 'output3.txt')).read(),
-                  open(test_file('bullet', 'output4.txt')).read()],
+    self.do_runf(test_file('third_party/bullet/Demos/HelloWorld/HelloWorld.cpp'),
+                 [open(test_file('bullet/output.txt')).read(), # different roundings
+                  open(test_file('bullet/output2.txt')).read(),
+                  open(test_file('bullet/output3.txt')).read(),
+                  open(test_file('bullet/output4.txt')).read()],
                  libraries=self.get_bullet_library(use_cmake),
-                 includes=[test_file('third_party', 'bullet', 'src')])
+                 includes=[test_file('third_party/bullet/src')])
 
   @no_asan('issues with freetype itself')
   @needs_make('depends on freetype')
   @is_slow_test
   def test_poppler(self):
-    pdf_data = open(test_file('poppler', 'paper.pdf'), 'rb').read()
+    pdf_data = open(test_file('poppler/paper.pdf'), 'rb').read()
     create_file('paper.pdf.js', str(list(bytearray(pdf_data))))
 
     create_file('pre.js', '''
@@ -6185,7 +6186,7 @@ def test_poppler(self):
     ''')
     self.emcc_args += ['--pre-js', 'pre.js', '-s', 'DEFAULT_LIBRARY_FUNCS_TO_INCLUDE=$unSign']
 
-    ppm_data = str(list(bytearray(open(test_file('poppler', 'ref.ppm'), 'rb').read())))
+    ppm_data = str(list(bytearray(open(test_file('poppler/ref.ppm'), 'rb').read())))
     self.do_run('', ppm_data.replace(' ', ''),
                 libraries=self.get_poppler_library(),
                 args=['-scale-to', '512', 'paper.pdf', 'filename'])
@@ -6211,7 +6212,7 @@ def line_splitter(data):
       # remove -g, so we have one test without it by default
       self.emcc_args = [x for x in self.emcc_args if x != '-g']
 
-      original_j2k = test_file('openjpeg', 'syntensity_lobby_s.j2k')
+      original_j2k = test_file('openjpeg/syntensity_lobby_s.j2k')
       image_bytes = list(bytearray(open(original_j2k, 'rb').read()))
       create_file('pre.js', """
         Module.preRun = function() { FS.createDataFile('/', 'image.j2k', %s, true, false, false); };
@@ -6220,13 +6221,13 @@ def line_splitter(data):
         };
         """ % line_splitter(str(image_bytes)))
 
-      shutil.copy(test_file('third_party', 'openjpeg', 'opj_config.h'), self.get_dir())
+      shutil.copy(test_file('third_party/openjpeg/opj_config.h'), self.get_dir())
 
-      lib = self.get_library(os.path.join('third_party', 'openjpeg'),
-                             [os.path.sep.join('codec/CMakeFiles/j2k_to_image.dir/index.c.o'.split('/')),
-                              os.path.sep.join('codec/CMakeFiles/j2k_to_image.dir/convert.c.o'.split('/')),
-                              os.path.sep.join('codec/CMakeFiles/j2k_to_image.dir/__/common/color.c.o'.split('/')),
-                              os.path.join('bin', 'libopenjpeg.a')],
+      lib = self.get_library('third_party/openjpeg',
+                             [Path('codec/CMakeFiles/j2k_to_image.dir/index.c.o'),
+                              Path('codec/CMakeFiles/j2k_to_image.dir/convert.c.o'),
+                              Path('codec/CMakeFiles/j2k_to_image.dir/__/common/color.c.o'),
+                              Path('bin/libopenjpeg.a')],
                              configure=['cmake', '.'],
                              # configure_args=['--enable-tiff=no', '--enable-jp3d=no', '--enable-png=no'],
                              make_args=[]) # no -j 2, since parallel builds can fail
@@ -6243,7 +6244,7 @@ def image_compare(output, err):
         js_data = [x if x >= 0 else 256 + x for x in js_data] # Our output may be signed, so unsign it
 
         # Get the correct output
-        true_data = bytearray(open(test_file('openjpeg', 'syntensity_lobby_s.raw'), 'rb').read())
+        true_data = bytearray(open(test_file('openjpeg/syntensity_lobby_s.raw'), 'rb').read())
 
         # Compare them
         assert(len(js_data) == len(true_data))
@@ -6269,14 +6270,14 @@ def image_compare(output, err):
       self.emcc_args += ['--pre-js', 'pre.js']
 
       def do_test():
-        self.do_runf(test_file('third_party', 'openjpeg', 'codec', 'j2k_to_image.c'),
+        self.do_runf(test_file('third_party/openjpeg/codec/j2k_to_image.c'),
                      'Successfully generated', # The real test for valid output is in image_compare
                      args='-i image.j2k -o image.raw'.split(),
                      libraries=lib,
-                     includes=[test_file('third_party', 'openjpeg', 'libopenjpeg'),
-                               test_file('third_party', 'openjpeg', 'codec'),
-                               test_file('third_party', 'openjpeg', 'common'),
-                               os.path.join(self.get_build_dir(), 'openjpeg')],
+                     includes=[test_file('third_party/openjpeg/libopenjpeg'),
+                               test_file('third_party/openjpeg/codec'),
+                               test_file('third_party/openjpeg/common'),
+                               Path(self.get_build_dir(), 'openjpeg')],
                      output_nicerizer=image_compare)
 
       do_test()
@@ -6299,11 +6300,11 @@ def do_test():
   @no_asan('call stack exceeded on some versions of node')
   @is_slow_test
   def test_fuzz(self):
-    self.emcc_args += ['-I' + test_file('fuzz', 'include'), '-w']
+    self.emcc_args += ['-I' + test_file('fuzz/include'), '-w']
 
     def run_all(x):
       print(x)
-      for name in sorted(glob.glob(test_file('fuzz', '*.c')) + glob.glob(test_file('fuzz', '*.cpp'))):
+      for name in sorted(glob.glob(test_file('fuzz/*.c')) + glob.glob(test_file('fuzz/*.cpp'))):
         if 'newfail' in name:
           continue
         if os.path.basename(name).startswith('temp_fuzzcode'):
@@ -6335,7 +6336,7 @@ def check(out, err):
         self.assertIn(msg, out)
       return out + err
 
-    self.do_runf(test_file('core', 'test_autodebug.c'),
+    self.do_runf(test_file('core/test_autodebug.c'),
                  'success', output_nicerizer=check)
 
   @parameterized({
@@ -6431,8 +6432,8 @@ def test_dyncall_specific(self, *args):
   def test_getValue_setValue(self):
     # these used to be exported, but no longer are by default
     def test(output_prefix='', args=[], assert_returncode=0):
-      src = test_file('core', 'getValue_setValue.cpp')
-      expected = test_file('core', 'getValue_setValue' + output_prefix + '.out')
+      src = test_file('core/getValue_setValue.cpp')
+      expected = test_file('core/getValue_setValue' + output_prefix + '.out')
       self.do_run_from_file(src, expected, assert_returncode=assert_returncode, emcc_args=args)
 
     # see that direct usage (not on module) works. we don't export, but the use
@@ -6456,9 +6457,9 @@ def test(output_prefix='', args=[], assert_returncode=0):
         if use_files:
           args += ['-DUSE_FILES']
         print(args)
-        self.do_runf(test_file('core', 'FS_exports.cpp'),
-                     (open(test_file('core', 'FS_exports' + output_prefix + '.out')).read(),
-                      open(test_file('core', 'FS_exports' + output_prefix + '_2.out')).read()),
+        self.do_runf(test_file('core/FS_exports.cpp'),
+                     (open(test_file('core/FS_exports' + output_prefix + '.out')).read(),
+                      open(test_file('core/FS_exports' + output_prefix + '_2.out')).read()),
                      assert_returncode=assert_returncode, emcc_args=args)
 
       # see that direct usage (not on module) works. we don't export, but the use
@@ -6478,8 +6479,8 @@ def test_legacy_exported_runtime_numbers(self):
     def test(output_prefix='', args=[], assert_returncode=0):
       old = self.emcc_args.copy()
       self.emcc_args += args
-      src = test_file('core', 'legacy_exported_runtime_numbers.cpp')
-      expected = test_file('core', 'legacy_exported_runtime_numbers%s.out' % output_prefix)
+      src = test_file('core/legacy_exported_runtime_numbers.cpp')
+      expected = test_file('core/legacy_exported_runtime_numbers%s.out' % output_prefix)
       self.do_run_from_file(src, expected, assert_returncode=assert_returncode)
       self.emcc_args = old
 
@@ -6575,12 +6576,12 @@ def test_add_function(self):
     self.set_setting('INVOKE_RUN', 0)
     self.set_setting('RESERVED_FUNCTION_POINTERS')
     self.set_setting('EXPORTED_RUNTIME_METHODS', ['callMain'])
-    src = test_file('interop', 'test_add_function.cpp')
-    post_js = test_file('interop', 'test_add_function_post.js')
+    src = test_file('interop/test_add_function.cpp')
+    post_js = test_file('interop/test_add_function_post.js')
     self.emcc_args += ['--post-js', post_js]
 
     print('basics')
-    self.do_run_in_out_file_test('interop', 'test_add_function.cpp')
+    self.do_run_in_out_file_test('interop/test_add_function.cpp')
 
     print('with RESERVED_FUNCTION_POINTERS=0')
     self.set_setting('RESERVED_FUNCTION_POINTERS', 0)
@@ -6599,7 +6600,7 @@ def test_add_function(self):
     self.emcc_args += ['-DGROWTH']
     # enable costly assertions to verify correct table behavior
     self.set_setting('ASSERTIONS', 2)
-    self.do_run_in_out_file_test('interop', 'test_add_function.cpp')
+    self.do_run_in_out_file_test('interop/test_add_function.cpp')
 
   def test_getFuncWrapper_sig_alias(self):
     self.set_setting('DEFAULT_LIBRARY_FUNCS_TO_INCLUDE', ['$getFuncWrapper'])
@@ -6654,7 +6655,7 @@ def test_demangle_stacks_symbol_map(self):
     if '-O' not in str(self.emcc_args) or '-O0' in self.emcc_args or '-O1' in self.emcc_args or '-g' in self.emcc_args:
       self.skipTest("without opts, we don't emit a symbol map")
     self.emcc_args += ['--emit-symbol-map']
-    self.do_runf(test_file('core', 'test_demangle_stacks.cpp'), 'abort', assert_returncode=NON_ZERO)
+    self.do_runf(test_file('core/test_demangle_stacks.cpp'), 'abort', assert_returncode=NON_ZERO)
     # make sure the shortened name is the right one
     full_aborter = None
     short_aborter = None
@@ -6917,39 +6918,39 @@ def test_embind_5(self):
     self.do_core_test('test_embind_5.cpp')
 
   def test_embind_custom_marshal(self):
-    self.emcc_args += ['--bind', '--pre-js', test_file('embind', 'test_custom_marshal.js')]
-    self.do_run_in_out_file_test('embind', 'test_custom_marshal.cpp', assert_identical=True)
+    self.emcc_args += ['--bind', '--pre-js', test_file('embind/test_custom_marshal.js')]
+    self.do_run_in_out_file_test('embind/test_custom_marshal.cpp', assert_identical=True)
 
   def test_embind_float_constants(self):
     self.emcc_args += ['--bind']
-    self.do_run_in_out_file_test('embind', 'test_float_constants.cpp')
+    self.do_run_in_out_file_test('embind/test_float_constants.cpp')
 
   def test_embind_negative_constants(self):
     self.emcc_args += ['--bind']
-    self.do_run_in_out_file_test('embind', 'test_negative_constants.cpp')
+    self.do_run_in_out_file_test('embind/test_negative_constants.cpp')
 
   @also_with_wasm_bigint
   def test_embind_unsigned(self):
     self.emcc_args += ['--bind']
-    self.do_run_in_out_file_test('embind', 'test_unsigned.cpp')
+    self.do_run_in_out_file_test('embind/test_unsigned.cpp')
 
   def test_embind_val(self):
     self.emcc_args += ['--bind']
-    self.do_run_in_out_file_test('embind', 'test_val.cpp')
+    self.do_run_in_out_file_test('embind/test_val.cpp')
 
   @no_wasm2js('wasm_bigint')
   def test_embind_i64_val(self):
     self.set_setting('WASM_BIGINT')
     self.emcc_args += ['--bind']
     self.node_args += ['--experimental-wasm-bigint']
-    self.do_run_in_out_file_test('embind', 'test_i64_val.cpp', assert_identical=True)
+    self.do_run_in_out_file_test('embind/test_i64_val.cpp', assert_identical=True)
 
   @no_wasm2js('wasm_bigint')
   def test_embind_i64_binding(self):
     self.set_setting('WASM_BIGINT')
     self.emcc_args += ['--bind']
     self.node_args += ['--experimental-wasm-bigint']
-    self.do_run_in_out_file_test('embind', 'test_i64_binding.cpp', assert_identical=True)
+    self.do_run_in_out_file_test('embind/test_i64_binding.cpp', assert_identical=True)
 
   def test_embind_no_rtti(self):
     create_file('main.cpp', r'''
@@ -7025,7 +7026,7 @@ def test_webidl(self, mode, allow_memory_growth):
 
     # Force IDL checks mode
     with env_modify({'IDL_CHECKS': mode}):
-      self.run_process([WEBIDL_BINDER, test_file('webidl', 'test.idl'), 'glue'])
+      self.run_process([WEBIDL_BINDER, test_file('webidl/test.idl'), 'glue'])
     self.assertExists('glue.cpp')
     self.assertExists('glue.js')
 
@@ -7047,11 +7048,11 @@ def post(filename):
           f.write("var isMemoryGrowthAllowed = true;")
         else:
           f.write("var isMemoryGrowthAllowed = false;")
-        f.write(open(test_file('webidl', 'post.js')).read())
+        f.write(open(test_file('webidl/post.js')).read())
         f.write('\n\n')
 
-    output = test_file('webidl', "output_%s.txt" % mode)
-    self.do_run_from_file(test_file('webidl', 'test.cpp'), output, post_build=post)
+    output = test_file('webidl/output_%s.txt' % mode)
+    self.do_run_from_file(test_file('webidl/test.cpp'), output, post_build=post)
 
   ### Tests for tools
 
@@ -7226,7 +7227,7 @@ def get_dwarf_addr(line, col):
     self.assertLess(get_dwarf_addr(6, 9), get_dwarf_addr(7, 9))
 
     # Get the wat, printing with -g which has binary offsets
-    wat = self.run_process([os.path.join(building.get_binaryen_bin(), 'wasm-opt'),
+    wat = self.run_process([Path(building.get_binaryen_bin(), 'wasm-opt'),
                            wasm_filename, '-g', '--print'], stdout=PIPE).stdout
 
     # We expect to see a pattern like this in optimized builds (there isn't
@@ -7291,7 +7292,7 @@ def test_modularize_closure_pre(self):
     # test that the combination of modularize + closure + pre-js works. in that mode,
     # closure should not minify the Module object in a way that the pre-js cannot use it.
     self.emcc_args += [
-      '--pre-js', test_file('core', 'modularize_closure_pre.js'),
+      '--pre-js', test_file('core/modularize_closure_pre.js'),
       '--closure=1',
       '-g1',
       '-s',
@@ -7312,11 +7313,11 @@ def test_emscripten_log(self):
     if '-g' not in self.emcc_args:
       self.emcc_args.append('-g')
     self.emcc_args += ['-DRUN_FROM_JS_SHELL']
-    self.do_run_in_out_file_test('emscripten_log', 'emscripten_log.cpp')
+    self.do_run_in_out_file_test('emscripten_log/emscripten_log.cpp')
     # test closure compiler as well
     print('closure')
     self.emcc_args += ['--closure=1', '-g1'] # extra testing
-    self.do_run_in_out_file_test('emscripten_log', 'emscripten_log_with_closure.cpp')
+    self.do_run_in_out_file_test('emscripten_log/emscripten_log_with_closure.cpp')
 
   def test_float_literals(self):
     self.do_run_in_out_file_test('test_float_literals.cpp')
@@ -7377,13 +7378,13 @@ def test_minmax(self):
     self.do_runf(test_file('test_minmax.c'), 'NAN != NAN\nSuccess!')
 
   def test_localeconv(self):
-    self.do_run_in_out_file_test('core', 'test_localeconv.c')
+    self.do_run_in_out_file_test('core/test_localeconv.c')
 
   def test_newlocale(self):
-    self.do_run_in_out_file_test('core', 'test_newlocale.c')
+    self.do_run_in_out_file_test('core/test_newlocale.c')
 
   def test_setlocale(self):
-    self.do_run_in_out_file_test('core', 'test_setlocale.c')
+    self.do_run_in_out_file_test('core/test_setlocale.c')
 
   def test_vswprintf_utf8(self):
     self.do_run_in_out_file_test('vswprintf_utf8.c')
@@ -7589,7 +7590,7 @@ def test_emscripten_lazy_load_code(self, conditional):
 
     # attempts to "break" the wasm by adding an unreachable in $foo_end. returns whether we found it.
     def break_wasm(name):
-      wat = self.run_process([os.path.join(building.get_binaryen_bin(), 'wasm-dis'), name], stdout=PIPE).stdout
+      wat = self.run_process([Path(building.get_binaryen_bin(), 'wasm-dis'), name], stdout=PIPE).stdout
       lines = wat.splitlines()
       wat = None
       for i in range(len(lines)):
@@ -7608,7 +7609,7 @@ def break_wasm(name):
       with open('wat.wat', 'w') as f:
         f.write(wat)
       shutil.move(name, name + '.orig')
-      self.run_process([os.path.join(building.get_binaryen_bin(), 'wasm-as'), 'wat.wat', '-o', name, '-g'])
+      self.run_process([Path(building.get_binaryen_bin(), 'wasm-as'), 'wat.wat', '-o', name, '-g'])
       return True
 
     def verify_working(args=['0']):
@@ -7875,7 +7876,7 @@ def test_postrun_exception(self):
     # verify that an exception thrown in postRun() will not trigger the
     # compilation failed handler, and will be printed to stderr.
     self.add_post_run('ThisFunctionDoesNotExist()')
-    self.build(test_file('core', 'test_hello_world.c'))
+    self.build(test_file('core/test_hello_world.c'))
     output = self.run_js('test_hello_world.js', assert_returncode=NON_ZERO)
     self.assertStartswith(output, 'hello, world!')
     self.assertContained('ThisFunctionDoesNotExist is not defined', output)
@@ -7959,7 +7960,7 @@ def test_minimal_runtime_global_initializer(self):
   @no_wasm2js('wasm2js does not support PROXY_TO_PTHREAD (custom section support)')
   def test_return_address(self):
     self.set_setting('USE_OFFSET_CONVERTER')
-    self.do_runf(test_file('core', 'test_return_address.c'), 'passed')
+    self.do_runf(test_file('core/test_return_address.c'), 'passed')
 
   @no_wasm2js('TODO: sanitizers in wasm2js')
   @no_asan('-fsanitize-minimal-runtime cannot be used with ASan')
@@ -7970,7 +7971,7 @@ def test_ubsan_minimal_too_many_errors(self):
         self.skipTest('test can only be run without optimizations on asm.js')
       # Need to use `-g` to get proper line numbers in asm.js
       self.emcc_args += ['-g']
-    self.do_runf(test_file('core', 'test_ubsan_minimal_too_many_errors.c'),
+    self.do_runf(test_file('core/test_ubsan_minimal_too_many_errors.c'),
                  expected_output='ubsan: add-overflow\n' * 20 + 'ubsan: too many errors\n')
 
   @no_wasm2js('TODO: sanitizers in wasm2js')
@@ -7982,7 +7983,7 @@ def test_ubsan_minimal_errors_same_place(self):
         self.skipTest('test can only be run without optimizations on asm.js')
       # Need to use `-g` to get proper line numbers in asm.js
       self.emcc_args += ['-g']
-    self.do_runf(test_file('core', 'test_ubsan_minimal_errors_same_place.c'),
+    self.do_runf(test_file('core/test_ubsan_minimal_errors_same_place.c'),
                  expected_output='ubsan: add-overflow\n' * 5)
 
   @parameterized({
@@ -7993,7 +7994,7 @@ def test_ubsan_minimal_errors_same_place(self):
   @no_wasm2js('TODO: sanitizers in wasm2js')
   def test_ubsan_full_overflow(self, args):
     self.emcc_args += args
-    self.do_runf(test_file('core', 'test_ubsan_full_overflow.c'),
+    self.do_runf(test_file('core/test_ubsan_full_overflow.c'),
                  assert_all=True, expected_output=[
       ".c:3:5: runtime error: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int'",
       ".c:7:7: runtime error: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int'",
@@ -8006,7 +8007,7 @@ def test_ubsan_full_overflow(self, args):
   @no_wasm2js('TODO: sanitizers in wasm2js')
   def test_ubsan_full_no_return(self, args):
     self.emcc_args += ['-Wno-return-type'] + args
-    self.do_runf(test_file('core', 'test_ubsan_full_no_return.cpp'),
+    self.do_runf(test_file('core/test_ubsan_full_no_return.cpp'),
                  expected_output='.cpp:1:5: runtime error: execution reached the end of a value-returning function without returning a value', assert_returncode=NON_ZERO)
 
   @parameterized({
@@ -8017,7 +8018,7 @@ def test_ubsan_full_no_return(self, args):
   @no_wasm2js('TODO: sanitizers in wasm2js')
   def test_ubsan_full_left_shift(self, args):
     self.emcc_args += args
-    self.do_runf(test_file('core', 'test_ubsan_full_left_shift.c'),
+    self.do_runf(test_file('core/test_ubsan_full_left_shift.c'),
                  assert_all=True, expected_output=[
       '.c:3:5: runtime error: left shift of negative value -1',
       ".c:7:5: runtime error: left shift of 16 by 29 places cannot be represented in type 'int'"
@@ -8030,7 +8031,7 @@ def test_ubsan_full_left_shift(self, args):
   @no_wasm2js('TODO: sanitizers in wasm2js')
   def test_ubsan_full_null_ref(self, args):
     self.emcc_args += args
-    self.do_runf(test_file('core', 'test_ubsan_full_null_ref.cpp'),
+    self.do_runf(test_file('core/test_ubsan_full_null_ref.cpp'),
                  assert_all=True, expected_output=[
       ".cpp:3:12: runtime error: reference binding to null pointer of type 'int'",
       ".cpp:4:13: runtime error: reference binding to null pointer of type 'int'",
@@ -8044,7 +8045,7 @@ def test_ubsan_full_null_ref(self, args):
   @no_wasm2js('TODO: sanitizers in wasm2js')
   def test_ubsan_full_static_cast(self, args):
     self.emcc_args += args
-    self.do_runf(test_file('core', 'test_ubsan_full_static_cast.cpp'),
+    self.do_runf(test_file('core/test_ubsan_full_static_cast.cpp'),
                  assert_all=True, expected_output=[
       ".cpp:18:10: runtime error: downcast of address",
       "which does not point to an object of type 'R'",
@@ -8079,7 +8080,7 @@ def modify_env(filename):
       with open(filename, 'w') as f:
         f.write(contents)
 
-    self.do_runf(test_file('core', 'test_ubsan_full_null_ref.cpp'),
+    self.do_runf(test_file('core/test_ubsan_full_null_ref.cpp'),
                  post_build=modify_env, assert_all=True, expected_output=expected_output)
 
   @no_wasm2js('TODO: sanitizers in wasm2js')
@@ -8192,7 +8193,7 @@ def test_asan_js_stack_op(self):
     self.emcc_args.append('-fsanitize=address')
     self.set_setting('ALLOW_MEMORY_GROWTH')
     self.set_setting('INITIAL_MEMORY', '300mb')
-    self.do_runf(test_file('core', 'test_asan_js_stack_op.c'),
+    self.do_runf(test_file('core/test_asan_js_stack_op.c'),
                  expected_output='Hello, World!')
 
   @no_safe_heap('asan does not work with SAFE_HEAP')
@@ -8226,19 +8227,19 @@ def post(filename):
   @no_asan('SAFE_HEAP cannot be used with ASan')
   def test_safe_heap_user_js(self):
     self.set_setting('SAFE_HEAP')
-    self.do_runf(test_file('core', 'test_safe_heap_user_js.c'),
+    self.do_runf(test_file('core/test_safe_heap_user_js.c'),
                  expected_output=['abort(segmentation fault storing 1 bytes to address 0)'], assert_returncode=NON_ZERO)
 
   def test_safe_stack(self):
     self.set_setting('STACK_OVERFLOW_CHECK', 2)
     self.set_setting('TOTAL_STACK', 65536)
-    self.do_runf(test_file('core', 'test_safe_stack.c'),
+    self.do_runf(test_file('core/test_safe_stack.c'),
                  expected_output=['abort(stack overflow)', '__handle_stack_overflow'], assert_returncode=NON_ZERO)
 
   def test_safe_stack_alloca(self):
     self.set_setting('STACK_OVERFLOW_CHECK', 2)
     self.set_setting('TOTAL_STACK', 65536)
-    self.do_runf(test_file('core', 'test_safe_stack_alloca.c'),
+    self.do_runf(test_file('core/test_safe_stack_alloca.c'),
                  expected_output=['abort(stack overflow)', '__handle_stack_overflow'], assert_returncode=NON_ZERO)
 
   @needs_dylink
@@ -8276,7 +8277,7 @@ def test_fpic_static(self):
   @node_pthreads
   def test_pthread_create(self):
     self.set_setting('EXIT_RUNTIME')
-    self.do_run_in_out_file_test('core', 'pthread', 'create.cpp')
+    self.do_run_in_out_file_test('core/pthread/create.cpp')
 
   @node_pthreads
   def test_pthread_c11_threads(self):
@@ -8284,56 +8285,56 @@ def test_pthread_c11_threads(self):
     self.set_setting('EXIT_RUNTIME')
     if not self.has_changed_setting('INITIAL_MEMORY'):
       self.set_setting('INITIAL_MEMORY', '64mb')
-    self.do_run_in_out_file_test('pthread', 'test_pthread_c11_threads.c')
+    self.do_run_in_out_file_test('pthread/test_pthread_c11_threads.c')
 
   @node_pthreads
   def test_pthread_cxx_threads(self):
     self.set_setting('PROXY_TO_PTHREAD')
     self.clear_setting('ALLOW_MEMORY_GROWTH')
     self.set_setting('EXIT_RUNTIME')
-    self.do_run_in_out_file_test('pthread', 'test_pthread_cxx_threads.cpp')
+    self.do_run_in_out_file_test('pthread/test_pthread_cxx_threads.cpp')
 
   @node_pthreads
   def test_pthread_create_pool(self):
     # with a pool, we can synchronously depend on workers being available
     self.set_setting('PTHREAD_POOL_SIZE', '2')
     self.emcc_args += ['-DALLOW_SYNC']
-    self.do_run_in_out_file_test('core', 'pthread', 'create.cpp')
+    self.do_run_in_out_file_test('core/pthread/create.cpp')
 
   @node_pthreads
   def test_pthread_create_proxy(self):
     # with PROXY_TO_PTHREAD, we can synchronously depend on workers being available
     self.set_setting('PROXY_TO_PTHREAD')
     self.emcc_args += ['-DALLOW_SYNC']
-    self.do_run_in_out_file_test('core', 'pthread', 'create.cpp')
+    self.do_run_in_out_file_test('core/pthread/create.cpp')
 
   @node_pthreads
   def test_pthread_create_embind_stack_check(self):
     # embind should work with stack overflow checks (see #12356)
     self.set_setting('STACK_OVERFLOW_CHECK', 2)
     self.emcc_args += ['--bind']
-    self.do_run_in_out_file_test('core', 'pthread', 'create.cpp')
+    self.do_run_in_out_file_test('core/pthread/create.cpp')
 
   @node_pthreads
   def test_pthread_exceptions(self):
     self.set_setting('PTHREAD_POOL_SIZE', '2')
     self.emcc_args += ['-fexceptions']
-    self.do_run_in_out_file_test('core', 'pthread', 'exceptions.cpp')
+    self.do_run_in_out_file_test('core/pthread/exceptions.cpp')
 
   @node_pthreads
   def test_pthread_exit_process(self):
     self.set_setting('PROXY_TO_PTHREAD')
     self.set_setting('EXIT_RUNTIME')
-    self.emcc_args += ['-DEXIT_RUNTIME', '--pre-js', test_file('core', 'pthread', 'test_pthread_exit_runtime.pre.js')]
-    self.do_run_in_out_file_test('core', 'pthread', 'test_pthread_exit_runtime.c', assert_returncode=42)
+    self.emcc_args += ['-DEXIT_RUNTIME', '--pre-js', test_file('core/pthread/test_pthread_exit_runtime.pre.js')]
+    self.do_run_in_out_file_test('core/pthread/test_pthread_exit_runtime.c', assert_returncode=42)
 
   @node_pthreads
   @disabled('https://github.com/emscripten-core/emscripten/issues/12945')
   def test_pthread_no_exit_process(self):
     # Same as above but without EXIT_RUNTIME
     self.set_setting('PROXY_TO_PTHREAD')
-    self.emcc_args += ['--pre-js', test_file('core', 'pthread', 'test_pthread_exit_runtime.pre.js')]
-    self.do_run_in_out_file_test('core', 'pthread', 'test_pthread_exit_runtime.c', assert_returncode=43)
+    self.emcc_args += ['--pre-js', test_file('core/pthread/test_pthread_exit_runtime.pre.js')]
+    self.do_run_in_out_file_test('core/pthread/test_pthread_exit_runtime.c', assert_returncode=43)
 
   @node_pthreads
   @no_wasm2js('wasm2js does not support PROXY_TO_PTHREAD (custom section support)')
@@ -8341,7 +8342,7 @@ def test_pthread_offset_converter(self):
     self.set_setting('PROXY_TO_PTHREAD')
     self.set_setting('EXIT_RUNTIME')
     self.set_setting('USE_OFFSET_CONVERTER')
-    self.do_runf(test_file('core', 'test_return_address.c'), 'passed')
+    self.do_runf(test_file('core/test_return_address.c'), 'passed')
 
   @node_pthreads
   @no_wasm2js('wasm2js does not support PROXY_TO_PTHREAD (custom section support)')
@@ -8352,22 +8353,22 @@ def test_pthread_offset_converter_modularize(self):
     self.set_setting('MODULARIZE')
     create_file('post.js', 'var m = require("./test_return_address.js"); m();')
     self.emcc_args += ['--extern-post-js', 'post.js', '-s', 'EXPORT_NAME=foo']
-    self.do_runf(test_file('core', 'test_return_address.c'), 'passed')
+    self.do_runf(test_file('core/test_return_address.c'), 'passed')
 
   def test_emscripten_atomics_stub(self):
-    self.do_run_in_out_file_test('core', 'pthread', 'emscripten_atomics.c')
+    self.do_run_in_out_file_test('core/pthread/emscripten_atomics.c')
 
   @no_asan('incompatibility with atomics')
   @node_pthreads
   def test_emscripten_atomics(self):
     self.set_setting('USE_PTHREADS')
-    self.do_run_in_out_file_test('core', 'pthread', 'emscripten_atomics.c')
+    self.do_run_in_out_file_test('core/pthread/emscripten_atomics.c')
 
   @no_asan('incompatibility with atomics')
   @node_pthreads
   def test_emscripten_futexes(self):
     self.set_setting('USE_PTHREADS')
-    self.do_run_in_out_file_test('core', 'pthread', 'emscripten_futexes.c')
+    self.do_run_in_out_file_test('core/pthread/emscripten_futexes.c')
 
   @needs_dylink
   @node_pthreads
@@ -8385,8 +8386,8 @@ def test_pthread_dylink(self):
     self.set_setting('USE_PTHREADS')
     self.set_setting('LLD_REPORT_UNDEFINED')
     self.set_setting('PTHREAD_POOL_SIZE=2')
-    main = test_file('core', 'pthread', 'test_pthread_dylink.c')
-    side = test_file('core', 'pthread', 'test_pthread_dylink_side.c')
+    main = test_file('core/pthread/test_pthread_dylink.c')
+    side = test_file('core/pthread/test_pthread_dylink_side.c')
     self.dylink_testf(main, side, "success", need_reverse=False)
 
   @needs_dylink
@@ -8396,8 +8397,8 @@ def test_pthread_dylink_tls(self):
     self.set_setting('EXIT_RUNTIME')
     self.set_setting('USE_PTHREADS')
     self.set_setting('PTHREAD_POOL_SIZE=1')
-    main = test_file('core', 'pthread', 'test_pthread_dylink_tls.c')
-    side = test_file('core', 'pthread', 'test_pthread_dylink_tls_side.c')
+    main = test_file('core/pthread/test_pthread_dylink_tls.c')
+    side = test_file('core/pthread/test_pthread_dylink_tls_side.c')
     self.dylink_testf(main, side, need_reverse=False)
 
   @needs_dylink
@@ -8459,7 +8460,7 @@ def test_undefined_main(self):
     if self.get_setting('STANDALONE_WASM'):
       # In standalone we don't support implicitly building without main.  The user has to explicitly
       # opt out (see below).
-      err = self.expect_fail([EMCC, test_file('core', 'test_ctors_no_main.cpp')] + self.get_emcc_args())
+      err = self.expect_fail([EMCC, test_file('core/test_ctors_no_main.cpp')] + self.get_emcc_args())
       self.assertContained('error: undefined symbol: main (referenced by top-level compiled C/C++ code)', err)
       self.assertContained('warning: To build in STANDALONE_WASM mode without a main(), use emcc --no-entry', err)
     elif not self.get_setting('LLD_REPORT_UNDEFINED') and not self.get_setting('STRICT'):
@@ -8471,7 +8472,7 @@ def test_undefined_main(self):
 
       # Disabling IGNORE_MISSING_MAIN should cause link to fail due to missing main
       self.set_setting('IGNORE_MISSING_MAIN', 0)
-      err = self.expect_fail([EMCC, test_file('core', 'test_ctors_no_main.cpp')] + self.get_emcc_args())
+      err = self.expect_fail([EMCC, test_file('core/test_ctors_no_main.cpp')] + self.get_emcc_args())
       self.assertContained('error: entry symbol not defined (pass --no-entry to suppress): main', err)
 
       # In non-standalone mode exporting an empty list of functions signal that we don't
@@ -8488,7 +8489,7 @@ def test_undefined_main_explict(self):
   def test_undefined_main_wasm_output(self):
     if not can_do_standalone(self):
       self.skipTest('standalone mode only')
-    err = self.expect_fail([EMCC, '-o', 'out.wasm', test_file('core', 'test_ctors_no_main.cpp')] + self.get_emcc_args())
+    err = self.expect_fail([EMCC, '-o', 'out.wasm', test_file('core/test_ctors_no_main.cpp')] + self.get_emcc_args())
     self.assertContained('undefined symbol: main', err)
 
   def test_export_start(self):
@@ -8511,7 +8512,7 @@ def test_emscripten_math(self):
   # the -jsDfoo=val syntax:
   # See https://github.com/emscripten-core/emscripten/issues/10580.
   def test_custom_js_options(self):
-    self.emcc_args += ['--js-library', test_file('core', 'test_custom_js_settings.js'), '-jsDCUSTOM_JS_OPTION=1']
+    self.emcc_args += ['--js-library', test_file('core/test_custom_js_settings.js'), '-jsDCUSTOM_JS_OPTION=1']
     self.do_core_test('test_custom_js_settings.c')
 
     self.assertContained('cannot change built-in settings values with a -jsD directive', self.expect_fail([EMCC, '-jsDWASM=0']))
@@ -8526,19 +8527,19 @@ def test_emscripten_stack(self):
   def test_abort_on_exceptions(self):
     self.set_setting('ABORT_ON_WASM_EXCEPTIONS')
     self.set_setting('EXPORTED_RUNTIME_METHODS', ['ccall', 'cwrap'])
-    self.emcc_args += ['--bind', '--post-js', test_file('core', 'test_abort_on_exception_post.js')]
+    self.emcc_args += ['--bind', '--post-js', test_file('core/test_abort_on_exception_post.js')]
     self.do_core_test('test_abort_on_exception.cpp')
 
   @needs_dylink
   def test_gl_main_module(self):
     self.set_setting('MAIN_MODULE')
-    self.do_runf(test_file('core', 'test_gl_get_proc_address.c'))
+    self.do_runf(test_file('core/test_gl_get_proc_address.c'))
 
   @needs_dylink
   def test_main_module_js_symbol(self):
     self.set_setting('MAIN_MODULE', 2)
-    self.emcc_args += ['--js-library', test_file('core', 'test_main_module_js_symbol.js')]
-    self.do_runf(test_file('core', 'test_main_module_js_symbol.c'))
+    self.emcc_args += ['--js-library', test_file('core/test_main_module_js_symbol.js')]
+    self.do_runf(test_file('core/test_main_module_js_symbol.c'))
 
   def test_REVERSE_DEPS(self):
     create_file('connect.c', '#include <sys/socket.h>\nint main() { return (int)&connect; }')
diff --git a/tests/test_other.py b/tests/test_other.py
index a86371ace71d5..7ceb8b34d5619 100644
--- a/tests/test_other.py
+++ b/tests/test_other.py
@@ -23,6 +23,7 @@
 import tempfile
 import unittest
 import uuid
+from pathlib import Path
 from subprocess import PIPE, STDOUT
 
 if __name__ == '__main__':
@@ -45,8 +46,8 @@
 emmake = shared.bat_suffix(path_from_root('emmake'))
 emconfig = shared.bat_suffix(path_from_root('em-config'))
 emsize = shared.bat_suffix(path_from_root('emsize'))
-wasm_dis = os.path.join(building.get_binaryen_bin(), 'wasm-dis')
-wasm_opt = os.path.join(building.get_binaryen_bin(), 'wasm-opt')
+wasm_dis = Path(building.get_binaryen_bin(), 'wasm-dis')
+wasm_opt = Path(building.get_binaryen_bin(), 'wasm-opt')
 
 EMTEST_REBASELINE = int(os.getenv('EMTEST_REBASELINE', '0'))
 
@@ -294,12 +295,12 @@ def test_emcc_3(self, compiler, suffix):
     self.assertContained('hello, world!', self.run_js('a.out.js'))
 
     # emcc [..] -o [path] ==> should work with absolute paths
-    for path in [os.path.abspath(os.path.join('..', 'file1.js')), os.path.join('b_dir', 'file2.js')]:
+    for path in [os.path.abspath(Path('../file1.js')), Path('b_dir/file2.js')]:
       print(path)
       os.chdir(self.get_dir())
       self.clear()
       print(os.listdir(os.getcwd()))
-      ensure_dir(os.path.join('a_dir', 'b_dir'))
+      ensure_dir(Path('a_dir/b_dir'))
       os.chdir('a_dir')
       # use single file so we don't have more files to clean up
       self.run_process([compiler, test_file('hello_world' + suffix), '-o', path, '-s', 'SINGLE_FILE'])
@@ -536,9 +537,9 @@ def test_em_config_missing_arg(self):
   def test_emsize(self):
     # test binaryen generated by running:
     #   emcc tests/hello_world.c -Oz --closure 1 -o tests/other/test_emsize.js
-    with open(test_file('other', 'test_emsize.out')) as expected_output:
+    with open(test_file('other/test_emsize.out')) as expected_output:
       expected = expected_output.read()
-    cmd = [emsize, test_file('other', 'test_emsize.js')]
+    cmd = [emsize, test_file('other/test_emsize.js')]
     for command in [cmd, cmd + ['-format=sysv']]:
       output = self.run_process(cmd, stdout=PIPE).stdout
       self.assertContained(expected, output)
@@ -607,12 +608,12 @@ def test_cmake(self, test_dir, output_file, cmake_args):
   @no_windows('Skipped on Windows because CMake does not configure native Clang builds well on Windows.')
   def test_cmake_compile_features(self):
     with temp_directory(self.get_dir()):
-      cmd = ['cmake', '-DCMAKE_C_COMPILER=' + CLANG_CC, '-DCMAKE_CXX_COMPILER=' + CLANG_CXX, test_file('cmake', 'stdproperty')]
+      cmd = ['cmake', '-DCMAKE_C_COMPILER=' + CLANG_CC, '-DCMAKE_CXX_COMPILER=' + CLANG_CXX, test_file('cmake/stdproperty')]
       print(str(cmd))
       native_features = self.run_process(cmd, stdout=PIPE).stdout
 
     with temp_directory(self.get_dir()):
-      cmd = [EMCMAKE, 'cmake', test_file('cmake', 'stdproperty')]
+      cmd = [EMCMAKE, 'cmake', test_file('cmake/stdproperty')]
       print(str(cmd))
       emscripten_features = self.run_process(cmd, stdout=PIPE).stdout
 
@@ -628,7 +629,7 @@ def test_cmake_with_embind_cpp11_mode(self):
     for args in [[], ['-DNO_GNU_EXTENSIONS=1']]:
       self.clear()
       # Use ninja generator here since we assume its always installed on our build/test machines.
-      configure = [EMCMAKE, 'cmake', test_file('cmake', 'cmake_with_emval')] + args
+      configure = [EMCMAKE, 'cmake', test_file('cmake/cmake_with_emval')] + args
       if WINDOWS:
         configure += ['-G', 'Ninja']
       print(str(configure))
@@ -646,12 +647,12 @@ def test_cmake_with_embind_cpp11_mode(self):
   # Tests that the Emscripten CMake toolchain option
   def test_cmake_bitcode_static_libraries(self):
     # Test that this option produces an error
-    err = self.expect_fail([EMCMAKE, 'cmake', test_file('cmake', 'static_lib'), '-DEMSCRIPTEN_GENERATE_BITCODE_STATIC_LIBRARIES=ON'])
+    err = self.expect_fail([EMCMAKE, 'cmake', test_file('cmake/static_lib'), '-DEMSCRIPTEN_GENERATE_BITCODE_STATIC_LIBRARIES=ON'])
     self.assertContained('EMSCRIPTEN_GENERATE_BITCODE_STATIC_LIBRARIES is not compatible with the', err)
 
   # Tests that the CMake variable EMSCRIPTEN_VERSION is properly provided to user CMake scripts
   def test_cmake_emscripten_version(self):
-    self.run_process([EMCMAKE, 'cmake', test_file('cmake', 'emscripten_version')])
+    self.run_process([EMCMAKE, 'cmake', test_file('cmake/emscripten_version')])
 
   def test_system_include_paths(self):
     # Verify that all default include paths are within `emscripten/system`
@@ -964,8 +965,8 @@ def test(compiler, main_name, lib_args, err_expected):
   def test_whole_archive(self):
     # Verify that -Wl,--whole-archive includes the static constructor from the
     # otherwise unreferenced library.
-    self.run_process([EMCC, '-c', '-o', 'main.o', test_file('test_whole_archive', 'main.c')])
-    self.run_process([EMCC, '-c', '-o', 'testlib.o', test_file('test_whole_archive', 'testlib.c')])
+    self.run_process([EMCC, '-c', '-o', 'main.o', test_file('test_whole_archive/main.c')])
+    self.run_process([EMCC, '-c', '-o', 'testlib.o', test_file('test_whole_archive/testlib.c')])
     self.run_process([EMAR, 'crs', 'libtest.a', 'testlib.o'])
 
     self.run_process([EMCC, '-Wl,--whole-archive', 'libtest.a', '-Wl,--no-whole-archive', 'main.o'])
@@ -1108,10 +1109,10 @@ def run_test():
           os.system('cat in.txt | {} > out.txt'.format(cmd))
         self.assertContained('abcdef\nghijkl\neof', open('out.txt').read())
 
-    self.emcc(test_file('module', 'test_stdin.c'), output_filename='out.js')
+    self.emcc(test_file('module/test_stdin.c'), output_filename='out.js')
     create_file('in.txt', 'abcdef\nghijkl')
     run_test()
-    self.emcc(test_file('module', 'test_stdin.c'),
+    self.emcc(test_file('module/test_stdin.c'),
               ['-O2', '--closure=1'], output_filename='out.js')
     run_test()
 
@@ -1170,7 +1171,7 @@ def test_local_link(self):
     ''')
 
     ensure_dir('subdir')
-    open(os.path.join('subdir', 'libfile.so'), 'w').write('this is not llvm bitcode!')
+    create_file('subdir/libfile.so', 'this is not llvm bitcode!')
 
     create_file('libfile.cpp', '''
       #include <stdio.h>
@@ -1180,7 +1181,7 @@ def test_local_link(self):
     ''')
 
     self.run_process([EMXX, 'libfile.cpp', '-shared', '-o', 'libfile.so'], stderr=PIPE)
-    self.run_process([EMXX, 'main.cpp', os.path.join('subdir', 'libfile.so'), '-L.'])
+    self.run_process([EMXX, 'main.cpp', Path('subdir/libfile.so'), '-L.'])
     self.assertContained('hello from lib', self.run_js('a.out.js'))
 
   def test_identical_basenames(self):
@@ -1188,26 +1189,26 @@ def test_identical_basenames(self):
     # causing multiply defined symbol errors
     ensure_dir('foo')
     ensure_dir('bar')
-    open(os.path.join('foo', 'main.cpp'), 'w').write('''
+    create_file('foo/main.cpp', '''
       extern void printey();
       int main() {
         printey();
         return 0;
       }
     ''')
-    open(os.path.join('bar', 'main.cpp'), 'w').write('''
+    create_file('bar/main.cpp', '''
       #include <stdio.h>
       void printey() { printf("hello there\\n"); }
     ''')
 
-    self.run_process([EMXX, os.path.join('foo', 'main.cpp'), os.path.join('bar', 'main.cpp')])
+    self.run_process([EMXX, Path('foo/main.cpp'), Path('bar/main.cpp')])
     self.assertContained('hello there', self.run_js('a.out.js'))
 
     # ditto with first creating .o files
     try_delete('a.out.js')
-    self.run_process([EMXX, '-c', os.path.join('foo', 'main.cpp'), '-o', os.path.join('foo', 'main.o')])
-    self.run_process([EMXX, '-c', os.path.join('bar', 'main.cpp'), '-o', os.path.join('bar', 'main.o')])
-    self.run_process([EMCC, os.path.join('foo', 'main.o'), os.path.join('bar', 'main.o')])
+    self.run_process([EMXX, '-c', Path('foo/main.cpp'), '-o', Path('foo/main.o')])
+    self.run_process([EMXX, '-c', Path('bar/main.cpp'), '-o', Path('bar/main.o')])
+    self.run_process([EMCC, Path('foo/main.o'), Path('bar/main.o')])
     self.assertContained('hello there', self.run_js('a.out.js'))
 
   def test_main_a(self):
@@ -1273,25 +1274,25 @@ def test_multiple_archives_duplicate_basenames(self):
 
   def test_archive_duplicate_basenames(self):
     ensure_dir('a')
-    create_file(os.path.join('a', 'common.c'), r'''
+    create_file('a/common.c', r'''
       #include <stdio.h>
       void a(void) {
         printf("a\n");
       }
     ''')
-    self.run_process([EMCC, os.path.join('a', 'common.c'), '-c', '-o', os.path.join('a', 'common.o')])
+    self.run_process([EMCC, Path('a/common.c'), '-c', '-o', Path('a/common.o')])
 
     ensure_dir('b')
-    create_file(os.path.join('b', 'common.c'), r'''
+    create_file('b/common.c', r'''
       #include <stdio.h>
       void b(void) {
         printf("b...\n");
       }
     ''')
-    self.run_process([EMCC, os.path.join('b', 'common.c'), '-c', '-o', os.path.join('b', 'common.o')])
+    self.run_process([EMCC, Path('b/common.c'), '-c', '-o', Path('b/common.o')])
 
     try_delete('liba.a')
-    self.run_process([EMAR, 'rc', 'liba.a', os.path.join('a', 'common.o'), os.path.join('b', 'common.o')])
+    self.run_process([EMAR, 'rc', 'liba.a', Path('a/common.o'), Path('b/common.o')])
 
     # Verify that archive contains basenames with hashes to avoid duplication
     text = self.run_process([EMAR, 't', 'liba.a'], stdout=PIPE).stdout
@@ -1314,7 +1315,7 @@ def test_archive_duplicate_basenames(self):
 
     # Using llvm-ar directly should cause duplicate basenames
     try_delete('libdup.a')
-    self.run_process([LLVM_AR, 'rc', 'libdup.a', os.path.join('a', 'common.o'), os.path.join('b', 'common.o')])
+    self.run_process([LLVM_AR, 'rc', 'libdup.a', Path('a/common.o'), Path('b/common.o')])
     text = self.run_process([EMAR, 't', 'libdup.a'], stdout=PIPE).stdout
     self.assertEqual(text.count('common.o'), 2)
 
@@ -1495,14 +1496,14 @@ def test(link_flags, lib_suffix):
         }
       ''')
 
-      create_file(os.path.join('libdir', 'libfile.cpp'), '''
+      create_file('libdir/libfile.cpp', '''
         #include <stdio.h>
         void printey() {
           printf("hello from lib");
         }
       ''')
 
-      create_file(os.path.join('libdir', 'libother.cpp'), '''
+      create_file('libdir/libother.cpp', '''
         #include <stdio.h>
         extern void printey();
         void printother() {
@@ -1513,9 +1514,9 @@ def test(link_flags, lib_suffix):
       ''')
 
       # Build libfile normally into an .so
-      self.run_process([EMXX, os.path.join('libdir', 'libfile.cpp'), '-shared', '-o', os.path.join('libdir', 'libfile.so' + lib_suffix)])
+      self.run_process([EMXX, Path('libdir/libfile.cpp'), '-shared', '-o', Path('libdir/libfile.so' + lib_suffix)])
       # Build libother and dynamically link it to libfile
-      self.run_process([EMXX, '-Llibdir', os.path.join('libdir', 'libother.cpp')] + link_flags + ['-shared', '-o', os.path.join('libdir', 'libother.so')])
+      self.run_process([EMXX, '-Llibdir', Path('libdir/libother.cpp')] + link_flags + ['-shared', '-o', Path('libdir/libother.so')])
       # Build the main file, linking in both the libs
       self.run_process([EMXX, '-Llibdir', os.path.join('main.cpp')] + link_flags + ['-lother', '-c'])
       print('...')
@@ -1614,14 +1615,14 @@ def test_sdl2_mixer_wav(self):
     self.emcc(test_file('sdl2_mixer_wav.c'), ['-s', 'USE_SDL_MIXER=2'], output_filename='a.out.js')
 
   def test_libpng(self):
-    shutil.copyfile(test_file('third_party', 'libpng', 'pngtest.png'), 'pngtest.png')
-    self.emcc(test_file('third_party', 'libpng', 'pngtest.c'), ['--embed-file', 'pngtest.png', '-s', 'USE_LIBPNG'], output_filename='a.out.js')
+    shutil.copyfile(test_file('third_party/libpng/pngtest.png'), 'pngtest.png')
+    self.emcc(test_file('third_party/libpng/pngtest.c'), ['--embed-file', 'pngtest.png', '-s', 'USE_LIBPNG'], output_filename='a.out.js')
     output = self.run_js('a.out.js')
     self.assertContained('libpng passes test', output)
 
   def test_giflib(self):
-    shutil.copyfile(test_file('third_party', 'giflib', 'treescap.gif'), 'treescap.gif')
-    self.emcc(test_file('third_party', 'giflib', 'giftext.c'), ['--embed-file', 'treescap.gif', '-s', 'USE_GIFLIB'], output_filename='a.out.js')
+    shutil.copyfile(test_file('third_party/giflib/treescap.gif'), 'treescap.gif')
+    self.emcc(test_file('third_party/giflib/giftext.c'), ['--embed-file', 'treescap.gif', '-s', 'USE_GIFLIB'], output_filename='a.out.js')
     self.assertContained('GIF file terminated normally', self.run_js('a.out.js', args=['treescap.gif']))
 
   def test_libjpeg(self):
@@ -1645,7 +1646,7 @@ def test_bzip2(self):
   def test_freetype(self):
     # copy the Liberation Sans Bold truetype file located in the
     # <emscripten_root>/tests/freetype to the compilation folder
-    shutil.copy2(test_file('freetype', 'LiberationSansBold.ttf'), os.getcwd())
+    shutil.copy2(test_file('freetype/LiberationSansBold.ttf'), os.getcwd())
     # build test program with the font file embed in it
     self.emcc(test_file('freetype_test.c'), ['-s', 'USE_FREETYPE', '--embed-file', 'LiberationSansBold.ttf'], output_filename='a.out.js')
     # the test program will print an ascii representation of a bitmap where the
@@ -1905,53 +1906,53 @@ def test_extern_prepost(self):
 
   def test_js_optimizer(self):
     for input, expected, passes in [
-      (test_file('optimizer', 'test-js-optimizer-minifyGlobals.js'), open(test_file('optimizer', 'test-js-optimizer-minifyGlobals-output.js')).read(),
+      (test_file('optimizer/test-js-optimizer-minifyGlobals.js'), open(test_file('optimizer/test-js-optimizer-minifyGlobals-output.js')).read(),
        ['minifyGlobals']),
-      (test_file('optimizer', 'test-js-optimizer-minifyLocals.js'), open(test_file('optimizer', 'test-js-optimizer-minifyLocals-output.js')).read(),
+      (test_file('optimizer/test-js-optimizer-minifyLocals.js'), open(test_file('optimizer/test-js-optimizer-minifyLocals-output.js')).read(),
        ['minifyLocals']),
-      (test_file('optimizer', 'JSDCE.js'), open(test_file('optimizer', 'JSDCE-output.js')).read(),
+      (test_file('optimizer/JSDCE.js'), open(test_file('optimizer/JSDCE-output.js')).read(),
        ['JSDCE']),
-      (test_file('optimizer', 'JSDCE-hasOwnProperty.js'), open(test_file('optimizer', 'JSDCE-hasOwnProperty-output.js')).read(),
+      (test_file('optimizer/JSDCE-hasOwnProperty.js'), open(test_file('optimizer/JSDCE-hasOwnProperty-output.js')).read(),
        ['JSDCE']),
-      (test_file('optimizer', 'JSDCE-fors.js'), open(test_file('optimizer', 'JSDCE-fors-output.js')).read(),
+      (test_file('optimizer/JSDCE-fors.js'), open(test_file('optimizer/JSDCE-fors-output.js')).read(),
        ['JSDCE']),
-      (test_file('optimizer', 'AJSDCE.js'), open(test_file('optimizer', 'AJSDCE-output.js')).read(),
+      (test_file('optimizer/AJSDCE.js'), open(test_file('optimizer/AJSDCE-output.js')).read(),
        ['AJSDCE']),
-      (test_file('optimizer', 'emitDCEGraph.js'), open(test_file('optimizer', 'emitDCEGraph-output.js')).read(),
+      (test_file('optimizer/emitDCEGraph.js'), open(test_file('optimizer/emitDCEGraph-output.js')).read(),
        ['emitDCEGraph', 'noPrint']),
-      (test_file('optimizer', 'emitDCEGraph2.js'), open(test_file('optimizer', 'emitDCEGraph2-output.js')).read(),
+      (test_file('optimizer/emitDCEGraph2.js'), open(test_file('optimizer/emitDCEGraph2-output.js')).read(),
        ['emitDCEGraph', 'noPrint']),
-      (test_file('optimizer', 'emitDCEGraph3.js'), open(test_file('optimizer', 'emitDCEGraph3-output.js')).read(),
+      (test_file('optimizer/emitDCEGraph3.js'), open(test_file('optimizer/emitDCEGraph3-output.js')).read(),
        ['emitDCEGraph', 'noPrint']),
-      (test_file('optimizer', 'emitDCEGraph4.js'), open(test_file('optimizer', 'emitDCEGraph4-output.js')).read(),
+      (test_file('optimizer/emitDCEGraph4.js'), open(test_file('optimizer/emitDCEGraph4-output.js')).read(),
        ['emitDCEGraph', 'noPrint']),
-      (test_file('optimizer', 'emitDCEGraph5.js'), open(test_file('optimizer', 'emitDCEGraph5-output.js')).read(),
+      (test_file('optimizer/emitDCEGraph5.js'), open(test_file('optimizer/emitDCEGraph5-output.js')).read(),
        ['emitDCEGraph', 'noPrint']),
-      (test_file('optimizer', 'minimal-runtime-applyDCEGraphRemovals.js'), open(test_file('optimizer', 'minimal-runtime-applyDCEGraphRemovals-output.js')).read(),
+      (test_file('optimizer/minimal-runtime-applyDCEGraphRemovals.js'), open(test_file('optimizer/minimal-runtime-applyDCEGraphRemovals-output.js')).read(),
        ['applyDCEGraphRemovals']),
-      (test_file('optimizer', 'applyDCEGraphRemovals.js'), open(test_file('optimizer', 'applyDCEGraphRemovals-output.js')).read(),
+      (test_file('optimizer/applyDCEGraphRemovals.js'), open(test_file('optimizer/applyDCEGraphRemovals-output.js')).read(),
        ['applyDCEGraphRemovals']),
-      (test_file('optimizer', 'applyImportAndExportNameChanges.js'), open(test_file('optimizer', 'applyImportAndExportNameChanges-output.js')).read(),
+      (test_file('optimizer/applyImportAndExportNameChanges.js'), open(test_file('optimizer/applyImportAndExportNameChanges-output.js')).read(),
        ['applyImportAndExportNameChanges']),
-      (test_file('optimizer', 'applyImportAndExportNameChanges2.js'), open(test_file('optimizer', 'applyImportAndExportNameChanges2-output.js')).read(),
+      (test_file('optimizer/applyImportAndExportNameChanges2.js'), open(test_file('optimizer/applyImportAndExportNameChanges2-output.js')).read(),
        ['applyImportAndExportNameChanges']),
-      (test_file('optimizer', 'minimal-runtime-emitDCEGraph.js'), open(test_file('optimizer', 'minimal-runtime-emitDCEGraph-output.js')).read(),
+      (test_file('optimizer/minimal-runtime-emitDCEGraph.js'), open(test_file('optimizer/minimal-runtime-emitDCEGraph-output.js')).read(),
        ['emitDCEGraph', 'noPrint']),
-      (test_file('optimizer', 'minimal-runtime-2-emitDCEGraph.js'), open(test_file('optimizer', 'minimal-runtime-2-emitDCEGraph-output.js')).read(),
+      (test_file('optimizer/minimal-runtime-2-emitDCEGraph.js'), open(test_file('optimizer/minimal-runtime-2-emitDCEGraph-output.js')).read(),
        ['emitDCEGraph', 'noPrint']),
-      (test_file('optimizer', 'standalone-emitDCEGraph.js'), open(test_file('optimizer', 'standalone-emitDCEGraph-output.js')).read(),
+      (test_file('optimizer/standalone-emitDCEGraph.js'), open(test_file('optimizer/standalone-emitDCEGraph-output.js')).read(),
        ['emitDCEGraph', 'noPrint']),
-      (test_file('optimizer', 'emittedJSPreservesParens.js'), open(test_file('optimizer', 'emittedJSPreservesParens-output.js')).read(),
+      (test_file('optimizer/emittedJSPreservesParens.js'), open(test_file('optimizer/emittedJSPreservesParens-output.js')).read(),
        []),
-      (test_file('optimizer', 'test-growableHeap.js'), open(test_file('optimizer', 'test-growableHeap-output.js')).read(),
+      (test_file('optimizer/test-growableHeap.js'), open(test_file('optimizer/test-growableHeap-output.js')).read(),
        ['growableHeap']),
-      (test_file('optimizer', 'test-unsignPointers.js'), open(test_file('optimizer', 'test-unsignPointers-output.js')).read(),
+      (test_file('optimizer/test-unsignPointers.js'), open(test_file('optimizer/test-unsignPointers-output.js')).read(),
        ['unsignPointers']),
-      (test_file('optimizer', 'test-asanify.js'), open(test_file('optimizer', 'test-asanify-output.js')).read(),
+      (test_file('optimizer/test-asanify.js'), open(test_file('optimizer/test-asanify-output.js')).read(),
        ['asanify']),
-      (test_file('optimizer', 'test-safeHeap.js'), open(test_file('optimizer', 'test-safeHeap-output.js')).read(),
+      (test_file('optimizer/test-safeHeap.js'), open(test_file('optimizer/test-safeHeap-output.js')).read(),
        ['safeHeap']),
-      (test_file('optimizer', 'test-LittleEndianHeap.js'), open(test_file('optimizer', 'test-LittleEndianHeap-output.js')).read(),
+      (test_file('optimizer/test-LittleEndianHeap.js'), open(test_file('optimizer/test-LittleEndianHeap-output.js')).read(),
        ['littleEndianHeap']),
     ]:
       print(input, passes)
@@ -1995,8 +1996,8 @@ def swap(func, stuff):
         self.assertIdentical(expected, js.replace('\r\n', '\n').replace('\n\n', '\n').replace('\n\n', '\n'))
 
       if input not in [ # tests that are native-optimizer only
-        test_file('optimizer', 'asmLastOpts.js'),
-        test_file('optimizer', '3154.js')
+        test_file('optimizer/asmLastOpts.js'),
+        test_file('optimizer/3154.js')
       ]:
         check_js(output, expected)
       else:
@@ -2133,7 +2134,7 @@ def verify(output):
   def test_scons(self):
     # this test copies the site_scons directory alongside the test
     shutil.copytree(test_file('scons'), 'test')
-    shutil.copytree(path_from_root('tools', 'scons', 'site_scons'), os.path.join('test', 'site_scons'))
+    shutil.copytree(path_from_root('tools', 'scons', 'site_scons'), Path('test/site_scons'))
     with utils.chdir('test'):
       self.run_process(['scons'])
       output = self.run_js('scons_integration.js', assert_returncode=5)
@@ -2152,7 +2153,7 @@ def test_emscons(self):
     self.assertContained('If you see this - the world is all right!', output)
 
   def test_embind_fail(self):
-    out = self.expect_fail([EMXX, test_file('embind', 'test_unsigned.cpp')])
+    out = self.expect_fail([EMXX, test_file('embind/test_unsigned.cpp')])
     self.assertContained("undefined symbol: _embind_register_function", out)
 
   def test_embind_asyncify(self):
@@ -2176,12 +2177,12 @@ def test_embind_asyncify(self):
   @is_slow_test
   def test_embind(self):
     environ = os.environ.copy()
-    environ['EMCC_CLOSURE_ARGS'] = environ.get('EMCC_CLOSURE_ARGS', '') + " --externs " + pipes.quote(test_file('embind', 'underscore-externs.js'))
+    environ['EMCC_CLOSURE_ARGS'] = environ.get('EMCC_CLOSURE_ARGS', '') + " --externs " + pipes.quote(test_file('embind/underscore-externs.js'))
     test_cases = [
         (['--bind']),
         (['--bind', '-O1']),
         (['--bind', '-O2']),
-        (['--bind', '-O2', '-s', 'ALLOW_MEMORY_GROWTH', test_file('embind', 'isMemoryGrowthEnabled=true.cpp')]),
+        (['--bind', '-O2', '-s', 'ALLOW_MEMORY_GROWTH', test_file('embind/isMemoryGrowthEnabled=true.cpp')]),
     ]
     without_utf8_args = ['-s', 'EMBIND_STD_STRING_IS_UTF8=0']
     test_cases_without_utf8 = []
@@ -2196,15 +2197,15 @@ def test_embind(self):
       self.clear()
 
       testFiles = [
-        test_file('embind', 'underscore-1.4.2.js'),
-        test_file('embind', 'imvu_test_adapter.js'),
-        test_file('embind', 'embind.test.js'),
+        test_file('embind/underscore-1.4.2.js'),
+        test_file('embind/imvu_test_adapter.js'),
+        test_file('embind/embind.test.js'),
       ]
 
       self.run_process(
-        [EMXX, test_file('embind', 'embind_test.cpp'),
-         '--pre-js', test_file('embind', 'test.pre.js'),
-         '--post-js', test_file('embind', 'test.post.js'),
+        [EMXX, test_file('embind/embind_test.cpp'),
+         '--pre-js', test_file('embind/test.pre.js'),
+         '--post-js', test_file('embind/test.post.js'),
          '-s', 'WASM_ASYNC_COMPILATION=0',
          '-s', 'IN_TEST_HARNESS'] + args,
         env=environ)
@@ -2518,9 +2519,9 @@ def test_module_exports_with_closure(self):
     self.clear()
 
     # compile with -O2 --closure 0
-    self.run_process([EMCC, test_file('Module-exports', 'test.c'),
+    self.run_process([EMCC, test_file('Module-exports/test.c'),
                       '-o', 'test.js', '-O2', '--closure', '0',
-                      '--pre-js', test_file('Module-exports', 'setup.js'),
+                      '--pre-js', test_file('Module-exports/setup.js'),
                       '-s', 'EXPORTED_FUNCTIONS=_bufferTest,_malloc,_free',
                       '-s', 'EXPORTED_RUNTIME_METHODS=ccall,cwrap',
                       '-s', 'WASM_ASYNC_COMPILATION=0'])
@@ -2534,7 +2535,7 @@ def test_module_exports_with_closure(self):
 
     # Check that main.js (which requires test.js) completes successfully when run in node.js
     # in order to check that the exports are indeed functioning correctly.
-    shutil.copyfile(test_file('Module-exports', 'main.js'), 'main.js')
+    shutil.copyfile(test_file('Module-exports/main.js'), 'main.js')
     if config.NODE_JS in config.JS_ENGINES:
       self.assertContained('bufferTest finished', self.run_js('main.js'))
 
@@ -2543,9 +2544,9 @@ def test_module_exports_with_closure(self):
     self.assertNotExists('test.js')
 
     # compile with -O2 --closure 1
-    self.run_process([EMCC, test_file('Module-exports', 'test.c'),
+    self.run_process([EMCC, test_file('Module-exports/test.c'),
                       '-o', 'test.js', '-O2', '--closure=1',
-                      '--pre-js', test_file('Module-exports', 'setup.js'),
+                      '--pre-js', test_file('Module-exports/setup.js'),
                       '-s', 'EXPORTED_FUNCTIONS=_bufferTest,_malloc,_free',
                       '-s', 'EXPORTED_RUNTIME_METHODS=ccall,cwrap',
                       '-s', 'WASM_ASYNC_COMPILATION=0'])
@@ -5126,7 +5127,7 @@ def test_emmake_python(self):
     # simulates a configure/make script that looks for things like CC, AR, etc., and which we should
     # not confuse by setting those vars to something containing `python X` as the script checks for
     # the existence of an executable.
-    self.run_process([emmake, PYTHON, test_file('emmake', 'make.py')])
+    self.run_process([emmake, PYTHON, test_file('emmake/make.py')])
 
   def test_sdl2_config(self):
     for args, expected in [
@@ -5998,7 +5999,7 @@ def test_realpath(self):
 }
 ''')
     ensure_dir('boot')
-    create_file(os.path.join('boot', 'README.txt'), ' ')
+    create_file('boot/README.txt', ' ')
     self.run_process([EMCC, 'src.c', '-s', 'SAFE_HEAP', '--embed-file', 'boot'])
     self.assertContained('Resolved: /boot/README.txt', self.run_js('a.out.js'))
 
@@ -6068,7 +6069,7 @@ def test_realpath_2(self):
 }
 ''')
     create_file('testfile.txt', '')
-    create_file(os.path.join('Folder', 'testfile.txt'), '')
+    create_file('Folder/testfile.txt', '')
     self.run_process([EMCC, 'src.c', '--embed-file', 'testfile.txt', '--embed-file', 'Folder'])
     self.assertContained('''Resolved: "testfile.txt" => "/testfile.txt"
 Resolved: "Folder/testfile.txt" => "/Folder/testfile.txt"
@@ -6180,10 +6181,10 @@ def test_sixtyfour_bit_return_value(self, args, bind_js):
     # The MS 32 bits should be available in Runtime.getTempRet0() even when compiled with -O2 --closure 1
 
     # Compile test.c and wrap it in a native JavaScript binding so we can call our compiled function from JS.
-    self.run_process([EMCC, test_file('return64bit', 'test.c'),
-                      '--pre-js', test_file('return64bit', 'testbindstart.js'),
+    self.run_process([EMCC, test_file('return64bit/test.c'),
+                      '--pre-js', test_file('return64bit/testbindstart.js'),
                       '--pre-js', test_file('return64bit', bind_js),
-                      '--post-js', test_file('return64bit', 'testbindend.js'),
+                      '--post-js', test_file('return64bit/testbindend.js'),
                       '-s', 'DEFAULT_LIBRARY_FUNCS_TO_INCLUDE=$dynCall',
                       '-s', 'EXPORTED_FUNCTIONS=_test_return64', '-o', 'test.js', '-O2',
                       '--closure=1', '-g1', '-s', 'WASM_ASYNC_COMPILATION=0'] + args)
@@ -6752,7 +6753,7 @@ def test_invalid_mem(self):
     self.assertContained('MAXIMUM_MEMORY must be a multiple of WebAssembly page size (64KiB)', ret)
 
   def test_dasho_invalid_dir(self):
-    ret = self.expect_fail([EMCC, test_file('hello_world.c'), '-o', os.path.join('NONEXISTING_DIRECTORY', 'out.js')])
+    ret = self.expect_fail([EMCC, test_file('hello_world.c'), '-o', Path('NONEXISTING_DIRECTORY/out.js')])
     self.assertContained('specified output file (NONEXISTING_DIRECTORY%sout.js) is in a directory that does not exist' % os.path.sep, ret)
 
   def test_dasho_is_dir(self):
@@ -6869,7 +6870,7 @@ def run_metadce_test(self, filename, args, expected_exists, expected_not_exists,
     # in -Os, -Oz, we remove imports wasm doesn't need
     print('Running metadce test: %s:' % filename, args, expected_exists,
           expected_not_exists, check_sent, check_imports, check_exports, check_funcs)
-    filename = test_file('other', 'metadce', filename)
+    filename = test_file('other/metadce', filename)
 
     def clean_arg(arg):
       return arg.replace('-', '')
@@ -7078,7 +7079,7 @@ def test_legalize_js_ffi(self):
       print(args)
       try_delete('a.out.wasm')
       try_delete('a.out.wat')
-      cmd = [EMCC, test_file('other', 'ffi.c'), '-g', '-o', 'a.out.wasm'] + args
+      cmd = [EMCC, test_file('other/ffi.c'), '-g', '-o', 'a.out.wasm'] + args
       print(' '.join(cmd))
       self.run_process(cmd)
       self.run_process([wasm_dis, 'a.out.wasm', '-o', 'a.out.wat'])
@@ -7124,7 +7125,7 @@ def test_no_legalize_js_ffi(self):
       try_delete('a.out.wasm')
       try_delete('a.out.wat')
       with env_modify({'EMCC_FORCE_STDLIBS': 'libc++'}):
-        cmd = [EMXX, test_file('other', 'noffi.cpp'), '-g', '-o', 'a.out.js'] + args
+        cmd = [EMXX, test_file('other/noffi.cpp'), '-g', '-o', 'a.out.js'] + args
       print(' '.join(cmd))
       self.run_process(cmd)
       self.run_process([wasm_dis, 'a.out.wasm', '-o', 'a.out.wat'])
@@ -7143,13 +7144,13 @@ def test_no_legalize_js_ffi(self):
   def test_export_aliasee(self):
     # build side module
     args = ['-s', 'SIDE_MODULE']
-    cmd = [EMCC, test_file('other', 'alias', 'side.c'), '-g', '-o', 'side.wasm'] + args
+    cmd = [EMCC, test_file('other/alias/side.c'), '-g', '-o', 'side.wasm'] + args
     print(' '.join(cmd))
     self.run_process(cmd)
 
     # build main module
     args = ['-g', '-s', 'EXPORTED_FUNCTIONS=_main,_foo', '-s', 'MAIN_MODULE=2', '-s', 'EXIT_RUNTIME', '-lnodefs.js']
-    cmd = [EMCC, test_file('other', 'alias', 'main.c'), '-o', 'main.js'] + args
+    cmd = [EMCC, test_file('other/alias/main.c'), '-o', 'main.js'] + args
     print(' '.join(cmd))
     self.run_process(cmd)
 
@@ -7158,7 +7159,7 @@ def test_export_aliasee(self):
 
   def test_sysconf_phys_pages(self):
     def run(args, expected):
-      cmd = [EMCC, test_file('unistd', 'sysconf_phys_pages.c')] + args
+      cmd = [EMCC, test_file('unistd/sysconf_phys_pages.c')] + args
       print(str(cmd))
       self.run_process(cmd)
       result = self.run_js('a.out.js').strip()
@@ -7316,7 +7317,7 @@ def test_lto_wasm_exceptions(self):
     self.emcc_args += ['-fwasm-exceptions', '-flto']
     self.v8_args.append('--experimental-wasm-eh')
     self.js_engines = [config.V8_ENGINE]
-    self.do_run_from_file(test_file('core', 'test_exceptions.cpp'), test_file('core', 'test_exceptions_caught.out'))
+    self.do_run_from_file(test_file('core/test_exceptions.cpp'), test_file('core/test_exceptions_caught.out'))
 
   def test_wasm_nope(self):
     for opts in [[], ['-O2']]:
@@ -7609,7 +7610,7 @@ def test_toolchain_profiler(self):
       self.run_process([EMCC, test_file('hello_world.c')])
 
   def test_noderawfs(self):
-    fopen_write = open(test_file('asmfs', 'fopen_write.cpp')).read()
+    fopen_write = open(test_file('asmfs/fopen_write.cpp')).read()
     create_file('main.cpp', fopen_write)
     self.run_process([EMXX, 'main.cpp', '-s', 'NODERAWFS'])
     self.assertContained("read 11 bytes. Result: Hello data!", self.run_js('a.out.js'))
@@ -7832,14 +7833,14 @@ def test_check_sourcemapurl_default(self, *args):
 
   def test_wasm_sourcemap(self):
     # The no_main.c will be read (from relative location) due to speficied "-s"
-    shutil.copyfile(test_file('other', 'wasm_sourcemap', 'no_main.c'), 'no_main.c')
+    shutil.copyfile(test_file('other/wasm_sourcemap/no_main.c'), 'no_main.c')
     wasm_map_cmd = [PYTHON, path_from_root('tools', 'wasm-sourcemap.py'),
                     '--sources', '--prefix', '=wasm-src://',
                     '--load-prefix', '/emscripten/tests/other/wasm_sourcemap=.',
                     '--dwarfdump-output',
-                    test_file('other', 'wasm_sourcemap', 'foo.wasm.dump'),
+                    test_file('other/wasm_sourcemap/foo.wasm.dump'),
                     '-o', 'a.out.wasm.map',
-                    test_file('other', 'wasm_sourcemap', 'foo.wasm'),
+                    test_file('other/wasm_sourcemap/foo.wasm'),
                     '--basepath=' + os.getcwd()]
     self.run_process(wasm_map_cmd)
     output = open('a.out.wasm.map').read()
@@ -7853,9 +7854,9 @@ def test_wasm_sourcemap(self):
   def test_wasm_sourcemap_dead(self):
     wasm_map_cmd = [PYTHON, path_from_root('tools', 'wasm-sourcemap.py'),
                     '--dwarfdump-output',
-                    test_file('other', 'wasm_sourcemap_dead', 't.wasm.dump'),
+                    test_file('other/wasm_sourcemap_dead/t.wasm.dump'),
                     '-o', 'a.out.wasm.map',
-                    test_file('other', 'wasm_sourcemap_dead', 't.wasm'),
+                    test_file('other/wasm_sourcemap_dead/t.wasm'),
                     '--basepath=' + os.getcwd()]
     self.run_process(wasm_map_cmd, stdout=PIPE, stderr=PIPE)
     output = open('a.out.wasm.map').read()
@@ -7904,8 +7905,8 @@ def test_separate_dwarf(self):
     os.mkdir('subdir')
     self.run_process([EMCC, test_file('hello_world.c'),
                       '-gseparate-dwarf',
-                      '-o', os.path.join('subdir', 'output.js')])
-    with open(os.path.join('subdir', 'output.wasm'), 'rb') as f:
+                      '-o', Path('subdir/output.js')])
+    with open(Path('subdir/output.wasm'), 'rb') as f:
       wasm = f.read()
       self.assertIn(b'output.wasm.debug.wasm', wasm)
       # check both unix-style slashes and the system's slashes, so that we don't
@@ -7926,10 +7927,10 @@ def test_separate_dwarf_with_filename(self):
     # should leave a relative path to the debug wasm
     os.mkdir('subdir')
     self.run_process([EMCC, test_file('hello_world.c'),
-                      '-o', os.path.join('subdir', 'output.js'),
+                      '-o', Path('subdir/output.js'),
                       '-gseparate-dwarf=with_dwarf2.wasm'])
     self.assertExists('with_dwarf2.wasm')
-    with open(os.path.join('subdir', 'output.wasm'), 'rb') as f:
+    with open(Path('subdir/output.wasm'), 'rb') as f:
       wasm = f.read()
       self.assertIn(b'../with_dwarf2.wasm', wasm)
 
@@ -7992,9 +7993,9 @@ def test_js_preprocess(self):
     self.assertEqual(err.count('JSLIB'), 1)
 
   def test_html_preprocess(self):
-    src_file = test_file('module', 'test_stdin.c')
+    src_file = test_file('module/test_stdin.c')
     output_file = 'test_stdin.html'
-    shell_file = test_file('module', 'test_html_preprocess.html')
+    shell_file = test_file('module/test_html_preprocess.html')
 
     self.run_process([EMCC, '-o', output_file, src_file, '--shell-file', shell_file, '-s', 'ASSERTIONS=0'], stdout=PIPE, stderr=PIPE)
     output = open(output_file).read()
@@ -8050,8 +8051,8 @@ def test_html_preprocess(self):
   # Tests that Emscripten-compiled applications can be run from a relative path with node command line that is different than the current working directory.
   def test_node_js_run_from_different_directory(self):
     ensure_dir('subdir')
-    self.run_process([EMCC, test_file('hello_world.c'), '-o', os.path.join('subdir', 'a.js'), '-O3'])
-    ret = self.run_process(config.NODE_JS + [os.path.join('subdir', 'a.js')], stdout=PIPE).stdout
+    self.run_process([EMCC, test_file('hello_world.c'), '-o', Path('subdir/a.js'), '-O3'])
+    ret = self.run_process(config.NODE_JS + [Path('subdir/a.js')], stdout=PIPE).stdout
     self.assertContained('hello, world!', ret)
 
   # Tests that a pthreads + modularize build can be run in node js
@@ -8069,7 +8070,7 @@ def test_node_js_pthread_module(self):
     create_file(os.path.join('subdir', moduleLoader), moduleLoaderContents)
 
     # build hello_world.c
-    self.run_process([EMCC, test_file('hello_world.c'), '-o', os.path.join('subdir', 'module.js'), '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'MODULARIZE', '-s', 'EXPORT_NAME=test_module', '-s', 'ENVIRONMENT=worker,node'])
+    self.run_process([EMCC, test_file('hello_world.c'), '-o', Path('subdir/module.js'), '-s', 'USE_PTHREADS', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'MODULARIZE', '-s', 'EXPORT_NAME=test_module', '-s', 'ENVIRONMENT=worker,node'])
 
     # run the module
     ret = self.run_process(config.NODE_JS + ['--experimental-wasm-threads'] + [os.path.join('subdir', moduleLoader)], stdout=PIPE).stdout
@@ -8177,7 +8178,7 @@ def test_asyncify_response_file(self):
         proc.stderr)
 
   def test_asyncify_advise(self):
-    src = test_file('other', 'asyncify_advise.c')
+    src = test_file('other/asyncify_advise.c')
 
     self.set_setting('ASYNCIFY')
     self.set_setting('ASYNCIFY_ADVISE')
@@ -8396,22 +8397,22 @@ def test_getpeername_unconnected_socket(self):
     ''', 'getpeername error: Socket not connected', assert_returncode=NON_ZERO)
 
   def test_getsockname_addrlen(self):
-    self.do_runf(test_file('sockets', 'test_getsockname_addrlen.c'), 'success')
+    self.do_runf(test_file('sockets/test_getsockname_addrlen.c'), 'success')
 
   def test_sin_zero(self):
-    self.do_runf(test_file('sockets', 'test_sin_zero.c'), 'success')
+    self.do_runf(test_file('sockets/test_sin_zero.c'), 'success')
 
   def test_getaddrinfo(self):
-    self.do_runf(test_file('sockets', 'test_getaddrinfo.c'), 'success')
+    self.do_runf(test_file('sockets/test_getaddrinfo.c'), 'success')
 
   def test_getnameinfo(self):
-    self.do_runf(test_file('sockets', 'test_getnameinfo.c'), 'success')
+    self.do_runf(test_file('sockets/test_getnameinfo.c'), 'success')
 
   def test_gethostbyname(self):
-    self.do_runf(test_file('sockets', 'test_gethostbyname.c'), 'success')
+    self.do_runf(test_file('sockets/test_gethostbyname.c'), 'success')
 
   def test_getprotobyname(self):
-    self.do_runf(test_file('sockets', 'test_getprotobyname.c'), 'success')
+    self.do_runf(test_file('sockets/test_getprotobyname.c'), 'success')
 
   def test_socketpair(self):
     self.do_run(r'''
@@ -8622,9 +8623,9 @@ def test_minimal_runtime_code_size(self, test_name, js, compare_js_output=False)
     random_printf_sources = [test_file('hello_random_printf.c'),
                              '-s', 'USES_DYNAMIC_ALLOC=0',
                              '-s', 'SINGLE_FILE']
-    hello_webgl_sources = [test_file('minimal_webgl', 'main.cpp'),
-                           test_file('minimal_webgl', 'webgl.c'),
-                           '--js-library', test_file('minimal_webgl', 'library_js.js'),
+    hello_webgl_sources = [test_file('minimal_webgl/main.cpp'),
+                           test_file('minimal_webgl/webgl.c'),
+                           '--js-library', test_file('minimal_webgl/library_js.js'),
                            '-s', 'USES_DYNAMIC_ALLOC', '-lwebgl.js',
                            '-s', 'MODULARIZE']
     hello_webgl2_sources = hello_webgl_sources + ['-s', 'MAX_WEBGL_VERSION=2']
@@ -8775,10 +8776,10 @@ def test_legacy_settings_forbidden_to_change(self):
     self.run_process([EMCC, '-s', 'PRECISE_I64_MATH=2', test_file('hello_world.c')])
 
   def test_jsmath(self):
-    self.run_process([EMXX, test_file('other', 'jsmath.cpp'), '-Os', '-o', 'normal.js', '--closure', '0'])
+    self.run_process([EMXX, test_file('other/jsmath.cpp'), '-Os', '-o', 'normal.js', '--closure', '0'])
     normal_js_size = os.path.getsize('normal.js')
     normal_wasm_size = os.path.getsize('normal.wasm')
-    self.run_process([EMXX, test_file('other', 'jsmath.cpp'), '-Os', '-o', 'jsmath.js', '-s', 'JS_MATH', '--closure', '0'])
+    self.run_process([EMXX, test_file('other/jsmath.cpp'), '-Os', '-o', 'jsmath.js', '-s', 'JS_MATH', '--closure', '0'])
     jsmath_js_size = os.path.getsize('jsmath.js')
     jsmath_wasm_size = os.path.getsize('jsmath.wasm')
     # js math increases JS size, but decreases wasm, and wins overall
@@ -8978,7 +8979,7 @@ def test_malloc_none(self):
     'cpp': ['cpp'],
   })
   def test_lsan_leaks(self, ext):
-    self.do_smart_test(test_file('other', 'test_lsan_leaks.' + ext),
+    self.do_smart_test(test_file('other/test_lsan_leaks.' + ext),
                        emcc_args=['-fsanitize=leak', '-s', 'ALLOW_MEMORY_GROWTH'],
                        assert_returncode=NON_ZERO, literals=[
       'Direct leak of 2048 byte(s) in 1 object(s) allocated from',
@@ -9003,7 +9004,7 @@ def test_lsan_leaks(self, ext):
     ]],
   })
   def test_lsan_stack_trace(self, ext, regexes):
-    self.do_smart_test(test_file('other', 'test_lsan_leaks.' + ext),
+    self.do_smart_test(test_file('other/test_lsan_leaks.' + ext),
                        emcc_args=['-fsanitize=leak', '-s', 'ALLOW_MEMORY_GROWTH', '-gsource-map'],
                        assert_returncode=NON_ZERO, literals=[
       'Direct leak of 2048 byte(s) in 1 object(s) allocated from',
@@ -9016,12 +9017,12 @@ def test_lsan_stack_trace(self, ext, regexes):
     'cpp': ['cpp'],
   })
   def test_lsan_no_leak(self, ext):
-    self.do_smart_test(test_file('other', 'test_lsan_no_leak.' + ext),
+    self.do_smart_test(test_file('other/test_lsan_no_leak.' + ext),
                        emcc_args=['-fsanitize=leak', '-s', 'ALLOW_MEMORY_GROWTH', '-s', 'ASSERTIONS=0'],
                        regexes=[r'^\s*$'])
 
   def test_lsan_no_stack_trace(self):
-    self.do_smart_test(test_file('other', 'test_lsan_leaks.c'),
+    self.do_smart_test(test_file('other/test_lsan_leaks.c'),
                        emcc_args=['-fsanitize=leak', '-s', 'ALLOW_MEMORY_GROWTH', '-DDISABLE_CONTEXT'],
                        assert_returncode=NON_ZERO, literals=[
       'Direct leak of 3427 byte(s) in 3 object(s) allocated from:',
@@ -9029,14 +9030,14 @@ def test_lsan_no_stack_trace(self):
     ])
 
   def test_asan_null_deref(self):
-    self.do_smart_test(test_file('other', 'test_asan_null_deref.c'),
+    self.do_smart_test(test_file('other/test_asan_null_deref.c'),
                        emcc_args=['-fsanitize=address', '-sALLOW_MEMORY_GROWTH=1', '-sINITIAL_MEMORY=314572800'],
                        assert_returncode=NON_ZERO, literals=[
       'AddressSanitizer: null-pointer-dereference on address',
     ])
 
   def test_asan_no_stack_trace(self):
-    self.do_smart_test(test_file('other', 'test_lsan_leaks.c'),
+    self.do_smart_test(test_file('other/test_lsan_leaks.c'),
                        emcc_args=['-fsanitize=address', '-sALLOW_MEMORY_GROWTH=1',  '-sINITIAL_MEMORY=314572800', '-DDISABLE_CONTEXT', '-s', 'EXIT_RUNTIME'],
                        assert_returncode=NON_ZERO, literals=[
       'Direct leak of 3427 byte(s) in 3 object(s) allocated from:',
@@ -9044,13 +9045,13 @@ def test_asan_no_stack_trace(self):
     ])
 
   def test_asan_pthread_stubs(self):
-    self.do_smart_test(test_file('other', 'test_asan_pthread_stubs.c'), emcc_args=['-fsanitize=address', '-sALLOW_MEMORY_GROWTH=1', '-sINITIAL_MEMORY=314572800'])
+    self.do_smart_test(test_file('other/test_asan_pthread_stubs.c'), emcc_args=['-fsanitize=address', '-sALLOW_MEMORY_GROWTH=1', '-sINITIAL_MEMORY=314572800'])
 
   @node_pthreads
   def test_proxy_to_pthread_stack(self):
     # Check that the proxied main gets run with TOTAL_STACK setting and not
     # DEFAULT_PTHREAD_STACK_SIZE.
-    self.do_smart_test(test_file('other', 'test_proxy_to_pthread_stack.c'),
+    self.do_smart_test(test_file('other/test_proxy_to_pthread_stack.c'),
                        ['success'],
                        emcc_args=['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD', '-s', 'DEFAULT_PTHREAD_STACK_SIZE=64kb', '-s', 'TOTAL_STACK=128kb'])
 
@@ -9059,7 +9060,7 @@ def test_proxy_to_pthread_stack(self):
     'sync': ['-s', 'WASM_ASYNC_COMPILATION=0'],
   })
   def test_offset_converter(self, *args):
-    self.do_smart_test(test_file('other', 'test_offset_converter.c'),
+    self.do_smart_test(test_file('other/test_offset_converter.c'),
                        emcc_args=['-s', 'USE_OFFSET_CONVERTER', '-gsource-map'] + list(args), literals=['ok'])
 
   @no_windows('ptys and select are not available on windows')
@@ -9189,7 +9190,7 @@ def test_EMSCRIPTEN_and_STRICT(self):
 
   def test_exception_settings(self):
     for catching, throwing, opts in itertools.product([0, 1], repeat=3):
-      cmd = [EMXX, test_file('other', 'exceptions_modes_symbols_defined.cpp'), '-s', 'DISABLE_EXCEPTION_THROWING=%d' % (1 - throwing), '-s', 'DISABLE_EXCEPTION_CATCHING=%d' % (1 - catching), '-O%d' % opts]
+      cmd = [EMXX, test_file('other/exceptions_modes_symbols_defined.cpp'), '-s', 'DISABLE_EXCEPTION_THROWING=%d' % (1 - throwing), '-s', 'DISABLE_EXCEPTION_CATCHING=%d' % (1 - catching), '-O%d' % opts]
       print(cmd)
       if not throwing and not catching:
         self.assertContained('DISABLE_EXCEPTION_THROWING was set (likely due to -fno-exceptions), which means no C++ exception throwing support code is linked in, but such support is required', self.expect_fail(cmd))
@@ -9201,11 +9202,11 @@ def test_exception_settings(self):
   def test_fignore_exceptions(self):
     # the new clang flag -fignore-exceptions basically is the same as -s DISABLE_EXCEPTION_CATCHING=1,
     # that is, it allows throwing, but emits no support code for catching.
-    self.run_process([EMXX, test_file('other', 'exceptions_modes_symbols_defined.cpp'), '-s', 'DISABLE_EXCEPTION_CATCHING=0'])
+    self.run_process([EMXX, test_file('other/exceptions_modes_symbols_defined.cpp'), '-s', 'DISABLE_EXCEPTION_CATCHING=0'])
     enable_size = os.path.getsize('a.out.wasm')
-    self.run_process([EMXX, test_file('other', 'exceptions_modes_symbols_defined.cpp'), '-s', 'DISABLE_EXCEPTION_CATCHING'])
+    self.run_process([EMXX, test_file('other/exceptions_modes_symbols_defined.cpp'), '-s', 'DISABLE_EXCEPTION_CATCHING'])
     disable_size = os.path.getsize('a.out.wasm')
-    self.run_process([EMXX, test_file('other', 'exceptions_modes_symbols_defined.cpp'), '-s', '-fignore-exceptions'])
+    self.run_process([EMXX, test_file('other/exceptions_modes_symbols_defined.cpp'), '-s', '-fignore-exceptions'])
     ignore_size = os.path.getsize('a.out.wasm')
     self.assertGreater(enable_size, disable_size)
     self.assertEqual(disable_size, ignore_size)
@@ -9452,7 +9453,7 @@ def test_empty_output_extension(self):
   def test_backwards_deps_in_archive(self):
     # Test that JS dependencies from deps_info.json work for code linked via
     # static archives using -l<name>
-    self.run_process([EMCC, '-c', test_file('sockets', 'test_gethostbyname.c'), '-o', 'a.o'])
+    self.run_process([EMCC, '-c', test_file('sockets/test_gethostbyname.c'), '-o', 'a.o'])
     self.run_process([LLVM_AR, 'cr', 'liba.a', 'a.o'])
     create_file('empty.c', 'static int foo = 0;')
     self.run_process([EMCC, 'empty.c', '-la', '-L.'])
@@ -9625,8 +9626,8 @@ def test_errno_type(self):
     self.run_process([EMCC, 'errno_type.c'])
 
   def test_standalone_syscalls(self):
-    self.run_process([EMXX, test_file('other', 'test_standalone_syscalls.cpp'), '-o', 'test.wasm'])
-    with open(test_file('other', 'test_standalone_syscalls.out')) as f:
+    self.run_process([EMXX, test_file('other/test_standalone_syscalls.cpp'), '-o', 'test.wasm'])
+    with open(test_file('other/test_standalone_syscalls.out')) as f:
       expected = f.read()
     for engine in config.WASM_ENGINES:
       self.assertContained(expected, self.run_js('test.wasm', engine))
@@ -9639,17 +9640,17 @@ def test_wasm2c_reactor(self):
 
     # first compile the library with emcc, getting a .c and .h
     self.run_process([EMCC,
-                      test_file('other', 'wasm2c', 'unsafe-library.c'),
+                      test_file('other/wasm2c/unsafe-library.c'),
                       '-O3', '-o', 'lib.wasm', '-s', 'WASM2C', '--no-entry'])
     # compile the main program natively normally, together with the unsafe
     # library
     self.run_process([CLANG_CC,
-                      test_file('other', 'wasm2c', 'my-code.c'),
+                      test_file('other/wasm2c/my-code.c'),
                       'lib.wasm.c', '-O3', '-o', 'program.exe'] +
                      clang_native.get_clang_native_args(),
                      env=clang_native.get_clang_native_env())
     output = self.run_process([os.path.abspath('program.exe')], stdout=PIPE).stdout
-    with open(test_file('other', 'wasm2c', 'output.txt')) as f:
+    with open(test_file('other/wasm2c/output.txt')) as f:
       self.assertEqual(output, f.read())
 
   @requires_native_clang
@@ -9657,7 +9658,7 @@ def test_wasm2c_multi_lib(self):
     # compile two libraries to object files
     for lib in ['a', 'b']:
       self.run_process([EMCC,
-                        test_file('other', 'wasm2c', f'unsafe-library-{lib}.c'),
+                        test_file('other/wasm2c', f'unsafe-library-{lib}.c'),
                         '-O3', '-o', f'lib{lib}.wasm', '-s', 'WASM2C', '--no-entry'])
       # build with a different WASM_RT_MODULE_PREFIX for each library, so that
       # they do not have colliding symbols
@@ -9668,13 +9669,13 @@ def test_wasm2c_multi_lib(self):
 
     # compile the main program with the wasmboxed libraries
     self.run_process([CLANG_CC,
-                      test_file('other', 'wasm2c', 'my-code-multi.c'),
+                      test_file('other/wasm2c/my-code-multi.c'),
                       'liba.wasm.o', 'libb.wasm.o',
                       '-O3', '-o', 'program.exe'] +
                      clang_native.get_clang_native_args(),
                      env=clang_native.get_clang_native_env())
     output = self.run_process([os.path.abspath('program.exe')], stdout=PIPE).stdout
-    with open(test_file('other', 'wasm2c', 'output-multi.txt')) as f:
+    with open(test_file('other/wasm2c/output-multi.txt')) as f:
       self.assertEqual(output, f.read())
 
   @parameterized({
@@ -9750,15 +9751,15 @@ def test_bitcode_input(self):
 
   def test_nostdlib(self):
     # First ensure all the system libs are built
-    self.run_process([EMCC, test_file('unistd', 'close.c')])
+    self.run_process([EMCC, test_file('unistd/close.c')])
 
-    self.assertContained('undefined symbol:', self.expect_fail([EMCC, test_file('unistd', 'close.c'), '-nostdlib']))
-    self.assertContained('undefined symbol:', self.expect_fail([EMCC, test_file('unistd', 'close.c'), '-nodefaultlibs']))
+    self.assertContained('undefined symbol:', self.expect_fail([EMCC, test_file('unistd/close.c'), '-nostdlib']))
+    self.assertContained('undefined symbol:', self.expect_fail([EMCC, test_file('unistd/close.c'), '-nodefaultlibs']))
 
     # Build again but with explit system libraries
     libs = ['-lc', '-lcompiler_rt', '-lc_rt_wasm']
-    self.run_process([EMCC, test_file('unistd', 'close.c'), '-nostdlib'] + libs)
-    self.run_process([EMCC, test_file('unistd', 'close.c'), '-nodefaultlibs'] + libs)
+    self.run_process([EMCC, test_file('unistd/close.c'), '-nostdlib'] + libs)
+    self.run_process([EMCC, test_file('unistd/close.c'), '-nodefaultlibs'] + libs)
 
   def test_argument_match(self):
     # Verify that emcc arguments match precisely.  We had a bug where only the prefix
@@ -9804,8 +9805,8 @@ def test_default_to_cxx(self):
   })
   def test_support_errno(self, args):
     self.emcc_args += args
-    src = test_file('core', 'test_support_errno.c')
-    output = test_file('core', 'test_support_errno.out')
+    src = test_file('core/test_support_errno.c')
+    output = test_file('core/test_support_errno.out')
 
     self.do_run_from_file(src, output)
     size_default = os.path.getsize('test_support_errno.js')
@@ -9813,18 +9814,18 @@ def test_support_errno(self, args):
     # Run the same test again but with SUPPORT_ERRNO disabled.  This time we don't expect errno
     # to be set after the failing syscall.
     self.emcc_args += ['-s', 'SUPPORT_ERRNO=0']
-    output = test_file('core', 'test_support_errno_disabled.out')
+    output = test_file('core/test_support_errno_disabled.out')
     self.do_run_from_file(src, output)
 
     # Verify the JS output was smaller
     self.assertLess(os.path.getsize('test_support_errno.js'), size_default)
 
   def test_assembly(self):
-    self.run_process([EMCC, '-c', test_file('other', 'test_asm.s'), '-o', 'foo.o'])
+    self.run_process([EMCC, '-c', test_file('other/test_asm.s'), '-o', 'foo.o'])
     self.do_other_test('test_asm.c', libraries=['foo.o'])
 
   def test_assembly_preprocessed(self):
-    self.run_process([EMCC, '-c', test_file('other', 'test_asm_cpp.S'), '-o', 'foo.o'])
+    self.run_process([EMCC, '-c', test_file('other/test_asm_cpp.S'), '-o', 'foo.o'])
     self.do_other_test('test_asm.c', libraries=['foo.o'])
 
   @parameterized({
@@ -9941,7 +9942,7 @@ def test_standalone_export_main(self):
     # Tests that explicitly exported `_main` does not fail, even though `_start` is the entry
     # point.
     # We should consider making this a warning since the `_main` export is redundant.
-    self.run_process([EMCC, '-sEXPORTED_FUNCTIONS=_main', '-sSTANDALONE_WASM', test_file('core', 'test_hello_world.c')])
+    self.run_process([EMCC, '-sEXPORTED_FUNCTIONS=_main', '-sSTANDALONE_WASM', test_file('core/test_hello_world.c')])
 
   def test_missing_malloc_export(self):
     # we used to include malloc by default. show a clear error in builds with
@@ -9987,11 +9988,11 @@ def test_missing_malloc_export_indirect(self):
     self.do_runf('unincluded_malloc.c', 'malloc was not included, but is needed in allocateUTF8. Adding "_malloc" to EXPORTED_FUNCTIONS should fix that. This may be a bug in the compiler, please file an issue.')
 
   def test_getrusage(self):
-    self.do_runf(test_file('other', 'test_getrusage.c'))
+    self.do_runf(test_file('other/test_getrusage.c'))
 
   @with_env_modify({'EMMAKEN_COMPILER': shared.CLANG_CC})
   def test_emmaken_compiler(self):
-    stderr = self.run_process([EMCC, '-c', test_file('core', 'test_hello_world.c')], stderr=PIPE).stderr
+    stderr = self.run_process([EMCC, '-c', test_file('core/test_hello_world.c')], stderr=PIPE).stderr
     self.assertContained('warning: `EMMAKEN_COMPILER` is deprecated', stderr)
 
   @no_windows('relies on a shell script')
@@ -10003,11 +10004,11 @@ def test_compiler_wrapper(self):
     ''')
     make_executable('wrapper.sh')
     with env_modify({'EM_COMPILER_WRAPPER': './wrapper.sh'}):
-      stdout = self.run_process([EMCC, '-c', test_file('core', 'test_hello_world.c')], stdout=PIPE).stdout
+      stdout = self.run_process([EMCC, '-c', test_file('core/test_hello_world.c')], stdout=PIPE).stdout
     self.assertContained('wrapping compiler call: ', stdout)
     self.assertExists('test_hello_world.o')
 
-    stdout = self.run_process([EMCC, '-c', test_file('core', 'test_hello_world.c'), '--compiler-wrapper=./wrapper.sh'], stdout=PIPE).stdout
+    stdout = self.run_process([EMCC, '-c', test_file('core/test_hello_world.c'), '--compiler-wrapper=./wrapper.sh'], stdout=PIPE).stdout
     self.assertContained('wrapping compiler call: ', stdout)
     self.assertExists('test_hello_world.o')
 
@@ -10040,13 +10041,13 @@ def test_LIBRARY_DEBUG(self):
     self.do_runf(test_file('hello_world.c'), '[library call:_fd_write: 0x1')
 
   def test_SUPPORT_LONGJMP_executable(self):
-    stderr = self.run_process([EMCC, test_file('core', 'test_longjmp.c'), '-s', 'SUPPORT_LONGJMP=0'], stderr=PIPE, check=False).stderr
+    stderr = self.run_process([EMCC, test_file('core/test_longjmp.c'), '-s', 'SUPPORT_LONGJMP=0'], stderr=PIPE, check=False).stderr
     self.assertContained('error: longjmp support was disabled (SUPPORT_LONGJMP=0), but it is required by the code (either set SUPPORT_LONGJMP=1, or remove uses of it in the project)',
                          stderr)
 
   def test_SUPPORT_LONGJMP_object(self):
     # compile the object *with* support, but link without
-    self.run_process([EMCC, test_file('core', 'test_longjmp.c'), '-c', '-s', 'SUPPORT_LONGJMP', '-o', 'a.o'])
+    self.run_process([EMCC, test_file('core/test_longjmp.c'), '-c', '-s', 'SUPPORT_LONGJMP', '-o', 'a.o'])
     stderr = self.run_process([EMCC, 'a.o', '-s', 'SUPPORT_LONGJMP=0'], stderr=PIPE, check=False).stderr
     self.assertContained('error: longjmp support was disabled (SUPPORT_LONGJMP=0), but it is required by the code (either set SUPPORT_LONGJMP=1, or remove uses of it in the project)',
                          stderr)
@@ -10186,7 +10187,7 @@ def test_syslog(self):
   def test_split_module(self):
     self.set_setting('SPLIT_MODULE')
     self.emcc_args += ['-g', '-Wno-experimental']
-    self.emcc_args += ['--post-js', test_file('other', 'test_split_module.post.js')]
+    self.emcc_args += ['--post-js', test_file('other/test_split_module.post.js')]
     self.emcc_args += ['-sEXPORTED_FUNCTIONS=_malloc,_free']
     self.do_other_test('test_split_module.c')
     self.assertExists('test_split_module.wasm')
@@ -10206,8 +10207,8 @@ def test_split_module(self):
   def test_split_main_module(self):
     initialTableSize = 17
 
-    side_src = test_file('other', 'lib_hello.c')
-    post_js = test_file('other', 'test_split_module.post.js')
+    side_src = test_file('other/lib_hello.c')
+    post_js = test_file('other/test_split_module.post.js')
 
     self.run_process([EMCC, side_src, '-sSIDE_MODULE=1', '-g', '-o', 'libhello.wasm'])
 
@@ -10434,7 +10435,7 @@ def test_check_undefined(self, flag):
     self.run_js('a.out.js')
 
     # negative case: foo is undefined in test_check_undefined.c
-    err = self.expect_fail([EMCC, flag, '-sERROR_ON_UNDEFINED_SYMBOLS', test_file('other', 'test_check_undefined.c')])
+    err = self.expect_fail([EMCC, flag, '-sERROR_ON_UNDEFINED_SYMBOLS', test_file('other/test_check_undefined.c')])
     self.assertContained('undefined symbol: foo', err)
 
   def test_EMMAKEN_NO_SDK(self):
diff --git a/tests/test_posixtest.py b/tests/test_posixtest.py
index 6e1cc45e9c693..2d006d4a64562 100644
--- a/tests/test_posixtest.py
+++ b/tests/test_posixtest.py
@@ -17,7 +17,7 @@
 from tools.shared import EMCC
 import test_posixtest_browser
 
-testsuite_root = path_from_root('tests', 'third_party', 'posixtestsuite')
+testsuite_root = path_from_root('tests/third_party/posixtestsuite')
 
 
 class posixtest(RunnerCore):
diff --git a/tests/test_sanity.py b/tests/test_sanity.py
index 357e7fd69819c..907b3baaa765e 100644
--- a/tests/test_sanity.py
+++ b/tests/test_sanity.py
@@ -9,6 +9,7 @@
 import time
 import re
 import tempfile
+from pathlib import Path
 from subprocess import PIPE, STDOUT
 
 from runner import RunnerCore, path_from_root, env_modify, test_file
@@ -23,7 +24,7 @@
 from tools import response_file
 
 SANITY_FILE = shared.Cache.get_path('sanity.txt')
-commands = [[EMCC], [path_from_root('tests', 'runner'), 'blahblah']]
+commands = [[EMCC], [path_from_root('tests/runner'), 'blahblah']]
 
 
 def restore():
@@ -206,7 +207,7 @@ def make_new_executable(name):
       self.assertContained('Please edit the file if any of those are incorrect', output)
       self.assertContained('This command will now exit. When you are done editing those paths, re-run it.', output)
       self.assertTrue(output.strip().endswith('============='))
-      template_file = open(path_from_root('tools', 'settings_template.py')).read()
+      template_file = Path(path_from_root('tools/settings_template.py')).read_text()
       self.assertNotContained('{{{', config_data)
       self.assertNotContained('}}}', config_data)
       self.assertContained('{{{', template_file)
diff --git a/tools/shared.py b/tools/shared.py
index 833a8741bd342..f4a20d14aaa19 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -69,6 +69,7 @@
 
 # TODO(sbc): Investigate switching to shlex.quote
 def shlex_quote(arg):
+  arg = os.fspath(arg)
   if ' ' in arg and (not (arg.startswith('"') and arg.endswith('"'))) and (not (arg.startswith("'") and arg.endswith("'"))):
     return '"' + arg.replace('"', '\\"') + '"'