1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
# Copyright 2016 WebAssembly Community Group participants
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import filecmp
import os
import shutil
import subprocess
import sys
import tempfile
def _open_archive(tarfile, tmp_dir):
with tempfile.TemporaryFile(mode='w+') as f:
try:
subprocess.check_call(['tar', '-xvf', tarfile], cwd=tmp_dir, stdout=f)
except Exception:
f.seek(0)
sys.stderr.write(f.read())
raise
return os.listdir(tmp_dir)
def _files_same(dir1, dir2, basenames):
diff = filecmp.cmpfiles(dir1, dir2, basenames)
return 0 == len(diff[1] + diff[2])
def _dirs_same(dir1, dir2, basenames):
for d in basenames:
left = os.path.join(dir1, d)
right = os.path.join(dir2, d)
if not (os.path.isdir(left) and os.path.isdir(right)):
return False
diff = filecmp.dircmp(right, right)
if 0 != len(diff.left_only + diff.right_only + diff.diff_files +
diff.common_funny + diff.funny_files):
return False
return True
def _move_files(dirfrom, dirto, basenames):
for f in basenames:
from_file = os.path.join(dirfrom, f)
to_file = os.path.join(dirto, f)
if os.path.isfile(to_file):
os.path.remove(to_file)
shutil.move(from_file, to_file)
def _move_dirs(dirfrom, dirto, basenames):
for d in basenames:
from_dir = os.path.join(dirfrom, d)
to_dir = os.path.join(dirto, d)
if os.path.isdir(to_dir):
shutil.rmtree(to_dir)
shutil.move(from_dir, to_dir)
def untar(tarfile, outdir):
"""Returns True if untar content differs from pre-existing outdir content."""
tmpdir = tempfile.mkdtemp()
try:
untared = _open_archive(tarfile, tmpdir)
files = [f for f in untared if os.path.isfile(os.path.join(tmpdir, f))]
dirs = [d for d in untared if os.path.isdir(os.path.join(tmpdir, d))]
assert len(files) + len(dirs) == len(untared), 'Only files and directories'
if _files_same(tmpdir, outdir, files) and _dirs_same(tmpdir, outdir, dirs):
# Nothing new or different in the tarfile.
return False
# Some or all of the files / directories are new.
_move_files(tmpdir, outdir, files)
_move_dirs(tmpdir, outdir, dirs)
return True
finally:
if os.path.isdir(tmpdir):
shutil.rmtree(tmpdir)
def split_wast(wastFile):
# .wast files can contain multiple modules, and assertions for each one.
# this splits out a wast into [(module, assertions), ..]
# we ignore module invalidity tests here.
wast = open(wastFile, 'rb').read()
# if it's a binary, leave it as is
if wast[0] == '\0':
return [[wast, '']]
wast = open(wastFile, 'r').read()
ret = []
def to_end(j):
depth = 1
while depth > 0 and j < len(wast):
if wast[j] == '"':
while 1:
j = wast.find('"', j + 1)
if wast[j - 1] == '\\':
continue
break
assert j > 0
elif wast[j] == '(':
depth += 1
elif wast[j] == ')':
depth -= 1
elif wast[j] == ';' and wast[j + 1] == ';':
j = wast.find('\n', j)
j += 1
return j
i = 0
while i >= 0:
start = wast.find('(', i)
if start >= 0 and wast[start + 1] == ';':
# block comment
i = wast.find(';)', start + 2)
assert i > 0, wast[start:]
i += 2
continue
skip = wast.find(';', i)
if skip >= 0 and skip < start and skip + 1 < len(wast):
if wast[skip + 1] == ';':
i = wast.find('\n', i) + 1
continue
if start < 0:
break
i = to_end(start + 1)
chunk = wast[start:i]
if chunk.startswith('(module'):
ret += [(chunk, [])]
elif chunk.startswith('(assert_invalid'):
continue
elif chunk.startswith(('(assert', '(invoke')):
ret[-1][1].append(chunk)
return ret
def run_command(cmd, expected_status=0, stderr=None,
expected_err=None, err_contains=False):
if expected_err is not None:
assert stderr == subprocess.PIPE or stderr is None,\
"Can't redirect stderr if using expected_err"
stderr = subprocess.PIPE
print 'executing: ', ' '.join(cmd)
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=stderr, universal_newlines=True)
out, err = proc.communicate()
code = proc.returncode
if code != expected_status:
raise Exception(('run_command failed (%s)' % code, out + str(err or '')))
err_correct = expected_err is None or \
(expected_err in err if err_contains else expected_err == err)
if not err_correct:
raise Exception(('run_command unexpected stderr',
"expected '%s', actual '%s'" % (expected_err, err)))
return out
def node_has_webassembly(cmd):
cmd = [cmd, '-e', 'process.stdout.write(typeof WebAssembly)']
return run_command(cmd) == 'object'
def node_test_glue():
# running concatenated files (a.js) in node interferes with module loading
# because the concatenated file expects a 'var Binaryen' but binaryen.js
# assigned to module.exports. this is correct behavior but tests then need
# a workaround:
return ('if (typeof module === "object" && typeof exports === "object")\n'
' Binaryen = module.exports;\n')
|
