mirror of https://github.com/svaarala/duktape.git
Browse Source
The matrix compile test relied on DUK_OPT_xxx and needs to be reworked if it is added back.pull/1255/head
Sami Vaarala
8 years ago
2 changed files with 0 additions and 575 deletions
@ -1,561 +0,0 @@ |
|||
#!/usr/bin/env python2 |
|||
# |
|||
# Compile test for a lot of option combinations |
|||
# |
|||
|
|||
# XXX: rewrite as nodejs and parallelize (large indices handling need bigint) |
|||
|
|||
import os |
|||
import sys |
|||
import time |
|||
import datetime |
|||
import json |
|||
import random |
|||
import optparse |
|||
import subprocess |
|||
import StringIO # no need for cStringIO |
|||
|
|||
# |
|||
# Test matrix helper: given a specification of combinations, count the |
|||
# total number of combinations and allow a specific combination to be |
|||
# fetched using an index. This avoids creating the combinations explicitly |
|||
# and also allows random sampling of the combination space (which can be |
|||
# very large). |
|||
# |
|||
|
|||
# Select one: Select([ 1, 2, 3 ]) -> [ 1 ], [ 2 ], [ 3 ] |
|||
class Select: |
|||
val = None |
|||
|
|||
def __init__(self, val): |
|||
self.val = val |
|||
|
|||
# Combine: Combine([ 1, 2 ], 'foo') -> [ 1 'foo' ], [ 2 'foo' ] |
|||
class Combine: |
|||
val = None |
|||
|
|||
def __init__(self, val): |
|||
self.val = val |
|||
|
|||
# Subset: Subset([ 'foo', 'bar' ]) -> Combine([ [ '', 'foo' ], [ '', 'bar' ] ]) |
|||
# -> [ '' '' ], [ 'foo' '' ], [ '' 'bar' ], [ 'foo' 'bar' ] |
|||
class Subset: |
|||
val = None |
|||
|
|||
def __init__(self, val): |
|||
self.val = val |
|||
|
|||
# Sequence: Sequence([ 'foo', 'bar', 'quux' ]) -> [ 'foo', 'bar', 'quux' ] |
|||
# Plain list is also interpreted as a Sequence. |
|||
class Sequence: |
|||
val = None |
|||
|
|||
def __init__(self, val): |
|||
self.val = val |
|||
|
|||
# Prepare a combination lookup structure. |
|||
def prepcomb(val): |
|||
if isinstance(val, (str, unicode)): |
|||
return { 'size': 1, 'value': val, 'type': 'terminal' } |
|||
if isinstance(val, Sequence): |
|||
return { 'size': 1, 'value': val.val, 'type': 'sequence' } |
|||
if isinstance(val, list): |
|||
# interpret as Sequence |
|||
return { 'size': 1, 'value': val, 'type': 'sequence' } |
|||
if isinstance(val, Select): |
|||
nodes = [] |
|||
size = 0 |
|||
for i in val.val: |
|||
node = prepcomb(i) |
|||
nodes.append(node) |
|||
size += node['size'] |
|||
return { 'size': size, 'value': nodes, 'type': 'select' } |
|||
if isinstance(val, Combine): |
|||
nodes = [] |
|||
size = 1 |
|||
for i in val.val: |
|||
node = prepcomb(i) |
|||
nodes.append(node) |
|||
size *= node['size'] |
|||
return { 'size': size, 'value': nodes, 'type': 'combine' } |
|||
if isinstance(val, Subset): |
|||
nodes = [] |
|||
size = 1 |
|||
for i in val.val: |
|||
node = prepcomb(i) |
|||
nodes.append(node) |
|||
size *= (node['size'] + 1) # value or not present |
|||
return { 'size': size, 'value': nodes, 'type': 'subset' } |
|||
raise Exception('invalid argument') |
|||
|
|||
# Return number of combinations for input lists. |
|||
def countcombinations(prepped): |
|||
return prepped['size'] |
|||
|
|||
# Return a combination for index, for index in [0,countcombinations(lists)[. |
|||
# This allows random selection of combinations using a PRNG. |
|||
def getcomb(prepped, index): |
|||
if prepped['type'] == 'terminal': |
|||
return [ prepped['value'] ], index |
|||
if prepped['type'] == 'sequence': |
|||
return prepped['value'], index |
|||
if prepped['type'] == 'select': |
|||
idx = index % prepped['size'] |
|||
index = index / prepped['size'] |
|||
|
|||
for i in prepped['value']: |
|||
if idx >= i['size']: |
|||
idx -= i['size'] |
|||
continue |
|||
ret, ign_index = getcomb(i, idx) |
|||
return ret, index |
|||
|
|||
raise Exception('should not be here') |
|||
if prepped['type'] == 'combine': |
|||
ret = [] |
|||
for i in prepped['value']: |
|||
idx = index % i['size'] |
|||
index = index / i['size'] |
|||
tmp, tmp_index = getcomb(i, idx) |
|||
ret.append(tmp) |
|||
return ret, index |
|||
if prepped['type'] == 'subset': |
|||
ret = [] |
|||
for i in prepped['value']: |
|||
idx = index % (i['size'] + 1) |
|||
index = index / (i['size'] + 1) |
|||
if idx == 0: |
|||
# no value |
|||
ret.append('') |
|||
else: |
|||
tmp, tmp_index = getcomb(i, idx - 1) |
|||
ret.append(tmp) |
|||
return ret, index |
|||
raise Exception('invalid prepped value') |
|||
|
|||
def flatten(v): |
|||
if isinstance(v, (str, unicode)): |
|||
return [ v ] |
|||
if isinstance(v, list): |
|||
ret = [] |
|||
for i in v: |
|||
ret += flatten(i) |
|||
return ret |
|||
raise Exception('invalid value: %s' % repr(v)) |
|||
|
|||
|
|||
def getcombination(val, index): |
|||
res, res_index = getcomb(val, index) |
|||
if res_index != 0: |
|||
sys.stderr.write('WARNING: index not consumed entirely, invalid index? (input index %d, output index %d)\n' % (index, res_index)) |
|||
|
|||
return res |
|||
|
|||
# Generate all combinations. |
|||
def getcombinations(val): |
|||
res = [] |
|||
for i in xrange(countcombinations(val)): |
|||
res.append(getcombination(val, i)) |
|||
return res |
|||
|
|||
# |
|||
# Test matrix |
|||
# |
|||
|
|||
def create_matrix(fn_duk): |
|||
# A lot of compiler versions are used, must install at least: |
|||
# |
|||
# gcc-4.6 |
|||
# gcc-4.7 |
|||
# gcc-4.8 |
|||
# gcc-4.6-multilib |
|||
# g++-4.6-multilib |
|||
# gcc-4.7-multilib |
|||
# g++-4.7-multilib |
|||
# gcc-4.8-multilib |
|||
# g++-4.8-multilib |
|||
# gcc-multilib |
|||
# g++-multilib |
|||
# llvm-gcc-4.6 |
|||
# llvm-gcc-4.7 |
|||
# llvm-3.4 |
|||
# clang |
|||
# |
|||
# The set of compilers tested is distribution specific and not ery |
|||
# stable, so you may need to edit the compilers manually. |
|||
|
|||
gcc_cmd_dialect_options = Select([ |
|||
# Some dialects and architectures are only available for newer g++ versions |
|||
Combine([ |
|||
# -m32 with older llvm causes self test failure (double union) |
|||
Select([ 'llvm-gcc' ]), |
|||
Select([ '-m64' ]), |
|||
Select([ |
|||
'', |
|||
'-std=c89', |
|||
'-std=c99', |
|||
[ '-std=c99', '-pedantic' ] |
|||
]) |
|||
]), |
|||
Combine([ |
|||
Select([ 'gcc', 'gcc-4.6' ]), |
|||
Select([ '-m64', '-m32' ]), |
|||
Select([ |
|||
'', |
|||
'-std=c89', |
|||
'-std=c99', |
|||
[ '-std=c99', '-pedantic' ] |
|||
]) |
|||
]), |
|||
Combine([ |
|||
Select([ 'gcc-4.7', 'gcc-4.8' ]), |
|||
Select([ '-m64', '-m32', '-mx32' ]), |
|||
Select([ |
|||
'', |
|||
'-std=c89', |
|||
'-std=c99', |
|||
[ '-std=c99', '-pedantic' ] |
|||
]) |
|||
]), |
|||
]) |
|||
gxx_cmd_dialect_options = Select([ |
|||
# Some dialects and architectures are only available for newer g++ versions |
|||
Combine([ |
|||
Select([ 'llvm-g++' ]), |
|||
Select([ '-m64' ]), |
|||
Select([ |
|||
'', |
|||
'-std=c++98', |
|||
[ '-std=c++11', '-pedantic' ] |
|||
]) |
|||
]), |
|||
Combine([ |
|||
Select([ 'g++', 'g++-4.6' ]), |
|||
Select([ '-m64', '-m32' ]), |
|||
Select([ |
|||
'', |
|||
'-std=c++98', |
|||
]) |
|||
]), |
|||
Combine([ |
|||
Select([ 'g++-4.7', 'g++-4.8' ]), |
|||
Select([ '-m64', '-m32', '-mx32' ]), |
|||
Select([ |
|||
'', |
|||
'-std=c++98', |
|||
[ '-std=c++11', '-pedantic' ] |
|||
]) |
|||
]), |
|||
Combine([ |
|||
Select([ 'g++', 'g++-4.8' ]), |
|||
Select([ '-m64', '-m32', '-mx32' ]), |
|||
Select([ |
|||
'-std=c++1y', |
|||
'-std=gnu++1y' |
|||
]) |
|||
]), |
|||
]) |
|||
gcc_gxx_debug_options = Select([ |
|||
'', |
|||
[ '-g', '-ggdb' ] |
|||
]) |
|||
gcc_gxx_warning_options = Select([ |
|||
'', |
|||
#'-Wall', |
|||
[ '-Wall', '-Wextra' ] |
|||
#XXX: -Wfloat-equal |
|||
# [ '-Wall', '-Wextra', '-Werror' ] |
|||
]) |
|||
gcc_gxx_optimization_options = Select([ |
|||
'-O0', |
|||
'-O1', |
|||
'-O2', |
|||
|
|||
# -O3 and -O4 produces spurious warnings on gcc 4.8.1, e.g. "error: assuming signed overflow does not occur when assuming that (X - c) > X is always false [-Werror=strict-overflow]" |
|||
# Not sure what causes these, but perhaps GCC converts signed comparisons into subtractions and then runs into: https://gcc.gnu.org/wiki/FAQ#signed_overflow |
|||
|
|||
[ '-O3', '-fno-strict-overflow' ], |
|||
#'-O3' |
|||
|
|||
[ '-O4', '-fno-strict-overflow' ], |
|||
#'-O4' |
|||
|
|||
'-Os' |
|||
]) |
|||
clang_cmd_dialect_options = Select([ |
|||
Combine([ |
|||
'clang', |
|||
Select([ '-m64', '-m32' ]), |
|||
Select([ |
|||
'', |
|||
'-std=c89', |
|||
'-std=c99', |
|||
[ '-std=c99', '-pedantic' ] |
|||
]) |
|||
]) |
|||
]) |
|||
clang_debug_options = Select([ |
|||
'', |
|||
[ '-g', '-ggdb' ] |
|||
]) |
|||
clang_warning_options = Select([ |
|||
'', |
|||
[ '-Wall', '-Wextra' ], |
|||
[ '-Wall', '-Wextra', '-Wcast-align' ] |
|||
#XXX: -Wfloat-equal |
|||
#[ '-Wall', '-Wextra', '-Werror' ] |
|||
]) |
|||
clang_optimization_options = Select([ |
|||
'-O0', |
|||
'-O1', |
|||
'-O2', |
|||
'-O3', |
|||
#'-O4', |
|||
'-Os' |
|||
]) |
|||
|
|||
# Feature options in suitable chunks that can be subsetted arbitrarily. |
|||
|
|||
duktape_options = Subset([ |
|||
Select([ '-DDUK_OPT_NO_REFERENCE_COUNTING', |
|||
'-DDUK_OPT_NO_MARK_AND_SWEEP', |
|||
'-DDUK_OPT_GC_TORTURE' ]), |
|||
'-DDUK_OPT_SHUFFLE_TORTURE', |
|||
'-DDUK_OPT_NO_VOLUNTARY_GC', |
|||
'-DDUK_OPT_NO_PACKED_TVAL', |
|||
Select([ '', '-DDUK_OPT_FORCE_ALIGN=4', '-DDUK_OPT_FORCE_ALIGN=8' ]), |
|||
'-DDUK_OPT_NO_TRACEBACKS', |
|||
'-DDUK_OPT_NO_VERBOSE_ERRORS', |
|||
'-DDUK_OPT_PARANOID_ERRORS', |
|||
'-DDUK_OPT_NO_MS_RESIZE_STRINGTABLE', |
|||
'-DDUK_OPT_NO_STRICT_DECL', |
|||
'-DDUK_OPT_NO_REGEXP_SUPPORT', |
|||
'-DDUK_OPT_NO_ES6_REGEXP_SYNTAX', |
|||
'-DDUK_OPT_NO_SOURCE_NONBMP', |
|||
'-DDUK_OPT_STRICT_UTF8_SOURCE', |
|||
'-DDUK_OPT_NO_SECTION_B', |
|||
'-DDUK_OPT_NO_JX', |
|||
'-DDUK_OPT_NO_JC', |
|||
'-DDUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT', |
|||
'-DDUK_OPT_NO_NONSTD_FUNC_STMT', |
|||
'-DDUK_OPT_NONSTD_FUNC_CALLER_PROPERTY', |
|||
'-DDUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY', |
|||
'-DDUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT', |
|||
'-DDUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER', |
|||
'-DDUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER', |
|||
'-DDUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029', |
|||
'-DDUK_OPT_NO_BYTECODE_DUMP_SUPPORT', |
|||
'-DDUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY', |
|||
'-DDUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF', |
|||
'-DDUK_OPT_NO_ES6_PROXY', |
|||
'-DDUK_OPT_NO_ZERO_BUFFER_DATA', |
|||
'-DDUK_OPT_LIGHTFUNC_BUILTINS', |
|||
'-DDUK_OPT_ASSERTIONS', |
|||
[ '-DDUK_OPT_DEBUG', '-DDUK_OPT_DEBUG_WRITE(level,file,line,func,msg)=do {fprintf(stderr, "%ld %s %ld %s %s\\n", (long) (level), (file), (long) (line), (func), (msg));} while(0)', '-DDUK_OPT_DPRINT', '-DDUK_OPT_DDDPRINT' ], |
|||
'-DDUK_OPT_SELF_TESTS', |
|||
[ '-DDUK_OPT_STRTAB_CHAIN', '-DDUK_OPT_STRTAB_CHAIN_SIZE=64' ], |
|||
|
|||
# DUK_OPT_DEBUGGER_SUPPORT depends on having pc2line and |
|||
# interrupt counter, so avoid invalid combinations. |
|||
Select([ |
|||
Subset([ '-DDUK_OPT_NO_PC2LINE', '-DDUK_OPT_INTERRUPT_COUNTER' ]), |
|||
[ '-DDUK_OPT_DEBUGGER_SUPPORT', '-DDUK_OPT_INTERRUPT_COUNTER' ] |
|||
]), |
|||
'-DDUK_OPT_DEBUGGER_FWD_LOGGING', |
|||
'-DDUK_OPT_DEBUGGER_DUMPHEAP', |
|||
'-DDUK_OPT_DEBUGGER_INSPECT', |
|||
'-DDUK_OPT_NO_DEBUGGER_THROW_NOTIFY', |
|||
'-DDUK_OPT_DEBUGGER_PAUSE_UNCAUGHT', |
|||
'-DDUK_OPT_JSON_STRINGIFY_FASTPATH' |
|||
|
|||
# XXX: 16-bit options |
|||
]) |
|||
|
|||
# XXX: DUK_USE_LEXER_SLIDING_WINDOW |
|||
|
|||
# The final command is compiler specific because e.g. include path |
|||
# and link option syntax could (in principle) differ between compilers. |
|||
|
|||
gcc_cmd_matrix = Combine([ |
|||
gcc_cmd_dialect_options, |
|||
gcc_gxx_debug_options, |
|||
gcc_gxx_warning_options, |
|||
gcc_gxx_optimization_options, |
|||
duktape_options, |
|||
[ '-DDUK_CMDLINE_PRINTALERT_SUPPORT', '-Isrc', '-Iextras/print-alert', 'src/duktape.c', 'extras/print-alert/duk_print_alert.c', 'examples/cmdline/duk_cmdline.c', '-o', fn_duk, '-lm' ] |
|||
]) |
|||
|
|||
gxx_cmd_matrix = Combine([ |
|||
gxx_cmd_dialect_options, |
|||
gcc_gxx_debug_options, |
|||
gcc_gxx_warning_options, |
|||
gcc_gxx_optimization_options, |
|||
duktape_options, |
|||
[ '-DDUK_CMDLINE_PRINTALERT_SUPPORT', '-Isrc', '-Iextras/print-alert', 'src/duktape.c', 'extras/print-alert/duk_print_alert.c', 'examples/cmdline/duk_cmdline.c', '-o', fn_duk, '-lm' ] |
|||
]) |
|||
|
|||
clang_cmd_matrix = Combine([ |
|||
clang_cmd_dialect_options, |
|||
clang_debug_options, |
|||
clang_warning_options, |
|||
clang_optimization_options, |
|||
duktape_options, |
|||
[ '-DDUK_CMDLINE_PRINTALERT_SUPPORT', '-Isrc', '-Iextras/print-alert', 'src/duktape.c', 'extras/print-alert/duk_print_alert.c', 'examples/cmdline/duk_cmdline.c', '-o', fn_duk, '-lm' ] |
|||
]) |
|||
|
|||
matrix = Select([ gcc_cmd_matrix, gxx_cmd_matrix, clang_cmd_matrix ]) |
|||
return matrix |
|||
|
|||
# |
|||
# Main |
|||
# |
|||
|
|||
def check_unlink(filename): |
|||
if os.path.exists(filename): |
|||
os.unlink(filename) |
|||
|
|||
def main(): |
|||
# XXX: add option for testcase(s) to run? |
|||
# XXX: add valgrind support, restrict to -m64 compilation? |
|||
# XXX: proper tempfile usage and cleanup |
|||
|
|||
time_str = str(long(time.time() * 1000.0)) |
|||
|
|||
parser = optparse.OptionParser() |
|||
parser.add_option('--count', dest='count', default='1000') |
|||
parser.add_option('--seed', dest='seed', default='default_seed_' + time_str) |
|||
parser.add_option('--out-results-json', dest='out_results_json', default='/tmp/matrix_results%s.json' % time_str) |
|||
parser.add_option('--out-failed', dest='out_failed', default='/tmp/matrix_failed%s.txt' % time_str) |
|||
parser.add_option('--verbose', dest='verbose', default=False, action='store_true') |
|||
(opts, args) = parser.parse_args() |
|||
|
|||
fn_testjs = '/tmp/test%s.js' % time_str |
|||
fn_duk = '/tmp/duk%s' % time_str |
|||
|
|||
# Avoid any optional features (like JSON or RegExps) in the test. |
|||
# Don't make the test very long, as it executes very slowly when |
|||
# DUK_OPT_DDDPRINT and DUK_OPT_ASSERTIONS are enabled. |
|||
|
|||
f = open(fn_testjs, 'wb') |
|||
f.write(''' |
|||
// Fibonacci using try-catch, exercises setjmp/longjmp a lot |
|||
function fibthrow(n) { |
|||
var f1, f2; |
|||
if (n === 0) { throw 0; } |
|||
if (n === 1) { throw 1; } |
|||
try { fibthrow(n-1); } catch (e) { f1 = e; } |
|||
try { fibthrow(n-2); } catch (e) { f2 = e; } |
|||
throw f1 + f2; |
|||
} |
|||
print('Hello world'); |
|||
print(1 + 2); |
|||
print(Math.PI); // tests constant endianness |
|||
print(JSON.stringify({ foo: 'bar' })); |
|||
try { fibthrow(9); } catch (e) { print(e); } |
|||
''') |
|||
f.close() |
|||
expect = 'Hello world\n3\n3.141592653589793\n{"foo":"bar"}\n34\n' |
|||
|
|||
print('Using seed: ' + repr(opts.seed)) |
|||
random.seed(opts.seed) |
|||
matrix = create_matrix(fn_duk) |
|||
prepped = prepcomb(matrix) |
|||
# print(json.dumps(prepped, indent=4)) |
|||
# print(json.dumps(getcombinations(prepped), indent=4)) |
|||
numcombinations = countcombinations(prepped) |
|||
|
|||
# The number of combinations is large so do (pseudo) random |
|||
# testing over the matrix. Ideally we'd avoid re-testing the |
|||
# same combination twice, but with the matrix space in billions |
|||
# this doesn't need to be checked. |
|||
|
|||
res = [] |
|||
failed = [] |
|||
for i in xrange(long(opts.count)): |
|||
fail = False |
|||
idx = random.randrange(0, numcombinations) |
|||
cmd = getcombination(prepped, idx) |
|||
#cmd = getcombination(prepped, idx) |
|||
compile_command = flatten(cmd) |
|||
compile_command = [ elem for elem in compile_command if elem != '' ] # remove empty strings |
|||
|
|||
print('%d/%d (combination %d, count %d)' % (i + 1, long(opts.count), idx, numcombinations)) |
|||
#print('%d/%d (combination %d, count %d) %s' % (i + 1, long(opts.count), idx, numcombinations, repr(compile_command))) |
|||
if opts.verbose: |
|||
print(' '.join(compile_command)) |
|||
|
|||
check_unlink(fn_duk) |
|||
#print(repr(compile_command)) |
|||
compile_p = subprocess.Popen(compile_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE) |
|||
compile_stdout, compile_stderr = compile_p.communicate() |
|||
compile_exitcode = compile_p.returncode |
|||
|
|||
if compile_exitcode != 0: |
|||
fail = True |
|||
else: |
|||
if not os.path.exists(fn_duk): |
|||
print('*** WARNING: compile success but no %s ***' % fn_duk) |
|||
|
|||
run_command = [ fn_duk, fn_testjs ] |
|||
if fail: |
|||
run_stdout = None |
|||
run_stderr = None |
|||
run_exitcode = 1 |
|||
else: |
|||
run_p = subprocess.Popen(run_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE) |
|||
run_stdout, run_stderr = run_p.communicate() |
|||
run_exitcode = run_p.returncode |
|||
|
|||
if run_exitcode != 0: |
|||
fail = True |
|||
if run_stdout != expect: |
|||
fail = True |
|||
|
|||
if fail: |
|||
print('------------------------------------------------------------------------------') |
|||
print('*** FAILED: %s' % repr(compile_command)) |
|||
print(' '.join(compile_command)) |
|||
failed.append(' '.join(compile_command)) |
|||
|
|||
print('COMPILE STDOUT:') |
|||
print(compile_stdout) |
|||
print('COMPILE STDERR:') |
|||
print(compile_stderr) |
|||
print('RUN STDOUT:') |
|||
print(run_stdout) |
|||
print('RUN STDERR:') |
|||
print(run_stderr) |
|||
print('------------------------------------------------------------------------------') |
|||
|
|||
res.append({ |
|||
'compile_command': compile_command, |
|||
'compile_stdout': compile_stdout, |
|||
'compile_stderr': compile_stderr, |
|||
'compile_exitcode': compile_exitcode, |
|||
'run_command': run_command, |
|||
'run_stdout': run_stdout, |
|||
# Don't include debug output, it's huge with DUK_OPT_DDDPRINT |
|||
#'run_stderr': run_stderr, |
|||
'run_exitcode': run_exitcode, |
|||
'run_expect': expect, |
|||
'success': not fail |
|||
}) |
|||
|
|||
sys.stdout.flush() |
|||
sys.stderr.flush() |
|||
|
|||
f = open(opts.out_results_json, 'wb') |
|||
f.write(json.dumps(res, indent=4, sort_keys=True)) |
|||
f.close() |
|||
|
|||
f = open(opts.out_failed, 'wb') |
|||
f.write('\n'.join(failed) + '\n') |
|||
f.close() |
|||
|
|||
check_unlink(fn_duk) |
|||
check_unlink(fn_testjs) |
|||
|
|||
# XXX: summary of success/failure/warnings (= stderr got anything) |
|||
|
|||
if __name__ == '__main__': |
|||
main() |
|||
Loading…
Reference in new issue