def run_gtest():
def run():
gtest = os.path.join(shared.options.binaryen_bin, 'binaryen-unittests')
result = subprocess.run(gtest)
if result.returncode != 0:
shared.num_failures += 1
if shared.options.abort_on_first_failure and shared.num_failures:
raise Exception("gtest test failed")
shared.with_pass_debug(run)
def run_lit():
def run():
lit_script = os.path.join(shared.options.binaryen_bin, 'binaryen-lit')
lit_tests = os.path.join(shared.options.binaryen_root, 'test', 'lit')
# lit expects to be run as its own executable
cmd = [sys.executable, lit_script, lit_tests, '-vv']
result = subprocess.run(cmd)
if result.returncode != 0:
shared.num_failures += 1
if shared.options.abort_on_first_failure and shared.num_failures:
raise Exception("lit test failed")
shared.with_pass_debug(run)
def run_gtest():
def run():
gtest = os.path.join(shared.options.binaryen_bin, 'binaryen-unittests')
if not os.path.isfile(gtest):
shared.warn('gtest binary not found - skipping tests')
else:
result = subprocess.run(gtest)
if result.returncode != 0:
shared.num_failures += 1
if shared.options.abort_on_first_failure and shared.num_failures:
raise Exception("gtest test failed")
shared.with_pass_debug(run)
def run_wasm_dis_tests():
print('\n[ checking wasm-dis on provided binaries... ]\n')
for t in shared.get_tests(shared.options.binaryen_test, ['.wasm']):
print('..', os.path.basename(t))
cmd = shared.WASM_DIS + [t]
if os.path.isfile(t + '.map'):
cmd += ['--source-map', t + '.map']
actual = support.run_command(cmd)
shared.fail_if_not_identical_to_file(actual, t + '.fromBinary')
# also verify there are no validation errors
def check():
cmd = shared.WASM_OPT + [t, '-all']
support.run_command(cmd)
shared.with_pass_debug(check)
def run_wasm_dis_tests():
print '\n[ checking wasm-dis on provided binaries... ]\n'
for t in tests:
if t.endswith('.wasm') and not t.startswith('spec'):
print '..', t
t = os.path.join(options.binaryen_test, t)
cmd = WASM_DIS + [t]
if os.path.isfile(t + '.map'):
cmd += ['--source-map', t + '.map']
actual = run_command(cmd)
fail_if_not_identical_to_file(actual, t + '.fromBinary')
# also verify there are no validation errors
def check():
cmd = WASM_OPT + [t, '-all']
run_command(cmd)
with_pass_debug(check)
def run_wasm_opt_tests():
print('\n[ checking wasm-opt -o notation... ]\n')
for extra_args in [[], ['--no-validation']]:
wast = os.path.join(shared.options.binaryen_test, 'hello_world.wat')
shared.delete_from_orbit('a.wat')
out = 'a.wat'
cmd = shared.WASM_OPT + [wast, '-o', out, '-S'] + extra_args
support.run_command(cmd)
shared.fail_if_not_identical_to_file(open(out).read(), wast)
print('\n[ checking wasm-opt binary reading/writing... ]\n')
shutil.copyfile(
os.path.join(shared.options.binaryen_test, 'hello_world.wat'), 'a.wat')
shared.delete_from_orbit('a.wasm')
shared.delete_from_orbit('b.wast')
support.run_command(shared.WASM_OPT + ['a.wat', '-o', 'a.wasm'])
assert open('a.wasm', 'rb').read()[0] == 0, 'we emit binary by default'
support.run_command(shared.WASM_OPT + ['a.wasm', '-o', 'b.wast', '-S'])
assert open('b.wast', 'rb').read()[0] != 0, 'we emit text with -S'
print('\n[ checking wasm-opt passes... ]\n')
for t in shared.get_tests(shared.get_test_dir('passes'),
['.wast', '.wasm']):
print('..', os.path.basename(t))
binary = '.wasm' in t
base = os.path.basename(t).replace('.wast', '').replace('.wasm', '')
passname = base
passes_file = os.path.join(shared.get_test_dir('passes'),
passname + '.passes')
if os.path.exists(passes_file):
passname = open(passes_file).read().strip()
opts = [('--' + p if not p.startswith('O') and p != 'g' else '-' + p)
for p in passname.split('_')]
actual = ''
for module, asserts in support.split_wast(t):
assert len(asserts) == 0
support.write_wast('split.wast', module)
cmd = shared.WASM_OPT + opts + ['split.wast', '--print']
curr = support.run_command(cmd)
actual += curr
# also check debug mode output is valid
debugged = support.run_command(cmd + ['--debug'],
stderr=subprocess.PIPE)
shared.fail_if_not_contained(actual, debugged)
# also check pass-debug mode
def check():
pass_debug = support.run_command(cmd)
shared.fail_if_not_identical(curr, pass_debug)
shared.with_pass_debug(check)
expected_file = os.path.join(
shared.get_test_dir('passes'),
base + ('.bin' if binary else '') + '.txt')
shared.fail_if_not_identical_to_file(actual, expected_file)
if 'emit-js-wrapper' in t:
with open('a.js') as actual:
shared.fail_if_not_identical_to_file(actual.read(), t + '.js')
if 'emit-spec-wrapper' in t:
with open('a.wat') as actual:
shared.fail_if_not_identical_to_file(actual.read(), t + '.wat')
print('\n[ checking wasm-opt parsing & printing... ]\n')
for t in shared.get_tests(shared.get_test_dir('print'), ['.wast']):
print('..', os.path.basename(t))
wasm = os.path.basename(t).replace('.wast', '')
cmd = shared.WASM_OPT + [t, '--print', '-all']
print(' ', ' '.join(cmd))
actual, err = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=True).communicate()
expected_file = os.path.join(shared.get_test_dir('print'),
wasm + '.txt')
shared.fail_if_not_identical_to_file(actual, expected_file)
cmd = shared.WASM_OPT + [
os.path.join(shared.get_test_dir('print'), t), '--print-minified',
'-all'
]
print(' ', ' '.join(cmd))
actual, err = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=True).communicate()
shared.fail_if_not_identical(
actual.strip(),
open(
os.path.join(shared.get_test_dir('print'),
wasm + '.minified.txt')).read().strip())
print('\n[ checking wasm-opt testcases... ]\n')
for t in shared.get_tests(shared.options.binaryen_test, ['.wast']):
print('..', os.path.basename(t))
f = t + '.from-wast'
cmd = shared.WASM_OPT + [t, '--print', '-all']
actual = support.run_command(cmd)
actual = actual.replace('printing before:\n', '')
shared.fail_if_not_identical_to_file(actual, f)
# FIXME Remove this condition after nullref is implemented in V8
if 'reference-types.wast' not in t:
shared.binary_format_check(t,
wasm_as_args=['-g'
]) # test with debuginfo
shared.binary_format_check(t,
wasm_as_args=[],
binary_suffix='.fromBinary.noDebugInfo'
) # test without debuginfo
shared.minify_check(t)
print('\n[ checking wasm-opt debugInfo read-write... ]\n')
for t in shared.get_tests(shared.options.binaryen_test, ['.fromasm']):
if 'debugInfo' not in t:
continue
print('..', os.path.basename(t))
f = t + '.read-written'
support.run_command(shared.WASM_AS +
[t, '--source-map=a.map', '-o', 'a.wasm', '-g'])
support.run_command(shared.WASM_OPT + [
'a.wasm', '--input-source-map=a.map', '-o', 'b.wasm',
'--output-source-map=b.map', '-g'
])
actual = support.run_command(shared.WASM_DIS +
['b.wasm', '--source-map=b.map'])
shared.fail_if_not_identical_to_file(actual, f)
def run_wasm_opt_tests():
print('\n[ checking wasm-opt -o notation... ]\n')
for extra_args in [[], ['--no-validation']]:
wast = os.path.join(options.binaryen_test, 'hello_world.wast')
delete_from_orbit('a.wast')
out = 'a.wast'
cmd = WASM_OPT + [wast, '-o', out, '-S'] + extra_args
run_command(cmd)
fail_if_not_identical_to_file(open(out).read(), wast)
print('\n[ checking wasm-opt binary reading/writing... ]\n')
shutil.copyfile(os.path.join(options.binaryen_test, 'hello_world.wast'),
'a.wast')
delete_from_orbit('a.wasm')
delete_from_orbit('b.wast')
run_command(WASM_OPT + ['a.wast', '-o', 'a.wasm'])
assert open('a.wasm', 'rb').read()[0] == 0, 'we emit binary by default'
run_command(WASM_OPT + ['a.wasm', '-o', 'b.wast', '-S'])
assert open('b.wast', 'rb').read()[0] != 0, 'we emit text with -S'
print('\n[ checking wasm-opt passes... ]\n')
for t in sorted(os.listdir(os.path.join(options.binaryen_test, 'passes'))):
if t.endswith(('.wast', '.wasm')):
print('..', t)
binary = '.wasm' in t
base = os.path.basename(t).replace('.wast',
'').replace('.wasm', '')
passname = base
if passname.isdigit():
passname = open(
os.path.join(options.binaryen_test, 'passes',
passname + '.passes')).read().strip()
opts = [('--' + p if not p.startswith('O') else '-' + p)
for p in passname.split('_')]
t = os.path.join(options.binaryen_test, 'passes', t)
actual = ''
for module, asserts in split_wast(t):
assert len(asserts) == 0
write_wast('split.wast', module)
cmd = WASM_OPT + opts + ['split.wast', '--print']
curr = run_command(cmd)
actual += curr
# also check debug mode output is valid
debugged = run_command(cmd + ['--debug'],
stderr=subprocess.PIPE)
fail_if_not_contained(actual, debugged)
# also check pass-debug mode
def check():
pass_debug = run_command(cmd)
fail_if_not_identical(curr, pass_debug)
with_pass_debug(check)
expected_file = os.path.join(
options.binaryen_test, 'passes',
base + ('.bin' if binary else '') + '.txt')
fail_if_not_identical_to_file(actual, expected_file)
if 'emit-js-wrapper' in t:
with open('a.js') as actual:
fail_if_not_identical_to_file(actual.read(), t + '.js')
if 'emit-spec-wrapper' in t:
with open('a.wat') as actual:
fail_if_not_identical_to_file(actual.read(), t + '.wat')
print('\n[ checking wasm-opt parsing & printing... ]\n')
for t in sorted(os.listdir(os.path.join(options.binaryen_test, 'print'))):
if t.endswith('.wast'):
print('..', t)
wasm = os.path.basename(t).replace('.wast', '')
cmd = WASM_OPT + [
os.path.join(options.binaryen_test, 'print', t), '--print',
'-all'
]
print(' ', ' '.join(cmd))
actual, err = subprocess.Popen(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=True).communicate()
expected_file = os.path.join(options.binaryen_test, 'print',
wasm + '.txt')
fail_if_not_identical_to_file(actual, expected_file)
cmd = WASM_OPT + [
os.path.join(options.binaryen_test, 'print', t),
'--print-minified', '-all'
]
print(' ', ' '.join(cmd))
actual, err = subprocess.Popen(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=True).communicate()
fail_if_not_identical(
actual.strip(),
open(
os.path.join(options.binaryen_test, 'print',
wasm + '.minified.txt')).read().strip())
print('\n[ checking wasm-opt testcases... ]\n')
for t in tests:
if t.endswith('.wast') and not t.startswith('spec'):
print('..', t)
t = os.path.join(options.binaryen_test, t)
f = t + '.from-wast'
cmd = WASM_OPT + [t, '--print', '-all']
actual = run_command(cmd)
actual = actual.replace('printing before:\n', '')
fail_if_not_identical_to_file(actual, f)
binary_format_check(t, wasm_as_args=['-g']) # test with debuginfo
binary_format_check(t,
wasm_as_args=[],
binary_suffix='.fromBinary.noDebugInfo'
) # test without debuginfo
minify_check(t)
print('\n[ checking wasm-opt debugInfo read-write... ]\n')
test_dir = os.path.join(options.binaryen_root, 'test')
for t in os.listdir(test_dir):
if t.endswith('.fromasm') and 'debugInfo' in t:
print('..', t)
t = os.path.join(test_dir, t)
f = t + '.read-written'
run_command(WASM_AS +
[t, '--source-map=a.map', '-o', 'a.wasm', '-g'])
run_command(WASM_OPT + [
'a.wasm', '--input-source-map=a.map', '-o', 'b.wasm',
'--output-source-map=b.map', '-g'
])
actual = run_command(WASM_DIS + ['b.wasm', '--source-map=b.map'])
fail_if_not_identical_to_file(actual, f)
def test_wasm2js_output():
for opt in (0, 1):
for t in tests + spec_tests + wasm2js_tests:
basename = os.path.basename(t)
if basename in wasm2js_blacklist:
continue
asm = basename.replace('.wast', '.2asm.js')
expected_file = os.path.join(shared.get_test_dir('wasm2js'), asm)
if opt:
expected_file += '.opt'
if not os.path.exists(expected_file):
continue
print('..', os.path.basename(t))
all_out = []
for module, asserts in support.split_wast(t):
support.write_wast('split.wast', module, asserts)
cmd = shared.WASM2JS + ['split.wast', '-all']
if opt:
cmd += ['-O']
if 'emscripten' in t:
cmd += ['--emscripten']
out = support.run_command(cmd)
all_out.append(out)
if not shared.NODEJS and not shared.MOZJS:
print('No JS interpreters. Skipping spec tests.')
continue
open('a.2asm.mjs', 'w').write(out)
cmd += ['--allow-asserts']
out = support.run_command(cmd)
# also verify it passes pass-debug verifications
shared.with_pass_debug(lambda: support.run_command(cmd))
open('a.2asm.asserts.mjs', 'w').write(out)
# verify asm.js is valid js, note that we're using --experimental-modules
# to enable ESM syntax and we're also passing a custom loader to handle the
# `spectest` and `env` modules in our tests.
if shared.NODEJS:
loader = os.path.join(shared.options.binaryen_root,
'scripts', 'test',
'node-esm-loader.mjs')
node = [
shared.NODEJS, '--experimental-modules', '--loader',
loader
]
cmd = node[:]
cmd.append('a.2asm.mjs')
out = support.run_command(cmd)
shared.fail_if_not_identical(out, '')
cmd = node[:]
cmd.append('a.2asm.asserts.mjs')
out = support.run_command(cmd,
expected_err='',
err_ignore='ExperimentalWarning')
shared.fail_if_not_identical(out, '')
shared.fail_if_not_identical_to_file(''.join(all_out),
expected_file)
