Move helper into test_other.py

We no longer have size test in test_browser, so we can colocate helper closer to its usages.

Author: RReverser

test/common.py

@@ -5,12 +5,9 @@
 
 from enum import Enum
 from functools import wraps
-import gzip
-import json
-from math import inf
 from pathlib import Path
 from subprocess import PIPE, STDOUT
-from typing import Dict, List, Tuple
+from typing import Dict, Tuple
 from urllib.parse import unquote, unquote_plus, urlparse, parse_qs
 from http.server import HTTPServer, SimpleHTTPRequestHandler
 import contextlib
@@ -1697,77 +1694,6 @@ def assertBinaryEqual(self, file1, file2):
     self.assertEqual(read_binary(file1),
                      read_binary(file2))
 
-  def check_output_sizes(self, outputs: List[str], metadata=None):
-    test_name = self.id().split('.')[-1]
-    results_file = test_file('code_size', test_name + '.json')
-
-    expected_results: dict = {}
-    try:
-      expected_results = json.loads(read_file(results_file))
-    except Exception:
-      if not EMTEST_REBASELINE:
-        raise
-
-    obtained_results = {}
-
-    total_output_size = 0
-    total_expected_size = 0
-    total_output_size_gz = 0
-    total_expected_size_gz = 0
-    for f in outputs:
-      f_gz = f + '.gz'
-      expected_size = expected_results.get(f, inf)
-      expected_size_gz = expected_results.get(f_gz, inf)
-      contents = read_binary(f)
-      size = len(contents)
-      size_gz = len(gzip.compress(contents))
-
-      obtained_results[f] = size
-      obtained_results[f_gz] = size_gz
-
-      if not EMTEST_REBASELINE and size != expected_size and (f.endswith(('.js', '.html'))):
-        print('Contents of ' + f + ': ')
-        print(contents.decode('utf-8', errors='replace'))
-
-      def print_diff(title, actual, expected):
-        diff = actual - expected
-        s = f'{title}={actual}, expected {expected}'
-        if diff > 0:
-          s += f', delta={diff} ({diff * 100.0 / expected:+.2f}%)'
-        print(s)
-
-      print_diff(f'size of {f}', size, expected_size)
-      print_diff(f'size of {f_gz}', size_gz, expected_size_gz)
-
-      # N.B. even though the test code above prints out gzip compressed sizes, regression testing is done against uncompressed sizes
-      # this is because optimizing for compressed sizes can be unpredictable and sometimes counterproductive
-      total_output_size += size
-      total_expected_size += expected_size
-
-      total_output_size_gz += size_gz
-      total_expected_size_gz += expected_size_gz
-
-    if len(outputs) > 1:
-      obtained_results['total'] = total_output_size
-      obtained_results['total_gz'] = total_output_size_gz
-
-    print_diff('Total output size', total_output_size, total_expected_size)
-    print_diff('Total output size gzipped', total_output_size_gz, total_expected_size_gz)
-
-    if metadata is not None:
-      obtained_results.update(metadata)
-
-    if EMTEST_REBASELINE:
-      create_file(results_file, json.dumps(obtained_results, indent=2) + '\n', absolute=True)
-    else:
-      if total_output_size > total_expected_size:
-        print(f'Oops, overall generated code size regressed by {total_output_size - total_expected_size} bytes!')
-        print('If this is expected, rerun the test with --rebaseline to update the expected sizes')
-      if total_output_size < total_expected_size:
-        print(f'Hey amazing, overall generated code size was improved by {total_expected_size - total_output_size} bytes!')
-        print('If this is expected, rerun the test with --rebaseline to update the expected sizes')
-      self.assertDictEqual(obtained_results, expected_results)
-
   library_cache: Dict[str, Tuple[str, object]] = {}
 
   def get_build_dir(self):

test/test_other.py

@@ -12,6 +12,7 @@
 import importlib
 import itertools
 import json
+from math import inf
 import os
 import re
 import select
@@ -9245,6 +9246,76 @@ def build(args):
     # adding --metrics should not affect code size
     self.assertEqual(base_size, os.path.getsize('a.out.wasm'))
 
+  def check_output_sizes(self, *outputs: str, **metadata):
+    test_name = self.id().split('.')[-1]
+    results_file = test_file('code_size', test_name + '.json')
+
+    expected_results: dict = {}
+    try:
+      expected_results = json.loads(read_file(results_file))
+    except Exception:
+      if not common.EMTEST_REBASELINE:
+        raise
+
+    obtained_results = {}
+
+    total_output_size = 0
+    total_expected_size = 0
+    total_output_size_gz = 0
+    total_expected_size_gz = 0
+    for f in outputs:
+      f_gz = f + '.gz'
+      expected_size = expected_results.get(f, inf)
+      expected_size_gz = expected_results.get(f_gz, inf)
+      contents = read_binary(f)
+      size = len(contents)
+      size_gz = len(gzip.compress(contents))
+
+      obtained_results[f] = size
+      obtained_results[f_gz] = size_gz
+
+      if not common.EMTEST_REBASELINE and size != expected_size and (f.endswith(('.js', '.html'))):
+        print('Contents of ' + f + ': ')
+        print(contents.decode('utf-8', errors='replace'))
+
+      def print_diff(title, actual, expected):
+        diff = actual - expected
+        s = f'{title}={actual}, expected {expected}'
+        if diff > 0:
+          s += f', delta={diff} ({diff * 100.0 / expected:+.2f}%)'
+        print(s)
+
+      print_diff(f'size of {f}', size, expected_size)
+      print_diff(f'size of {f_gz}', size_gz, expected_size_gz)
+
+      # N.B. even though the test code above prints out gzip compressed sizes, regression testing is done against uncompressed sizes
+      # this is because optimizing for compressed sizes can be unpredictable and sometimes counterproductive
+      total_output_size += size
+      total_expected_size += expected_size
+
+      total_output_size_gz += size_gz
+      total_expected_size_gz += expected_size_gz
+
+    if len(outputs) > 1:
+      obtained_results['total'] = total_output_size
+      obtained_results['total_gz'] = total_output_size_gz
+
+    print_diff('Total output size', total_output_size, total_expected_size)
+    print_diff('Total output size gzipped', total_output_size_gz, total_expected_size_gz)
+
+    obtained_results.update(metadata)
+
+    if common.EMTEST_REBASELINE:
+      create_file(results_file, json.dumps(obtained_results, indent=2) + '\n', absolute=True)
+    else:
+      if total_output_size > total_expected_size:
+        print(f'Oops, overall generated code size regressed by {total_output_size - total_expected_size} bytes!')
+        print('If this is expected, rerun the test with --rebaseline to update the expected sizes')
+      if total_output_size < total_expected_size:
+        print(f'Hey amazing, overall generated code size was improved by {total_expected_size - total_output_size} bytes!')
+        print('If this is expected, rerun the test with --rebaseline to update the expected sizes')
+      self.assertDictEqual(obtained_results, expected_results)
+
   @crossplatform
   def test_unoptimized_code_size(self):
     # We don't care too about unoptimized code size but we would like to keep it
@@ -9255,7 +9326,7 @@ def test_unoptimized_code_size(self):
     self.build('hello_world.c', cflags=['-O0', '--output-eol=linux', '-sASSERTIONS=0'], output_basename='no_asserts')
     self.build('hello_world.c', cflags=['-O0', '--output-eol=linux', '-sSTRICT'], output_basename='strict')
 
-    self.check_output_sizes(['hello_world.js', 'hello_world.wasm', 'no_asserts.js', 'no_asserts.wasm', 'strict.js', 'strict.wasm'])
+    self.check_output_sizes('hello_world.js', 'hello_world.wasm', 'no_asserts.js', 'no_asserts.wasm', 'strict.js', 'strict.wasm')
 
   def run_codesize_test(self, filename, cflags, check_funcs=True, check_full_js=False):
     # in -Os, -Oz, we remove imports wasm doesn't need
@@ -9328,7 +9399,7 @@ def strip_numeric_suffixes(funcname):
         funcs.sort()
         info['funcs'] = [strip_numeric_suffixes(f) for f in funcs]
 
-    self.check_output_sizes(outputs, info)
+    self.check_output_sizes(*outputs, **info)
 
   @parameterized({
     'O0': ([], True),
@@ -11889,7 +11960,7 @@ def test_minimal_runtime_code_size(self, test_name, wasm2js, compare_js_output=F
       self.run_process(terser + ['-b', 'beautify=true', 'a.js', '-o', 'pretty.js'], env=shared.env_with_node_in_path())
       self.assertFileContents(js_out, read_file('pretty.js'))
 
-    self.check_output_sizes(outputs)
+    self.check_output_sizes(*outputs)
 
   # Tests the library_c_preprocessor.js functionality.
   @crossplatform
@@ -12333,7 +12404,7 @@ def test(args):
     # Changing this option to [] should decrease code size.
     self.assertLess(changed, normal)
     # Check an absolute code size as well.
-    self.check_output_sizes(['a.out.js'])
+    self.check_output_sizes('a.out.js')
 
   def test_INCOMING_MODULE_JS_API_missing(self):
     create_file('pre.js', 'Module.onRuntimeInitialized = () => out("initialized");')