def main(args):
parser = argparse.ArgumentParser()
parser.add_argument('-o',
'--out-dir',
metavar='PATH',
help='output directory for files.')
parser.add_argument('-v',
'--verbose',
help='print more diagnotic messages.',
action='store_true')
parser.add_argument('--bindir',
metavar='PATH',
default=find_exe.GetDefaultPath(),
help='directory to search for all executables.')
parser.add_argument(
'--no-error-cmdline',
help='don\'t display the subprocess\'s commandline when' +
' an error occurs',
dest='error_cmdline',
action='store_false')
parser.add_argument('-p',
'--print-cmd',
help='print the commands that are run.',
action='store_true')
parser.add_argument('--run-all-exports', action='store_true')
parser.add_argument('--spec', action='store_true')
parser.add_argument('-t', '--trace', action='store_true')
parser.add_argument('file', help='test file.')
options = parser.parse_args(args)
wast2wasm = utils.Executable(find_exe.GetWast2WasmExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
wast2wasm.AppendOptionalArgs({
'-v': options.verbose,
'--spec': options.spec,
})
wasm_interp = utils.Executable(find_exe.GetWasmInterpExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
wasm_interp.AppendOptionalArgs({
'-v': options.verbose,
'--run-all-exports': options.run_all_exports,
'--spec': options.spec,
'--trace': options.trace,
})
wast2wasm.verbose = options.print_cmd
wasm_interp.verbose = options.print_cmd
with utils.TempDirectory(options.out_dir, 'run-interp-') as out_dir:
new_ext = '.json' if options.spec else '.wasm'
out_file = utils.ChangeDir(utils.ChangeExt(options.file, new_ext),
out_dir)
wast2wasm.RunWithArgs(options.file, '-o', out_file)
wasm_interp.RunWithArgs(out_file)
return 0
def main(args):
parser = argparse.ArgumentParser()
parser.add_argument('-o',
'--out-dir',
metavar='PATH',
help='output directory for files.')
parser.add_argument('--wasm-interp-executable',
metavar='PATH',
help='override wasm-interp executable.')
parser.add_argument('-v',
'--verbose',
help='print more diagnotic messages.',
action='store_true')
parser.add_argument(
'--no-error-cmdline',
help='don\'t display the subprocess\'s commandline when' +
' an error occurs',
dest='error_cmdline',
action='store_false')
parser.add_argument('--run-all-exports', action='store_true')
parser.add_argument('--spec', action='store_true')
parser.add_argument('--use-libc-allocator', action='store_true')
parser.add_argument('--print-cmd',
help='print the commands that are run.',
action='store_true')
parser.add_argument('file', help='test file.')
options = parser.parse_args(args)
gen_wasm = utils.Executable(sys.executable,
GEN_WASM_PY,
error_cmdline=options.error_cmdline)
wasm_interp = utils.Executable(find_exe.GetWasmInterpExecutable(
options.wasm_interp_executable),
error_cmdline=options.error_cmdline)
wasm_interp.AppendOptionalArgs({
'--run-all-exports':
options.run_all_exports,
'--spec':
options.spec,
'--trace':
options.verbose,
'--use-libc-allocator':
options.use_libc_allocator
})
gen_wasm.verbose = options.print_cmd
wasm_interp.verbose = options.print_cmd
with utils.TempDirectory(options.out_dir,
'run-gen-wasm-interp-') as out_dir:
out_file = utils.ChangeDir(utils.ChangeExt(options.file, '.wasm'),
out_dir)
gen_wasm.RunWithArgs(options.file, '-o', out_file)
wasm_interp.RunWithArgs(out_file)
return 0
def main(args):
parser = argparse.ArgumentParser()
parser.add_argument('-v',
'--verbose',
help='print more diagnotic messages.',
action='store_true')
parser.add_argument('-r',
'--relocatable',
action='store_true',
help='final output is relocatable')
parser.add_argument('-o',
'--out-dir',
metavar='PATH',
help='output directory for files.')
parser.add_argument('--bindir',
metavar='PATH',
default=find_exe.GetDefaultPath(),
help='directory to search for all executables.')
parser.add_argument(
'--no-error-cmdline',
help='don\'t display the subprocess\'s commandline when' +
' an error occurs',
dest='error_cmdline',
action='store_false')
parser.add_argument('-p',
'--print-cmd',
help='print the commands that are run.',
action='store_true')
parser.add_argument('--incremental',
help='incremenatly link one object at' +
' a time to produce the final linked binary.',
action='store_true')
parser.add_argument('--debug-names', action='store_true')
parser.add_argument('--dump-verbose', action='store_true')
parser.add_argument('--spec', action='store_true')
parser.add_argument('file', help='test file.')
options = parser.parse_args(args)
wast2wasm = utils.Executable(find_exe.GetWast2WasmExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
wast2wasm.AppendOptionalArgs({
'--debug-names': options.debug_names,
'-v': options.dump_verbose,
})
wasm_link = utils.Executable(find_exe.GetWasmlinkExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
wasm_link.AppendOptionalArgs({
'-v': options.verbose,
'-r': options.relocatable,
})
wasmdump = utils.Executable(find_exe.GetWasmdumpExecutable(options.bindir),
error_cmdline=options.error_cmdline)
wasm_interp = utils.Executable(find_exe.GetWasmInterpExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
wast2wasm.verbose = options.print_cmd
wasm_link.verbose = options.print_cmd
wasmdump.verbose = options.print_cmd
wasm_interp.verbose = options.print_cmd
filename = options.file
with utils.TempDirectory(options.out_dir, 'wasm-link-') as out_dir:
basename = os.path.basename(filename)
basename_noext = os.path.splitext(basename)[0]
out_file = os.path.join(out_dir, basename_noext + '.json')
wast2wasm.RunWithArgs('--spec', '--debug-names', '--no-check', '-r',
'-o', out_file, filename)
wasm_files = utils.GetModuleFilenamesFromSpecJSON(out_file)
wasm_files = [utils.ChangeDir(f, out_dir) for f in wasm_files]
output = os.path.join(out_dir, 'linked.wasm')
if options.incremental:
partially_linked = output + '.partial'
for i, f in enumerate(wasm_files):
if i == 0:
wasm_link.RunWithArgs('-o', output, f)
else:
if os.path.exists(partially_linked):
os.remove(partially_linked)
os.rename(output, partially_linked)
wasm_link.RunWithArgs('-r', '-o', output, partially_linked,
f)
#wasmdump.RunWithArgs('-d', '-h', output)
wasmdump.RunWithArgs('-d', '-x', '-r', '-h', output)
else:
wasm_link.RunWithArgs('-o', output, *wasm_files)
wasmdump.RunWithArgs('-d', '-x', '-r', '-h', output)
if options.spec:
with open(out_file) as json_file:
spec = json.load(json_file, object_pairs_hook=OrderedDict)
spec['commands'] = [
c for c in spec['commands'] if c['type'] != 'module'
]
module = OrderedDict([
('type', 'module'),
('line', 0),
('filename', os.path.basename(output)),
])
spec['commands'].insert(0, module)
with open(out_file, 'wb') as json_file:
json.dump(spec, json_file, indent=4)
wasm_interp.RunWithArgs('--spec', out_file)
def main(args):
parser = argparse.ArgumentParser()
parser.add_argument('-a',
'--arg',
help='additional args to pass to executable',
action='append')
parser.add_argument('-o',
'--out-dir',
metavar='PATH',
help='output directory for files.')
parser.add_argument('--exe-dir',
metavar='PATH',
help='directory to search for all executables. '
'This can be overridden by the other executable '
'flags.')
parser.add_argument('-e',
'--sexpr-wasm-executable',
metavar='PATH',
help='override executable.')
parser.add_argument('--js-executable',
metavar='PATH',
help='override js executable.')
parser.add_argument('--wasm-wast-executable',
metavar='PATH',
help='override wasm-wast executable.')
parser.add_argument('--wasm-interp-executable',
metavar='PATH',
help='override wasm-interp executable.')
parser.add_argument('-v',
'--verbose',
help='print more diagnotic messages.',
action='store_true')
parser.add_argument('-l',
'--list',
help='list all tests.',
action='store_true')
parser.add_argument('-r',
'--rebase',
help='rebase a test to its current output.',
action='store_true')
parser.add_argument('-j',
'--jobs',
help='number of jobs to use to run tests',
type=int,
default=multiprocessing.cpu_count())
parser.add_argument('-t',
'--timeout',
type=float,
default=DEFAULT_TIMEOUT,
help='per test timeout in seconds')
parser.add_argument('--no-roundtrip',
help='don\'t run roundtrip.py on all tests',
action='store_false',
default=True,
dest='roundtrip')
parser.add_argument('patterns',
metavar='pattern',
nargs='*',
help='test patterns.')
options = parser.parse_args(args)
if options.patterns:
pattern_re = '|'.join(
fnmatch.translate('*%s*' % p) for p in options.patterns)
else:
pattern_re = '.*'
test_names = findtests.FindTestFiles(SCRIPT_DIR, '.txt', pattern_re)
if options.list:
for test_name in test_names:
print test_name
return 0
if not test_names:
print 'no tests match that filter'
return 1
if options.exe_dir:
if not options.sexpr_wasm_executable:
options.sexpr_wasm_executable = os.path.join(
options.exe_dir, 'sexpr-wasm')
if not options.wasm_wast_executable:
options.wasm_wast_executable = os.path.join(
options.exe_dir, 'wasm-wast')
if not options.wasm_interp_executable:
options.wasm_interp_executable = os.path.join(
options.exe_dir, 'wasm-interp')
variables = {
'sexpr-wasm':
find_exe.GetSexprWasmExecutable(options.sexpr_wasm_executable),
'js':
find_exe.GetJSExecutable(options.js_executable),
'wasm-wast':
find_exe.GetWasmWastExecutable(options.wasm_wast_executable),
'wasm-interp':
find_exe.GetWasmInterpExecutable(options.wasm_interp_executable),
}
status = Status(options.verbose)
infos = GetAllTestInfo(test_names, status)
inq = multiprocessing.Queue()
test_count = 0
for info in infos:
if info.skip:
status.Skipped(info)
continue
inq.put(info)
test_count += 1
if options.roundtrip:
if info.ShouldCreateRoundtrip():
inq.put(info.CreateRoundtripInfo())
test_count += 1
outq = multiprocessing.Queue()
num_proc = options.jobs
status.Start(test_count)
if options.out_dir:
out_dir = options.out_dir
out_dir_is_temp = False
if not os.path.exists(out_dir):
os.makedirs(out_dir)
else:
out_dir = tempfile.mkdtemp(prefix='sexpr-wasm-')
out_dir_is_temp = True
try:
for i, p in enumerate(range(num_proc)):
args = (i, options, variables, inq, outq, out_dir)
proc = multiprocessing.Process(target=ProcessWorker, args=args)
proc.start()
finished_tests = 0
while finished_tests < test_count:
try:
info, result = outq.get(True, 0.01)
except Queue.Empty:
status.UpdateTimer()
continue
finished_tests += 1
HandleTestResult(status, info, result, options.rebase)
except KeyboardInterrupt:
while multiprocessing.active_children():
time.sleep(0.1)
finally:
while multiprocessing.active_children():
time.sleep(0.1)
if out_dir_is_temp:
shutil.rmtree(out_dir)
status.Clear()
ret = 0
if status.failed:
sys.stderr.write('**** FAILED %s\n' % ('*' * (80 - 14)))
for info in status.failed_tests:
sys.stderr.write('- %s\n' % info.name)
ret = 1
status.Print()
return ret
def main(args):
parser = argparse.ArgumentParser()
parser.add_argument('-o',
'--out-dir',
metavar='PATH',
help='output directory for files.')
parser.add_argument('--wast2wasm',
metavar='PATH',
help='override wast2wasm executable.')
parser.add_argument('--wasmdump',
metavar='PATH',
help='override wast2wasm executable.')
parser.add_argument('--wasm-interp',
metavar='PATH',
help='override wasm-interp executable.')
parser.add_argument('-v',
'--verbose',
help='print more diagnotic messages.',
action='store_true')
parser.add_argument(
'--no-error-cmdline',
help='don\'t display the subprocess\'s commandline when' +
' an error occurs',
dest='error_cmdline',
action='store_false')
parser.add_argument('-p',
'--print-cmd',
help='print the commands that are run.',
action='store_true')
parser.add_argument('--run-all-exports', action='store_true')
parser.add_argument('--spec', action='store_true')
parser.add_argument('--use-libc-allocator', action='store_true')
parser.add_argument('file', help='test file.')
options = parser.parse_args(args)
wast2wasm = utils.Executable(find_exe.GetWast2WasmExecutable(
options.wast2wasm),
error_cmdline=options.error_cmdline)
wast2wasm.AppendOptionalArgs({
'-v':
options.verbose,
'--spec':
options.spec,
'--use-libc-allocator':
options.use_libc_allocator
})
wasmdump = utils.Executable(find_exe.GetWasmdumpExecutable(
options.wasmdump),
error_cmdline=options.error_cmdline)
wasm_interp = utils.Executable(find_exe.GetWasmInterpExecutable(
options.wasm_interp),
error_cmdline=options.error_cmdline)
wasm_interp.AppendOptionalArgs({
'--run-all-exports':
options.run_all_exports,
'--spec':
options.spec,
'--trace':
options.verbose,
'--use-libc-allocator':
options.use_libc_allocator
})
wast2wasm.verbose = options.print_cmd
wasm_interp.verbose = options.print_cmd
with utils.TempDirectory(options.out_dir, 'run-interp-') as out_dir:
new_ext = '.json' if options.spec else '.wasm'
out_file = utils.ChangeDir(utils.ChangeExt(options.file, new_ext),
out_dir)
wast2wasm.RunWithArgs(options.file, '-o', out_file)
if options.spec:
wasm_files = utils.GetModuleFilenamesFromSpecJSON(out_file)
wasm_files = [utils.ChangeDir(f, out_dir) for f in wasm_files]
else:
wasm_files = [out_file]
for wasm_file in wasm_files:
wasmdump.RunWithArgs(wasm_file)
wasm_interp.RunWithArgs(out_file)
return 0
def main(args):
parser = argparse.ArgumentParser()
parser.add_argument('-o',
'--out-dir',
metavar='PATH',
help='output directory for files.')
parser.add_argument('-v',
'--verbose',
help='print more diagnotic messages.',
action='store_true')
parser.add_argument('--bindir',
metavar='PATH',
default=find_exe.GetDefaultPath(),
help='directory to search for all executables.')
parser.add_argument(
'--no-error-cmdline',
help='don\'t display the subprocess\'s commandline when' +
' an error occurs',
dest='error_cmdline',
action='store_false')
parser.add_argument('-p',
'--print-cmd',
help='print the commands that are run.',
action='store_true')
parser.add_argument('--run-all-exports', action='store_true')
parser.add_argument('--host-print', action='store_true')
parser.add_argument('-t', '--trace', action='store_true')
parser.add_argument('file', help='test file.')
parser.add_argument('--enable-saturating-float-to-int',
action='store_true')
parser.add_argument('--enable-threads', action='store_true')
parser.add_argument('--trap-on-failed-comp', action='store_true')
options = parser.parse_args(args)
wast_tool = None
interp_tool = None
interp_jit_tool = None
wast_tool = utils.Executable(find_exe.GetWat2WasmExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
interp_tool = utils.Executable(find_exe.GetWasmInterpExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
interp_tool.AppendOptionalArgs({
'--host-print':
options.host_print,
'--run-all-exports':
options.run_all_exports,
})
interp_jit_tool = utils.Executable(find_exe.GetWasmInterpExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
interp_jit_tool.AppendOptionalArgs({
'--host-print':
options.host_print,
'--run-all-exports':
options.run_all_exports,
})
wast_tool.AppendOptionalArgs({
'-v': options.verbose,
'--enable-saturating-float-to-int':
options.enable_saturating_float_to_int,
'--enable-threads': options.enable_threads,
})
interp_tool.AppendOptionalArgs({
'-v':
options.verbose,
'--run-all-exports':
options.run_all_exports,
'--trace':
options.trace,
'--enable-saturating-float-to-int':
options.enable_saturating_float_to_int,
'--enable-threads':
options.enable_threads,
'--disable-jit':
True,
})
interp_jit_tool.AppendOptionalArgs({
'-v':
options.verbose,
'--run-all-exports':
options.run_all_exports,
'--trace':
options.trace,
'--enable-saturating-float-to-int':
options.enable_saturating_float_to_int,
'--enable-threads':
options.enable_threads,
'--trap-on-failed-comp':
options.trap_on_failed_comp,
})
wast_tool.verbose = options.print_cmd
interp_tool.verbose = options.print_cmd
interp_jit_tool.verbose = options.print_cmd
with utils.TempDirectory(options.out_dir, 'run-jit-perform-') as out_dir:
if not options.file.endswith('.wasm'):
new_ext = '.wasm'
out_file = utils.ChangeDir(utils.ChangeExt(options.file, new_ext),
out_dir)
wast_tool.RunWithArgs(options.file, '-o', out_file)
else:
out_file = options.file
start = time.time()
interp_out = interp_tool.RunWithArgsForStdout(out_file)
interp_time = time.time() - start
start = time.time()
jit_out = interp_jit_tool.RunWithArgsForStdout(out_file)
jit_time = time.time() - start
print("Interpreter: {}\nJIT: {}".format(interp_time, jit_time))
expected_lines = [line for line in interp_out.splitlines() if line]
actual_lines = [line for line in jit_out.splitlines() if line]
diff_lines = list(
difflib.unified_diff(expected_lines,
actual_lines,
fromfile='expected',
tofile='actual',
lineterm=''))
msg = ""
if len(diff_lines) > 0:
msg += 'STDOUT MISMATCH:\n' + '\n'.join(diff_lines) + '\n'
if msg:
raise Error(msg)
return 0
def main(args):
parser = argparse.ArgumentParser()
parser.add_argument('-o',
'--out-dir',
metavar='PATH',
help='output directory for files.')
parser.add_argument('-v',
'--verbose',
help='print more diagnotic messages.',
action='store_true')
parser.add_argument('--bindir',
metavar='PATH',
default=find_exe.GetDefaultPath(),
help='directory to search for all executables.')
parser.add_argument(
'--no-error-cmdline',
help='don\'t display the subprocess\'s commandline when' +
' an error occurs',
dest='error_cmdline',
action='store_false')
parser.add_argument('-p',
'--print-cmd',
help='print the commands that are run.',
action='store_true')
parser.add_argument('--run-all-exports', action='store_true')
parser.add_argument('--host-print', action='store_true')
parser.add_argument('--spec', action='store_true')
parser.add_argument('-t', '--trace', action='store_true')
parser.add_argument('file', help='test file.')
parser.add_argument('--enable-saturating-float-to-int',
action='store_true')
parser.add_argument('--enable-threads', action='store_true')
parser.add_argument('--disable-jit', action='store_true')
parser.add_argument('--trap-on-failed-comp', action='store_true')
options = parser.parse_args(args)
wast_tool = None
interp_tool = None
if options.spec:
wast_tool = utils.Executable(find_exe.GetWast2JsonExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
interp_tool = utils.Executable(find_exe.GetSpectestInterpExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
else:
wast_tool = utils.Executable(find_exe.GetWat2WasmExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
interp_tool = utils.Executable(find_exe.GetWasmInterpExecutable(
options.bindir),
error_cmdline=options.error_cmdline)
interp_tool.AppendOptionalArgs({
'--host-print':
options.host_print,
'--run-all-exports':
options.run_all_exports,
})
wast_tool.AppendOptionalArgs({
'-v': options.verbose,
'--enable-saturating-float-to-int':
options.enable_saturating_float_to_int,
'--enable-threads': options.enable_threads,
})
interp_tool.AppendOptionalArgs({
'-v':
options.verbose,
'--run-all-exports':
options.run_all_exports,
'--trap-on-failed-comp':
options.trap_on_failed_comp,
'--trace':
options.trace,
'--enable-saturating-float-to-int':
options.enable_saturating_float_to_int,
'--enable-threads':
options.enable_threads,
'--disable-jit':
options.disable_jit,
'--no-stack-trace':
not options.spec
})
wast_tool.verbose = options.print_cmd
interp_tool.verbose = options.print_cmd
with utils.TempDirectory(options.out_dir, 'run-interp-') as out_dir:
new_ext = '.json' if options.spec else '.wasm'
out_file = utils.ChangeDir(utils.ChangeExt(options.file, new_ext),
out_dir)
wast_tool.RunWithArgs(options.file, '-o', out_file)
interp_tool.RunWithArgs(out_file)
return 0
