OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 the V8 project authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 // Flags: --validate-asm --allow-natives-syntax | |
6 | |
7 (function TestModuleArgs() { | |
8 function Module1(stdlib) { | |
9 "use asm"; | |
10 function foo() { } | |
11 return { foo: foo }; | |
12 } | |
13 function Module2(stdlib, ffi) { | |
14 "use asm"; | |
15 function foo() { } | |
16 return { foo: foo }; | |
17 } | |
18 function Module3(stdlib, ffi, heap) { | |
19 "use asm"; | |
20 function foo() { } | |
21 return { foo: foo }; | |
22 } | |
23 var modules = [Module1, Module2, Module3]; | |
24 var heap = new ArrayBuffer(1024 * 1024); | |
25 for (var i = 0; i < modules.length; ++i) { | |
26 print('Module' + (i + 1)); | |
27 var module = modules[i]; | |
28 // TODO(bradnelson): Support modules without the stdlib. | |
29 var m = module({}); | |
30 assertTrue(%IsAsmWasmCode(module)); | |
31 var m = module({}, {}); | |
32 assertTrue(%IsAsmWasmCode(module)); | |
33 var m = module({}, {}, heap); | |
34 assertTrue(%IsAsmWasmCode(module)); | |
35 var m = module({}, {}, heap, {}); | |
36 assertTrue(%IsAsmWasmCode(module)); | |
37 } | |
38 })(); | |
39 | |
40 (function TestBadModule() { | |
41 function Module(stdlib, ffi, heap) { | |
42 "use asm"; | |
43 function foo() { var y = 3; var x = 1 + y; return 123; } | |
44 return { foo: foo }; | |
45 } | |
46 var m = Module({}); | |
47 assertFalse(%IsAsmWasmCode(Module)); | |
48 assertEquals(123, m.foo()); | |
49 })(); | |
50 | |
51 (function TestBadArgTypes() { | |
52 function Module(a, b, c) { | |
53 "use asm"; | |
54 return {}; | |
55 } | |
56 var m = Module(1, 2, 3); | |
57 assertFalse(%IsAsmWasmCode(Module)); | |
58 assertEquals({}, m); | |
59 })(); | |
60 | |
61 (function TestBadArgTypesMismatch() { | |
62 function Module(a, b, c) { | |
63 "use asm"; | |
64 return {}; | |
65 } | |
66 var m = Module(1, 2); | |
67 assertFalse(%IsAsmWasmCode(Module)); | |
68 assertEquals({}, m); | |
69 })(); | |
70 | |
71 (function TestModuleNoStdlib() { | |
72 // TODO(bradnelson): | |
73 // Support modules like this if they don't use the whole stdlib. | |
74 function Module() { | |
75 "use asm"; | |
76 function foo() { return 123; } | |
77 return { foo: foo }; | |
78 } | |
79 var m = Module({}); | |
80 assertFalse(%IsAsmWasmCode(Module)); | |
81 assertEquals(123, m.foo()); | |
82 })(); | |
83 | |
84 (function TestModuleWith5() { | |
85 function Module(a, b, c, d, e) { | |
86 "use asm"; | |
87 function foo() { return 123; } | |
88 return { foo: foo }; | |
89 } | |
90 var heap = new ArrayBuffer(1024 * 1024); | |
91 var m = Module({}, {}, heap); | |
92 assertFalse(%IsAsmWasmCode(Module)); | |
93 assertEquals(123, m.foo()); | |
94 })(); | |
95 | |
96 (function TestModuleNoStdlibCall() { | |
97 function Module(stdlib, ffi, heap) { | |
98 "use asm"; | |
99 function foo() { return 123; } | |
100 return { foo: foo }; | |
101 } | |
102 // TODO(bradnelson): Support instantiation like this if stdlib is unused. | |
103 var m = Module(); | |
104 assertFalse(%IsAsmWasmCode(Module)); | |
105 assertEquals(123, m.foo()); | |
106 })(); | |
107 | |
108 (function TestModuleNew() { | |
109 function Module(stdlib, ffi, heap) { | |
110 "use asm"; | |
111 function foo() { return 123; } | |
112 return { foo: foo }; | |
113 } | |
114 var m = new Module({}, {}); | |
115 assertTrue(%IsAsmWasmCode(Module)); | |
116 assertEquals(123, m.foo()); | |
117 })(); | |
118 | |
119 (function TestMultipleFailures() { | |
120 function Module(stdlib) { | |
121 "use asm"; | |
122 function foo() { return 123; } | |
123 return { foo: foo }; | |
124 } | |
125 var m1 = Module(1, 2, 3); | |
126 assertFalse(%IsAsmWasmCode(Module)); | |
127 var m2 = Module(1, 2, 3); | |
128 assertFalse(%IsAsmWasmCode(Module)); | |
129 assertEquals(123, m1.foo()); | |
130 assertEquals(123, m2.foo()); | |
131 })(); | |
132 | |
133 (function TestFailureThenSuccess() { | |
134 function Module(stdlib, ffi, heap) { | |
Michael Starzinger
2016/08/12 09:21:56
This is not exactly what I had in mind. This will
bradn
2016/08/12 18:50:02
Done.
| |
135 "use asm"; | |
136 function foo() { return 123; } | |
137 return { foo: foo }; | |
138 } | |
139 var heap = new ArrayBuffer(1024 * 1024); | |
140 var m1 = Module(1, 2, 3); | |
141 assertFalse(%IsAsmWasmCode(Module)); | |
142 var m2 = Module({}, {}, heap); | |
143 // TODO(bradnelson): Worth making this succeed? | |
144 // This would require creating a new SharedFunctionInfo | |
145 // on failure at instantiation time. | |
146 assertFalse(%IsAsmWasmCode(Module)); | |
147 assertEquals(123, m1.foo()); | |
148 assertEquals(123, m2.foo()); | |
149 })(); | |
150 | |
151 (function TestSuccessThenFailure() { | |
152 function Module(stdlib, ffi, heap) { | |
153 "use asm"; | |
154 function foo() { return 123; } | |
155 return { foo: foo }; | |
156 } | |
157 var heap = new ArrayBuffer(1024 * 1024); | |
158 var m1 = Module({}, {}, heap); | |
159 assertTrue(%IsAsmWasmCode(Module)); | |
160 var m2 = Module(1, 2, 3); | |
161 assertFalse(%IsAsmWasmCode(Module)); | |
162 assertEquals(123, m1.foo()); | |
163 assertEquals(123, m2.foo()); | |
164 })(); | |
165 | |
166 (function TestBoundFunction() { | |
167 function Module(stdlib, ffi, heap) { | |
168 "use asm"; | |
169 function foo() { return 123; } | |
170 return { foo: foo }; | |
171 } | |
172 var heap = new ArrayBuffer(1024 * 1024); | |
173 var ModuleBound = Module.bind(this, {}, {}, heap); | |
174 var m = ModuleBound(); | |
175 assertTrue(%IsAsmWasmCode(Module)); | |
176 assertEquals(123, m.foo()); | |
177 })(); | |
OLD | NEW |