def test_wasm2js_output():
for wasm in tests + spec_tests + extra_wasm2js_tests:
if not wasm.endswith('.wast'):
continue
basename = os.path.basename(wasm)
if basename in wasm2js_blacklist:
continue
asm = basename.replace('.wast', '.2asm.js')
expected_file = os.path.join(wasm2js_dir, asm)
if not os.path.exists(expected_file):
continue
print '..', wasm
t = os.path.join(options.binaryen_test, wasm)
all_out = []
for module, asserts in split_wast(t):
with open('split.wast', 'w') as o:
o.write(module + '\n'.join(asserts))
cmd = WASM2JS + ['split.wast', '-O']
if 'emscripten' in wasm:
cmd += ['--emscripten']
out = run_command(cmd)
all_out.append(out)
if not NODEJS and not MOZJS:
print 'No JS interpreters. Skipping spec tests.'
continue
open('a.2asm.mjs', 'w').write(out)
cmd += ['--allow-asserts']
out = run_command(cmd)
# also verify it passes pass-debug verifications
with_pass_debug(lambda: 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 NODEJS:
node = [NODEJS, '--experimental-modules', '--loader', './scripts/test/node-esm-loader.mjs']
cmd = node[:]
cmd.append('a.2asm.mjs')
out = run_command(cmd)
fail_if_not_identical(out, '')
cmd = node[:]
cmd.append('a.2asm.asserts.mjs')
out = run_command(cmd, expected_err='', err_ignore='The ESM module loader is experimental')
fail_if_not_identical(out, '')
fail_if_not_identical_to_file(''.join(all_out), expected_file)
def test_wasm2js_output():
for wasm in tests + spec_tests + extra_wasm2js_tests:
if not wasm.endswith('.wast'):
continue
basename = os.path.basename(wasm)
if basename in wasm2js_blacklist:
continue
asm = basename.replace('.wast', '.2asm.js')
expected_file = os.path.join(wasm2js_dir, asm)
if not os.path.exists(expected_file):
continue
print '..', wasm
cmd = WASM2JS + [os.path.join(options.binaryen_test, wasm)]
out = run_command(cmd)
fail_if_not_identical_to_file(out, expected_file)
if not NODEJS and not MOZJS:
print 'No JS interpreters. Skipping spec tests.'
continue
open('a.2asm.mjs', 'w').write(out)
cmd += ['--allow-asserts']
out = 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` module in our tests.
if NODEJS:
node = [
NODEJS, '--experimental-modules', '--loader',
'./scripts/test/node-esm-loader.mjs'
]
cmd = node[:]
cmd.append('a.2asm.mjs')
out = run_command(cmd)
fail_if_not_identical(out, '')
cmd = node[:]
cmd.append('a.2asm.asserts.mjs')
out = run_command(
cmd,
expected_err='',
err_ignore='The ESM module loader is experimental')
fail_if_not_identical(out, '')
def test_wasm2asm_output():
for wasm in tests + spec_tests + extra_tests:
if not wasm.endswith('.wast'):
continue
asm = os.path.basename(wasm).replace('.wast', '.2asm.js')
expected_file = os.path.join(options.binaryen_test, asm)
if not os.path.exists(expected_file):
continue
print '..', wasm
cmd = WASM2ASM + [os.path.join(options.binaryen_test, wasm)]
out = run_command(cmd)
expected = open(expected_file).read()
fail_if_not_identical(out, expected)
if not NODEJS and not MOZJS:
print 'No JS interpreters. Skipping spec tests.'
continue
open('a.2asm.js', 'w').write(out)
cmd += ['--allow-asserts']
out = run_command(cmd)
open('a.2asm.asserts.js', 'w').write(out)
# verify asm.js is valid js
if NODEJS:
out = run_command([NODEJS, 'a.2asm.js'])
fail_if_not_identical(out, '')
out = run_command([NODEJS, 'a.2asm.asserts.js'], expected_err='')
fail_if_not_identical(out, '')
if MOZJS:
# verify asm.js validates, if this is asm.js code (we emit
# almost-asm instead when we need to)
if 'use asm' in open('a.2asm.js').read():
# check only subset of err because mozjs emits timing info
out = run_command(
[MOZJS, '-w', 'a.2asm.js'],
expected_err='Successfully compiled asm.js code',
err_contains=True)
fail_if_not_identical(out, '')
out = run_command([MOZJS, 'a.2asm.asserts.js'],
expected_err='')
fail_if_not_identical(out, '')
def test_wasm2asm_output():
for wasm in tests + [w for w in spec_tests if '.fail' not in w]:
if not wasm.endswith('.wast') or os.path.basename(wasm) in blacklist:
continue
asm = os.path.basename(wasm).replace('.wast', '.2asm.js')
expected_file = os.path.join('test', asm)
if not os.path.exists(expected_file):
continue
print '..', wasm
cmd = WASM2ASM + [os.path.join('test', wasm)]
out = run_command(cmd)
expected = open(expected_file).read()
fail_if_not_identical(out, expected)
if not NODEJS and not MOZJS:
print 'No JS interpreters. Skipping spec tests.'
continue
open('a.2asm.js', 'w').write(out)
cmd += ['--allow-asserts']
out = run_command(cmd)
open('a.2asm.asserts.js', 'w').write(out)
# verify asm.js is valid js
if NODEJS:
out = run_command([NODEJS, 'a.2asm.js'])
fail_if_not_identical(out, '')
out = run_command([NODEJS, 'a.2asm.asserts.js'], expected_err='')
fail_if_not_identical(out, '')
if MOZJS:
# verify asm.js validates
# check only subset of err because mozjs emits timing info
out = run_command([MOZJS, '-w', 'a.2asm.js'],
expected_err='Successfully compiled asm.js code',
err_contains=True)
fail_if_not_identical(out, '')
out = run_command([MOZJS, 'a.2asm.asserts.js'], expected_err='')
fail_if_not_identical(out, '')
def test_asserts_output():
for wasm in assert_tests:
print '..', wasm
asserts = os.path.basename(wasm).replace('.wast.asserts',
'.asserts.js')
traps = os.path.basename(wasm).replace('.wast.asserts', '.traps.js')
asserts_expected_file = os.path.join('test', asserts)
traps_expected_file = os.path.join('test', traps)
cmd = WASM2ASM + [os.path.join('test', wasm), '--allow-asserts']
out = run_command(cmd)
expected = open(asserts_expected_file).read()
fail_if_not_identical(out, expected)
cmd += ['--pedantic']
out = run_command(cmd)
expected = open(traps_expected_file).read()
fail_if_not_identical(out, expected)
def test_wasm2asm():
print '\n[ checking wasm2asm testcases... ]\n'
# tests with i64s, invokes, etc.
blacklist = ['atomics.wast', 'address.wast']
spec_tests = [
os.path.join('spec', t)
for t in sorted(os.listdir(os.path.join('test', 'spec')))
]
for wasm in tests + spec_tests:
if not wasm.endswith('.wast') or os.path.basename(wasm) in blacklist:
continue
asm = os.path.basename(wasm).replace('.wast', '.2asm.js')
expected_file = os.path.join('test', asm)
if not os.path.exists(expected_file):
continue
print '..', wasm
cmd = WASM2ASM + [os.path.join('test', wasm)]
out = run_command(cmd)
# verify output
expected = open(expected_file).read()
fail_if_not_identical(out, expected)
open('a.2asm.js', 'w').write(out)
if NODEJS:
# verify asm.js is valid js
out = run_command([NODEJS, 'a.2asm.js'])
fail_if_not_identical(out, '')
if MOZJS:
# verify asm.js validates
# check only subset of err because mozjs emits timing info
out = run_command([MOZJS, '-w', 'a.2asm.js'],
expected_err='Successfully compiled asm.js code',
err_contains=True)
fail_if_not_identical(out, '')
def test_asm2wasm():
print '[ checking asm2wasm testcases... ]\n'
for asm in tests:
if not asm.endswith('.asm.js'):
continue
for precise in [0, 1, 2]:
for opts in [1, 0]:
cmd = ASM2WASM + [os.path.join(options.binaryen_test, asm)]
wasm = asm.replace('.asm.js', '.fromasm')
if not precise:
cmd += ['--trap-mode=allow', '--ignore-implicit-traps']
wasm += '.imprecise'
elif precise == 2:
cmd += ['--trap-mode=clamp']
wasm += '.clamp'
if not opts:
wasm += '.no-opts'
if precise:
cmd += ['-O0'] # test that -O0 does nothing
else:
cmd += ['-O']
if 'debugInfo' in asm:
cmd += ['-g']
if 'noffi' in asm:
cmd += ['--no-legalize-javascript-ffi']
if precise and opts:
# test mem init importing
open('a.mem', 'wb').write(asm)
cmd += ['--mem-init=a.mem']
if asm[0] == 'e':
cmd += ['--mem-base=1024']
if 'i64' in asm or 'wasm-only' in asm or 'noffi' in asm:
cmd += ['--wasm-only']
wasm = os.path.join(options.binaryen_test, wasm)
print '..', asm, wasm
def do_asm2wasm_test():
actual = run_command(cmd)
# verify output
if not os.path.exists(wasm):
fail_with_error('output .wast file %s does not exist' %
wasm)
expected = open(wasm, 'rb').read()
if actual != expected:
fail(actual, expected)
binary_format_check(wasm, verify_final_result=False)
# test both normally and with pass debug (so each inter-pass state
# is validated)
old_pass_debug = os.environ.get('BINARYEN_PASS_DEBUG')
try:
os.environ['BINARYEN_PASS_DEBUG'] = '1'
print "With BINARYEN_PASS_DEBUG=1:"
do_asm2wasm_test()
del os.environ['BINARYEN_PASS_DEBUG']
print "With BINARYEN_PASS_DEBUG disabled:"
do_asm2wasm_test()
finally:
if old_pass_debug is not None:
os.environ['BINARYEN_PASS_DEBUG'] = old_pass_debug
else:
if 'BINARYEN_PASS_DEBUG' in os.environ:
del os.environ['BINARYEN_PASS_DEBUG']
# verify in wasm
if options.interpreter:
# remove imports, spec interpreter doesn't know what to do with them
subprocess.check_call(WASM_OPT +
['--remove-imports', wasm],
stdout=open('ztemp.wast', 'w'),
stderr=subprocess.PIPE)
proc = subprocess.Popen(
[options.interpreter, 'ztemp.wast'],
stderr=subprocess.PIPE)
out, err = proc.communicate()
if proc.returncode != 0:
try: # to parse the error
reported = err.split(':')[1]
start, end = reported.split('-')
start_line, start_col = map(int, start.split('.'))
lines = open('ztemp.wast').read().split('\n')
print
print '=' * 80
print lines[start_line - 1]
print(' ' * (start_col - 1)) + '^'
print(' ' * (start_col - 2)) + '/_\\'
print '=' * 80
print err
except Exception:
# failed to pretty-print
fail_with_error('wasm interpreter error: ' + err)
fail_with_error('wasm interpreter error')
# verify debug info
if 'debugInfo' in asm:
jsmap = 'a.wasm.map'
cmd += [
'--source-map', jsmap, '--source-map-url',
'http://example.org/' + jsmap, '-o', 'a.wasm'
]
run_command(cmd)
if not os.path.isfile(jsmap):
fail_with_error('Debug info map not created: %s' %
jsmap)
with open(wasm + '.map', 'rb') as expected:
with open(jsmap, 'rb') as actual:
fail_if_not_identical(actual.read(),
expected.read())
with open('a.wasm', 'rb') as binary:
url_section_name = bytearray(
[16]) + bytearray('sourceMappingURL')
url = 'http://example.org/' + jsmap
assert len(url) < 256, 'name too long'
url_section_contents = bytearray([len(url)
]) + bytearray(url)
print url_section_name
binary_contents = bytearray(binary.read())
if url_section_name not in binary_contents:
fail_with_error(
'source map url section not found in binary')
url_section_index = binary_contents.index(
url_section_name)
if url_section_contents not in binary_contents[
url_section_index:]:
fail_with_error(
'source map url not found in url section')
def test_wasm2js_output():
for opt in (0, 1):
for wasm in tests + spec_tests + extra_wasm2js_tests:
if not wasm.endswith('.wast'):
continue
basename = os.path.basename(wasm)
if basename in wasm2js_blacklist:
continue
asm = basename.replace('.wast', '.2asm.js')
expected_file = os.path.join(wasm2js_dir, asm)
if opt:
expected_file += '.opt'
if not os.path.exists(expected_file):
continue
print '..', wasm
t = os.path.join(options.binaryen_test, wasm)
all_out = []
for module, asserts in split_wast(t):
with open('split.wast', 'w') as o:
o.write(module + '\n'.join(asserts))
cmd = WASM2JS + ['split.wast']
if opt:
cmd += ['-O']
if 'emscripten' in wasm:
cmd += ['--emscripten']
out = run_command(cmd)
all_out.append(out)
if not NODEJS and not MOZJS:
print 'No JS interpreters. Skipping spec tests.'
continue
open('a.2asm.mjs', 'w').write(out)
cmd += ['--allow-asserts']
out = run_command(cmd)
# also verify it passes pass-debug verifications
with_pass_debug(lambda: 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 NODEJS:
node = [
NODEJS, '--experimental-modules', '--loader',
'./scripts/test/node-esm-loader.mjs'
]
cmd = node[:]
cmd.append('a.2asm.mjs')
out = run_command(cmd)
fail_if_not_identical(out, '')
cmd = node[:]
cmd.append('a.2asm.asserts.mjs')
out = run_command(
cmd,
expected_err='',
err_ignore='The ESM module loader is experimental')
fail_if_not_identical(out, '')
fail_if_not_identical_to_file(''.join(all_out), expected_file)