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
|
// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --expose-wasm
load("test/mjsunit/wasm/wasm-constants.js");
load("test/mjsunit/wasm/wasm-module-builder.js");
function toByteArray(s) {
var arr = [];
for (var i = 0; i < s.length; ++i) {
arr.push(s.charCodeAt(i) & 0xff);
}
return arr;
}
function toString(arr) {
if (typeof arr === "string") return arr;
var s = "";
for (var b of arr) s += String.fromCharCode(b);
return s;
}
function toUTF8(arr) {
if (typeof arr === "string" || arr === undefined) return arr;
return decodeURIComponent(escape(toString(arr)));
}
function isValidUtf8(arr) {
if (typeof arr === "string" || arr === undefined) return true;
try {
var s = toUTF8(arr);
for (var i = 0; i < s.length; ++i)
if ((s.charCodeAt(i) & 0xfffe) == 0xfffe)
return false;
return true;
} catch (e) {
if (e instanceof URIError) return false;
throw e;
}
}
function checkImportsAndExports(imported_module_name, imported_function_name,
internal_function_name, exported_function_name, shouldThrow) {
var builder = new WasmModuleBuilder();
builder.addImportWithModule(imported_module_name, imported_function_name,
kSig_v_v);
builder.addFunction(internal_function_name, kSig_v_v)
.addBody([kExprCallFunction, 0])
.exportAs(exported_function_name);
// sanity check: does javascript agree with out shouldThrow annotation?
assertEquals(shouldThrow,
!isValidUtf8(imported_module_name) ||
!isValidUtf8(imported_function_name) ||
!isValidUtf8(exported_function_name),
"JavaScript does not agree with our shouldThrow expectation");
if (!shouldThrow) {
imported_module_name = toUTF8(imported_module_name);
imported_function_name = toUTF8(imported_function_name);
}
var ffi = new Object();
if (imported_function_name === undefined) {
ffi[imported_module_name] = function() { };
} else {
ffi[imported_module_name] = new Object();
ffi[imported_module_name][imported_function_name] = function() { };
}
var hasThrown = true;
try {
builder.instantiate(ffi);
hasThrown = false;
} catch (err) {
if (!shouldThrow) print(err);
assertTrue(shouldThrow, "Should not throw error on valid names");
assertTrue(err instanceof Error, "exception should be an Error");
assertContains("UTF-8", err.toString());
}
assertEquals(shouldThrow, hasThrown,
"Should throw validation error on invalid names");
}
function checkImportedModuleName(name, shouldThrow) {
checkImportsAndExports(name, "imp", "func", undefined, shouldThrow);
}
function checkImportedFunctionName(name, shouldThrow) {
checkImportsAndExports("module", name, "func", "func", shouldThrow);
}
function checkExportedFunctionName(name, shouldThrow) {
checkImportsAndExports("module", "func", "func", name, shouldThrow);
}
function checkInternalFunctionName(name) {
checkImportsAndExports("module", "func", name, "func", false);
}
function checkAll(name, shouldThrow) {
checkImportedModuleName(name, shouldThrow);
checkImportedFunctionName(name, shouldThrow);
checkExportedFunctionName(name, shouldThrow);
checkInternalFunctionName(name);
}
checkAll("ascii", false);
checkAll("some math: (½)² = ¼", false);
checkAll("中国历史系列条目\n北", false);
checkAll(toByteArray("\xef\xb7\x8f"), false);
checkAll(toByteArray("a\xc2\x81\xe1\x80\xbf\xf1\x80\xa0\xbf"), false);
checkAll(toByteArray("\xff"), true);
checkAll(toByteArray("\xed\xa0\x8f"), true); // surrogate code points
checkAll(toByteArray("\xe0\x82\x80"), true); // overlong sequence
checkAll(toByteArray("\xf4\x90\x80\x80"), true); // beyond limit: U+110000
checkAll(toByteArray("\xef\xbf\xbe"), true); // non-character; U+FFFE
checkAll(toByteArray("with\x00null"), false);
|
