Use NODE_JS_TEST over NODE_JS in test code

test/test_benchmark.py

@@ -366,8 +366,8 @@ def get_output_files(self):
   'v8-lto': EmscriptenBenchmarker('v8-lto', aot_v8, ['-flto']),
   'v8-ctors': EmscriptenBenchmarker('v8-ctors', aot_v8, ['-sEVAL_CTORS']),
   'v8-64': EmscriptenBenchmarker('v8-64', aot_v8, ['-sMEMORY64=2']),
-  'node': EmscriptenBenchmarker('node', config.NODE_JS),
-  'node-64': EmscriptenBenchmarker('node-64', config.NODE_JS, ['-sMEMORY64=2']),
+  'node': EmscriptenBenchmarker('node', config.NODE_JS_TEST),
+  'node-64': EmscriptenBenchmarker('node-64', config.NODE_JS_TEST, ['-sMEMORY64=2']),
   'cherp-v8': CheerpBenchmarker('cheerp-v8-wasm', aot_v8),
   # TODO: ensure no baseline compiler is used, see v8
   'sm': EmscriptenBenchmarker('sm', config.SPIDERMONKEY_ENGINE),

test/test_core.py

@@ -512,16 +512,14 @@ def test_intvars(self):
 
   def test_int53(self):
     if common.EMTEST_REBASELINE:
-      self.run_process([EMCC, test_file('core/test_int53.c'), '-o', 'a.js', '-DGENERATE_ANSWERS'] + self.cflags)
-      ret = self.run_process(config.NODE_JS + ['a.js'], stdout=PIPE).stdout
+      ret = self.do_runf('core/test_int53.c', interleaved_output=False, cflags=['-DGENERATE_ANSWERS'])
       write_file(test_file('core/test_int53.out'), ret)
     else:
       self.do_core_test('test_int53.c', interleaved_output=False)
 
   def test_int53_convertI32PairToI53Checked(self):
     if common.EMTEST_REBASELINE:
-      self.run_process([EMCC, test_file('core/test_convertI32PairToI53Checked.cpp'), '-o', 'a.js', '-DGENERATE_ANSWERS'] + self.cflags)
-      ret = self.run_process(config.NODE_JS + ['a.js'], stdout=PIPE).stdout
+      ret = self.do_runf('core/test_convertI32PairToI53Checked.cpp', interleaved_output=False, cflags=['-DGENERATE_ANSWERS'])
       write_file(test_file('core/test_convertI32PairToI53Checked.out'), ret)
     else:
       self.do_core_test('test_convertI32PairToI53Checked.cpp', interleaved_output=False)

test/test_other.py

@@ -6902,28 +6902,23 @@ def test_bad_locale(self):
   @crossplatform
   def test_browser_language_detection(self):
     # Test HTTP Accept-Language parsing by simulating navigator.languages #8751
-    self.run_process([EMCC,
-                      test_file('test_browser_language_detection.c')])
-
     expected_lang = os.environ.get('LANG')
     if expected_lang is None:
       # If the LANG env. var doesn't exist (Windows), ask Node for the language.
-      try:
-        cmd = config.NODE_JS + ['-e', 'console.log(navigator.languages[0])']
-        expected_lang = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
-        expected_lang = expected_lang.decode('utf-8').strip().replace('-', '_')
-        expected_lang = f'{expected_lang}.UTF-8'
-      except Exception:
-        expected_lang = 'en_US.UTF-8'
+      cmd = config.NODE_JS_TEST + ['-e', 'console.log(navigator.languages[0] || "en_US")']
+      expected_lang = self.run_process(cmd, stdout=PIPE).stdout
+      expected_lang = expected_lang.strip().replace('-', '_')
+      expected_lang = f'{expected_lang}.UTF-8'
 
     # We support both "C" and system LANG here since older versions of node do
     # not expose navigator.languages.
-    self.assertContained(f'LANG=({expected_lang}|en_US.UTF-8|C.UTF-8)', self.run_js('a.out.js'), regex=True)
+    output = self.do_runf('test_browser_language_detection.c')
+    self.assertContained(f'LANG=({expected_lang}|en_US.UTF-8|C.UTF-8)', output, regex=True)
 
     # Accept-Language: fr,fr-FR;q=0.8,en-US;q=0.5,en;q=0.3
     create_file('pre.js', 'var navigator = { language: "fr" };')
-    self.run_process([EMCC, '--pre-js', 'pre.js', test_file('test_browser_language_detection.c')])
-    self.assertContained('LANG=fr.UTF-8', self.run_js('a.out.js'))
+    output = self.do_runf('test_browser_language_detection.c', cflags=['--pre-js', 'pre.js'])
+    self.assertContained('LANG=fr.UTF-8', output)
 
     # Accept-Language: fr-FR,fr;q=0.8,en-US;q=0.5,en;q=0.3
     create_file('pre.js', r'var navigator = { language: "fr-FR" };')
@@ -9991,27 +9986,27 @@ def test_multi_inheritance_exception_message(self):
 
   @requires_node
   def test_jsrun(self):
-    print(config.NODE_JS)
+    print(config.NODE_JS_TEST)
     jsrun.WORKING_ENGINES = {}
     # Test that engine check passes
-    self.assertTrue(jsrun.check_engine(config.NODE_JS))
+    self.assertTrue(jsrun.check_engine(config.NODE_JS_TEST))
     # Run it a second time (cache hit)
-    self.assertTrue(jsrun.check_engine(config.NODE_JS))
+    self.assertTrue(jsrun.check_engine(config.NODE_JS_TEST))
 
     # Test that engine check fails
     bogus_engine = ['/fake/inline4']
     self.assertFalse(jsrun.check_engine(bogus_engine))
     self.assertFalse(jsrun.check_engine(bogus_engine))
 
     # Test the other possible way (list vs string) to express an engine
-    if type(config.NODE_JS) is list:
-      engine2 = config.NODE_JS[0]
+    if type(config.NODE_JS_TEST) is list:
+      engine2 = config.NODE_JS_TEST[0]
     else:
-      engine2 = [config.NODE_JS]
+      engine2 = [config.NODE_JS_TEST]
     self.assertTrue(jsrun.check_engine(engine2))
 
     # Test that self.run_js requires the engine
-    self.run_js(test_file('hello_world.js'), config.NODE_JS)
+    self.run_js(test_file('hello_world.js'), config.NODE_JS_TEST)
     caught_exit = 0
     try:
       self.run_js(test_file('hello_world.js'), bogus_engine)

test/test_sanity.py

@@ -610,8 +610,8 @@ def test_js_engine_path(self):
     jsengines = [('d8',     config.V8_ENGINE),
                  ('d8_g',   config.V8_ENGINE),
                  ('js',     config.SPIDERMONKEY_ENGINE),
-                 ('node',   config.NODE_JS),
-                 ('nodejs', config.NODE_JS)]
+                 ('node',   config.NODE_JS_TEST),
+                 ('nodejs', config.NODE_JS_TEST)]
     for filename, engine in jsengines:
       delete_file(SANITY_FILE)
       if type(engine) is list: