[test] Parameterize some more tests. NFC (#21875)

Author: sbc100

test/test_other.py

@@ -955,22 +955,22 @@ def test_cmake_explicit_generator(self):
   # Tests that it's possible to pass C++11 or GNU++11 build modes to CMake by building code that
   # needs C++11 (embind)
   @requires_ninja
-  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', '-GNinja', test_file('cmake/cmake_with_emval')] + args
-      print(str(configure))
-      self.run_process(configure)
-      build = ['cmake', '--build', '.']
-      print(str(build))
-      self.run_process(build)
-
-      out = self.run_js('cmake_with_emval.js')
-      if '-DNO_GNU_EXTENSIONS=1' in args:
-        self.assertContained('Hello! __STRICT_ANSI__: 1, __cplusplus: 201103', out)
-      else:
-        self.assertContained('Hello! __STRICT_ANSI__: 0, __cplusplus: 201103', out)
+  @parameterized({
+    '': [[]],
+    '_no_gnu': [['-DNO_GNU_EXTENSIONS=1']],
+  })
+  def test_cmake_with_embind_cpp11_mode(self, args):
+    # Use ninja generator here since we assume its always installed on our build/test machines.
+    configure = [EMCMAKE, 'cmake', '-GNinja', test_file('cmake/cmake_with_emval')] + args
+    self.run_process(configure)
+    build = ['cmake', '--build', '.']
+    self.run_process(build)
+
+    out = self.run_js('cmake_with_emval.js')
+    if '-DNO_GNU_EXTENSIONS=1' in args:
+      self.assertContained('Hello! __STRICT_ANSI__: 1, __cplusplus: 201103', out)
+    else:
+      self.assertContained('Hello! __STRICT_ANSI__: 0, __cplusplus: 201103', out)
 
   # Tests that the Emscripten CMake toolchain option
   def test_cmake_bitcode_static_libraries(self):
@@ -2584,11 +2584,16 @@ def test_undefined_exported_js_function(self, outfile):
     self.run_process(cmd)
 
   @parameterized({
-    'warn': ('WARN',),
-    'error': ('ERROR',),
-    'ignore': (None,)
+    '': [[]],
+    'O1': [['-O1']],
+    'GL2': [['-sMAX_WEBGL_VERSION=2']],
   })
-  def test_undefined_symbols(self, action):
+  @parameterized({
+    'warn': ['WARN'],
+    'error': ['ERROR'],
+    'ignore': [None]
+  })
+  def test_undefined_symbols(self, action, args):
     create_file('main.c', r'''
       #include <stdio.h>
       #include <SDL.h>
@@ -2606,36 +2611,35 @@ def test_undefined_symbols(self, action):
       }
       ''')
 
-    for args in ([], ['-O1'], ['-sMAX_WEBGL_VERSION=2']):
-      for value in ([0, 1]):
-        delete_file('a.out.js')
-        print('checking "%s" %s' % (args, value))
-        extra = ['-s', action + '_ON_UNDEFINED_SYMBOLS=%d' % value] if action else []
-        proc = self.run_process([EMCC, '-sUSE_SDL', '-sGL_ENABLE_GET_PROC_ADDRESS', 'main.c'] + extra + args, stderr=PIPE, check=False)
-        if common.EMTEST_VERBOSE:
-          print(proc.stderr)
-        if value or action is None:
-          # The default is that we error in undefined symbols
-          self.assertContained('undefined symbol: something', proc.stderr)
-          self.assertContained('undefined symbol: elsey', proc.stderr)
-          check_success = False
-        elif action == 'ERROR' and not value:
-          # Error disables, should only warn
-          self.assertContained('warning: undefined symbol: something', proc.stderr)
-          self.assertContained('warning: undefined symbol: elsey', proc.stderr)
-          self.assertNotContained('undefined symbol: emscripten_', proc.stderr)
-          check_success = True
-        elif action == 'WARN' and not value:
-          # Disabled warning should imply disabling errors
-          self.assertNotContained('undefined symbol', proc.stderr)
-          check_success = True
-
-        if check_success:
-          self.assertEqual(proc.returncode, 0)
-          self.assertTrue(os.path.exists('a.out.js'))
-        else:
-          self.assertNotEqual(proc.returncode, 0)
-          self.assertFalse(os.path.exists('a.out.js'))
+    for value in ([0, 1]):
+      delete_file('a.out.js')
+      print('checking %s' % value)
+      extra = ['-s', action + '_ON_UNDEFINED_SYMBOLS=%d' % value] if action else []
+      proc = self.run_process([EMCC, '-sUSE_SDL', '-sGL_ENABLE_GET_PROC_ADDRESS', 'main.c'] + extra + args, stderr=PIPE, check=False)
+      if common.EMTEST_VERBOSE:
+        print(proc.stderr)
+      if value or action is None:
+        # The default is that we error in undefined symbols
+        self.assertContained('undefined symbol: something', proc.stderr)
+        self.assertContained('undefined symbol: elsey', proc.stderr)
+        check_success = False
+      elif action == 'ERROR' and not value:
+        # Error disables, should only warn
+        self.assertContained('warning: undefined symbol: something', proc.stderr)
+        self.assertContained('warning: undefined symbol: elsey', proc.stderr)
+        self.assertNotContained('undefined symbol: emscripten_', proc.stderr)
+        check_success = True
+      elif action == 'WARN' and not value:
+        # Disabled warning should imply disabling errors
+        self.assertNotContained('undefined symbol', proc.stderr)
+        check_success = True
+
+      if check_success:
+        self.assertEqual(proc.returncode, 0)
+        self.assertTrue(os.path.exists('a.out.js'))
+      else:
+        self.assertNotEqual(proc.returncode, 0)
+        self.assertFalse(os.path.exists('a.out.js'))
 
   def test_undefined_data_symbols(self):
     create_file('main.c', r'''
@@ -4658,7 +4662,13 @@ def add_on_abort_and_verify(extra=''):
     os.remove('a.out.wasm') # trigger onAbort by intentionally causing startup to fail
     add_on_abort_and_verify()
 
-  def test_no_exit_runtime(self):
+  @parameterized({
+    '': ([],),
+    '01': (['-O1', '-g2'],),
+    'O2': (['-O2', '-g2', '-flto'],),
+  })
+  @also_with_wasm2js
+  def test_no_exit_runtime(self, opts):
     create_file('code.cpp', r'''
 #include <stdio.h>
 
@@ -4683,29 +4693,27 @@ def test_no_exit_runtime(self):
 }
     ''')
 
-    for wasm in [0, 1]:
-      for no_exit in [1, 0]:
-        for opts in [[], ['-O1'], ['-O2', '-g2'], ['-O2', '-g2', '-flto']]:
-          print(wasm, no_exit, opts)
-          cmd = [EMXX] + opts + ['code.cpp', '-sEXIT_RUNTIME=' + str(1 - no_exit), '-sWASM=' + str(wasm)]
-          if wasm:
-            cmd += ['--profiling-funcs'] # for function names
-          self.run_process(cmd)
-          output = self.run_js('a.out.js')
-          src = read_file('a.out.js')
-          if wasm:
-            src += '\n' + self.get_wasm_text('a.out.wasm')
-          exit = 1 - no_exit
-          print('  exit:', exit, 'opts:', opts)
-          self.assertContained('coming around', output)
-          self.assertContainedIf('going away', output, exit)
-          # The wasm backend uses atexit to register destructors when
-          # constructors are called  There is currently no way to exclude
-          # these destructors from the wasm binary.
-          # TODO(sbc): Re-enabled these assertions once the wasm backend
-          # is able to eliminate these.
-          # assert ('atexit(' in src) == exit, 'atexit should not appear in src when EXIT_RUNTIME=0'
-          # assert ('_ZN5WasteILi2EED' in src) == exit, 'destructors should not appear if no exit:\n' + src
+    for no_exit in [1, 0]:
+      print(no_exit)
+      cmd = [EMXX] + opts + ['code.cpp', '-sEXIT_RUNTIME=' + str(1 - no_exit)] + self.get_emcc_args()
+      if self.is_wasm():
+        cmd += ['--profiling-funcs'] # for function names
+      self.run_process(cmd)
+      output = self.run_js('a.out.js')
+      src = read_file('a.out.js')
+      if self.is_wasm():
+        src += '\n' + self.get_wasm_text('a.out.wasm')
+      exit = 1 - no_exit
+      print('  exit:', exit)
+      self.assertContained('coming around', output)
+      self.assertContainedIf('going away', output, exit)
+      # The wasm backend uses atexit to register destructors when
+      # constructors are called  There is currently no way to exclude
+      # these destructors from the wasm binary.
+      # TODO(sbc): Re-enabled these assertions once the wasm backend
+      # is able to eliminate these.
+      # assert ('atexit(' in src) == exit, 'atexit should not appear in src when EXIT_RUNTIME=0'
+      # assert ('_ZN5WasteILi2EED' in src) == exit, 'destructors should not appear if no exit:\n' + src
 
   def test_no_exit_runtime_warnings_flush(self):
     # check we warn if there is unflushed info
@@ -4771,19 +4779,22 @@ def test(cxx, no_exit, assertions, flush=0, keepalive=0, filesystem=1):
           for flush in [0, 1]:
             test(cxx, no_exit, assertions, flush)
 
-  def test_fs_after_main(self):
-    for args in [[], ['-O1']]:
-      print(args)
-      self.run_process([EMXX, test_file('fs_after_main.cpp')])
-      self.assertContained('Test passed.', self.run_js('a.out.js'))
-
-  def test_opt_levels(self):
-    for opt in ['-O1', '-O2', '-Os', '-Oz', '-O3', '-Og', '-Ofast']:
+  def test_extra_opt_levels(self):
+    # Opt levels that we don't tend to test elsewhere
+    for opt in ['-Og', '-Ofast']:
       print(opt)
       proc = self.run_process([EMCC, '-v', test_file('hello_world.c'), opt], stderr=PIPE)
       self.assertContained(opt, proc.stderr)
       self.assertContained('hello, world!', self.run_js('a.out.js'))
 
+  @parameterized({
+    '': [[]],
+    'O1': [['-O1']],
+  })
+  def test_fs_after_main(self, args):
+    self.run_process([EMXX, test_file('fs_after_main.cpp')])
+    self.assertContained('Test passed.', self.run_js('a.out.js'))
+
   def test_oz_size(self):
     sizes = {}
     for name, args in [
@@ -6615,17 +6626,18 @@ def test_massive_alloc(self, wasm):
     if not wasm:
       self.assertContained('Warning: Enlarging memory arrays, this is not fast! 16777216,1468137472\n', output)
 
-  def test_failing_alloc(self):
+  @parameterized({
+    '': (False,),
+    'growth': (True,),
+  })
+  @also_with_wasm2js
+  def test_failing_alloc(self, growth):
     for pre_fail, post_fail, opts in [
       ('', '', []),
       ('EM_ASM( Module.temp = _sbrk() );', 'EM_ASM( assert(Module.temp === _sbrk(), "must not adjust brk when an alloc fails!") );', []),
-      # also test non-wasm in normal mode
-      ('', '', ['-sWASM=0']),
-      ('EM_ASM( Module.temp = _sbrk() );', 'EM_ASM( assert(Module.temp === _sbrk(), "must not adjust brk when an alloc fails!") );', ['-sWASM=0']),
     ]:
-      for growth in [0, 1]:
-        for aborting_args in [[], ['-sABORTING_MALLOC=0']]:
-          create_file('main.cpp', r'''
+      for aborting_args in [[], ['-sABORTING_MALLOC=0']]:
+        create_file('main.cpp', r'''
 #include <stdio.h>
 #include <stdlib.h>
 #include <vector>
@@ -6665,38 +6677,38 @@ def test_failing_alloc(self):
   printf("managed another malloc!\n");
 }
 ''' % (pre_fail, post_fail))
-          args = [EMXX, 'main.cpp', '-sEXPORTED_FUNCTIONS=_main,_sbrk', '-sINITIAL_MEMORY=16MB'] + opts + aborting_args
-          args += ['-sTEST_MEMORY_GROWTH_FAILS'] # In this test, force memory growing to fail
+        args = [EMXX, 'main.cpp', '-sEXPORTED_FUNCTIONS=_main,_sbrk', '-sINITIAL_MEMORY=16MB'] + opts + aborting_args
+        args += ['-sTEST_MEMORY_GROWTH_FAILS'] # In this test, force memory growing to fail
+        if growth:
+          args += ['-sALLOW_MEMORY_GROWTH']
+        # growth disables aborting by default, but it can be overridden
+        aborting = not aborting_args and not growth
+        print('test_failing_alloc', args, pre_fail)
+        self.run_process(args)
+        # growth also disables aborting
+        can_manage_another = not aborting
+        split = '-DSPLIT' in args
+        print('can manage another:', can_manage_another, 'split:', split, 'aborting:', aborting)
+        output = self.run_js('a.out.js', assert_returncode=0 if can_manage_another else NON_ZERO)
+        if can_manage_another:
+          self.assertContained('an allocation failed!\n', output)
+          if not split:
+            # split memory allocation may fail due to GC objects no longer being allocatable,
+            # and we can't expect to recover from that deterministically. So just check we
+            # get to the fail.
+            # otherwise, we should fail eventually, then free, then succeed
+            self.assertContained('managed another malloc!\n', output)
+        else:
+          # we should see an abort
+          self.assertContained('Aborted(Cannot enlarge memory arrays', output)
           if growth:
-            args += ['-sALLOW_MEMORY_GROWTH']
-          # growth disables aborting by default, but it can be overridden
-          aborting = not aborting_args and not growth
-          print('test_failing_alloc', args, pre_fail)
-          self.run_process(args)
-          # growth also disables aborting
-          can_manage_another = not aborting
-          split = '-DSPLIT' in args
-          print('can manage another:', can_manage_another, 'split:', split, 'aborting:', aborting)
-          output = self.run_js('a.out.js', assert_returncode=0 if can_manage_another else NON_ZERO)
-          if can_manage_another:
-            self.assertContained('an allocation failed!\n', output)
-            if not split:
-              # split memory allocation may fail due to GC objects no longer being allocatable,
-              # and we can't expect to recover from that deterministically. So just check we
-              # get to the fail.
-              # otherwise, we should fail eventually, then free, then succeed
-              self.assertContained('managed another malloc!\n', output)
+            # when growth is enabled, the default is to not abort, so just explain that
+            self.assertContained('If you want malloc to return NULL (0) instead of this abort, do not link with -sABORTING_MALLOC', output)
           else:
-            # we should see an abort
-            self.assertContained('Aborted(Cannot enlarge memory arrays', output)
-            if growth:
-              # when growth is enabled, the default is to not abort, so just explain that
-              self.assertContained('If you want malloc to return NULL (0) instead of this abort, do not link with -sABORTING_MALLOC', output)
-            else:
-              # when growth is not enabled, suggest 3 possible solutions (start with more memory, allow growth, or don't abort)
-              self.assertContained(('higher than the current value 16777216,', 'higher than the current value 33554432,'), output)
-              self.assertContained('compile with -sALLOW_MEMORY_GROWTH', output)
-              self.assertContained('compile with -sABORTING_MALLOC=0', output)
+            # when growth is not enabled, suggest 3 possible solutions (start with more memory, allow growth, or don't abort)
+            self.assertContained(('higher than the current value 16777216,', 'higher than the current value 33554432,'), output)
+            self.assertContained('compile with -sALLOW_MEMORY_GROWTH', output)
+            self.assertContained('compile with -sABORTING_MALLOC=0', output)
 
   def test_failing_growth_2gb(self):
     create_file('test.c', r'''
@@ -8779,37 +8791,42 @@ def test_side_module_folder_deps(self):
     self.run_process([EMCC, test_file('hello_world.c'), '-sMAIN_MODULE', '-o', 'main.js', '-L', 'subdir', '-lside2'])
 
   @is_slow_test
-  def test_lto(self):
+  @parameterized({
+    '': ([],),
+    '01': (['-O1'],),
+    'O2': (['-O2'],),
+    'O3': (['-O3'],),
+    'Os': (['-Os'],),
+    'Oz': (['-Oz'],),
+  })
+  def test_lto(self, args):
     # test building of non-wasm-object-files libraries, building with them, and running them
 
-    src = test_file('hello_libcxx.cpp')
     # test codegen in lto mode, and compare to normal (wasm object) mode
-    for args in [[], ['-O1'], ['-O2'], ['-O3'], ['-Os'], ['-Oz']]:
-      print(args)
-
-      print('wasm in object')
-      self.run_process([EMXX, src] + args + ['-c', '-o', 'hello_obj.o'])
-      self.assertTrue(building.is_wasm('hello_obj.o'))
-      self.assertFalse(is_bitcode('hello_obj.o'))
-
-      print('bitcode in object')
-      self.run_process([EMXX, src] + args + ['-c', '-o', 'hello_bitcode.o', '-flto'])
-      self.assertFalse(building.is_wasm('hello_bitcode.o'))
-      self.assertTrue(is_bitcode('hello_bitcode.o'))
-
-      print('use bitcode object (LTO)')
-      self.run_process([EMXX, 'hello_bitcode.o'] + args + ['-flto'])
-      self.assertContained('hello, world!', self.run_js('a.out.js'))
-      print('use bitcode object (non-LTO)')
-      self.run_process([EMXX, 'hello_bitcode.o'] + args)
-      self.assertContained('hello, world!', self.run_js('a.out.js'))
+    src = test_file('hello_libcxx.cpp')
+    # wasm in object
+    self.run_process([EMXX, src] + args + ['-c', '-o', 'hello_obj.o'])
+    self.assertTrue(building.is_wasm('hello_obj.o'))
+    self.assertFalse(is_bitcode('hello_obj.o'))
+
+    # bitcode in object
+    self.run_process([EMXX, src] + args + ['-c', '-o', 'hello_bitcode.o', '-flto'])
+    self.assertFalse(building.is_wasm('hello_bitcode.o'))
+    self.assertTrue(is_bitcode('hello_bitcode.o'))
+
+    # use bitcode object (LTO)
+    self.run_process([EMXX, 'hello_bitcode.o'] + args + ['-flto'])
+    self.assertContained('hello, world!', self.run_js('a.out.js'))
+    # use bitcode object (non-LTO)
+    self.run_process([EMXX, 'hello_bitcode.o'] + args)
+    self.assertContained('hello, world!', self.run_js('a.out.js'))
 
-      print('use native object (LTO)')
-      self.run_process([EMXX, 'hello_obj.o'] + args + ['-flto'])
-      self.assertContained('hello, world!', self.run_js('a.out.js'))
-      print('use native object (non-LTO)')
-      self.run_process([EMXX, 'hello_obj.o'] + args)
-      self.assertContained('hello, world!', self.run_js('a.out.js'))
+    # use native object (LTO)
+    self.run_process([EMXX, 'hello_obj.o'] + args + ['-flto'])
+    self.assertContained('hello, world!', self.run_js('a.out.js'))
+    # use native object (non-LTO)
+    self.run_process([EMXX, 'hello_obj.o'] + args)
+    self.assertContained('hello, world!', self.run_js('a.out.js'))
 
   @parameterized({
     'noexcept': [],