The Tor Browser / file comparison
comparison: js/src/jit-test/tests/asm.js/testSource.js
js/src/jit-test/tests/asm.js/testSource.js
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:01943e8de1a6 |
|---|---|
| 1 setCachingEnabled(true); | |
| 2 | |
| 3 (function() { | |
| 4 /* | |
| 5 * NO ARGUMENT | |
| 6 */ | |
| 7 | |
| 8 function f0() { | |
| 9 "use asm"; | |
| 10 function g() {} | |
| 11 return g; | |
| 12 | |
| 13 } | |
| 14 | |
| 15 var bodyOnly = '"use asm";\n\ | |
| 16 function g() {}\n\ | |
| 17 return g;\n'; | |
| 18 | |
| 19 var funcBody = 'function f0() {\n\ | |
| 20 "use asm";\n\ | |
| 21 function g() {}\n\ | |
| 22 return g;\n\n\ | |
| 23 }'; | |
| 24 | |
| 25 assertEq(f0.toString(), funcBody); | |
| 26 assertEq(f0.toSource(), funcBody); | |
| 27 | |
| 28 var f0 = function() { | |
| 29 "use asm"; | |
| 30 function g() {} | |
| 31 return g; | |
| 32 | |
| 33 } | |
| 34 | |
| 35 funcBody1 = funcBody.replace('function f0','function '); | |
| 36 assertEq(f0.toString(), funcBody1); | |
| 37 assertEq(f0.toSource(), '(' + funcBody1 + ')'); | |
| 38 | |
| 39 var g = function g0() { | |
| 40 "use asm"; | |
| 41 function g() {} | |
| 42 return g; | |
| 43 | |
| 44 } | |
| 45 | |
| 46 funcBody2 = funcBody.replace('function f0', 'function g0'); | |
| 47 assertEq(g.toString(), funcBody2); | |
| 48 assertEq(g.toSource(), '(' + funcBody2 + ')'); | |
| 49 | |
| 50 f0 = new Function(bodyOnly); | |
| 51 assertEq(f0.toString(), "function anonymous() {\n" + bodyOnly + "\n}"); | |
| 52 assertEq(f0.toSource(), "(function anonymous() {\n" + bodyOnly + "\n})"); | |
| 53 | |
| 54 if (isAsmJSCompilationAvailable() && isCachingEnabled()) { | |
| 55 var m = new Function(bodyOnly); | |
| 56 assertEq(isAsmJSModuleLoadedFromCache(m), true); | |
| 57 assertEq(m.toString(), "function anonymous() {\n" + bodyOnly + "\n}"); | |
| 58 assertEq(m.toSource(), "(function anonymous() {\n" + bodyOnly + "\n})"); | |
| 59 } | |
| 60 | |
| 61 })(); | |
| 62 | |
| 63 (function() { | |
| 64 /* | |
| 65 * ONE ARGUMENT | |
| 66 */ | |
| 67 function f1(glob) { | |
| 68 "use asm"; | |
| 69 function g() {} | |
| 70 return g; | |
| 71 | |
| 72 } | |
| 73 | |
| 74 var bodyOnly = '"use asm";\n\ | |
| 75 function g() {}\n\ | |
| 76 return g;\n'; | |
| 77 | |
| 78 var funcBody = 'function f1(glob) {\n\ | |
| 79 "use asm";\n\ | |
| 80 function g() {}\n\ | |
| 81 return g;\n\n\ | |
| 82 }'; | |
| 83 | |
| 84 assertEq(f1.toString(), funcBody); | |
| 85 assertEq(f1.toSource(), funcBody); | |
| 86 | |
| 87 f1 = function(glob) { | |
| 88 "use asm"; | |
| 89 function g() {} | |
| 90 return g; | |
| 91 | |
| 92 } | |
| 93 | |
| 94 funcBody1 = funcBody.replace('function f1', 'function '); | |
| 95 assertEq(f1.toString(), funcBody1); | |
| 96 assertEq(f1.toSource(), '(' + funcBody1 + ')'); | |
| 97 | |
| 98 var g = function g0(glob) { | |
| 99 "use asm"; | |
| 100 function g() {} | |
| 101 return g; | |
| 102 | |
| 103 } | |
| 104 | |
| 105 funcBody2 = funcBody.replace('function f1', 'function g0'); | |
| 106 assertEq(g.toString(), funcBody2); | |
| 107 assertEq(g.toSource(), '(' + funcBody2 + ')'); | |
| 108 | |
| 109 f1 = new Function('glob', bodyOnly); | |
| 110 assertEq(f1.toString(), "function anonymous(glob) {\n" + bodyOnly + "\n}"); | |
| 111 assertEq(f1.toSource(), "(function anonymous(glob) {\n" + bodyOnly + "\n})"); | |
| 112 | |
| 113 if (isAsmJSCompilationAvailable() && isCachingEnabled()) { | |
| 114 var m = new Function('glob', bodyOnly); | |
| 115 assertEq(isAsmJSModuleLoadedFromCache(m), true); | |
| 116 assertEq(m.toString(), "function anonymous(glob) {\n" + bodyOnly + "\n}"); | |
| 117 assertEq(m.toSource(), "(function anonymous(glob) {\n" + bodyOnly + "\n})"); | |
| 118 } | |
| 119 | |
| 120 })(); | |
| 121 | |
| 122 | |
| 123 (function() { | |
| 124 /* | |
| 125 * TWO ARGUMENTS | |
| 126 */ | |
| 127 function f2(glob, ffi) { | |
| 128 "use asm"; | |
| 129 function g() {} | |
| 130 return g; | |
| 131 | |
| 132 } | |
| 133 | |
| 134 var bodyOnly = '"use asm";\n\ | |
| 135 function g() {}\n\ | |
| 136 return g;\n'; | |
| 137 | |
| 138 var funcBody = 'function f2(glob, ffi) {\n\ | |
| 139 "use asm";\n\ | |
| 140 function g() {}\n\ | |
| 141 return g;\n\n\ | |
| 142 }'; | |
| 143 | |
| 144 assertEq(f2.toString(), funcBody); | |
| 145 assertEq(f2.toSource(), funcBody); | |
| 146 | |
| 147 f2 = function (glob, ffi) { | |
| 148 "use asm"; | |
| 149 function g() {} | |
| 150 return g; | |
| 151 | |
| 152 } | |
| 153 | |
| 154 funcBody1 = funcBody.replace('function f2', 'function '); | |
| 155 assertEq(f2.toString(), funcBody1); | |
| 156 assertEq(f2.toSource(), '(' + funcBody1 + ')'); | |
| 157 | |
| 158 var g = function g0(glob, ffi) { | |
| 159 "use asm"; | |
| 160 function g() {} | |
| 161 return g; | |
| 162 | |
| 163 } | |
| 164 | |
| 165 var funcBody2 = funcBody.replace('function f2', 'function g0'); | |
| 166 assertEq(g.toString(), funcBody2); | |
| 167 assertEq(g.toSource(), '(' + funcBody2 + ')'); | |
| 168 | |
| 169 f2 = new Function('glob', 'ffi', bodyOnly); | |
| 170 assertEq(f2.toString(), "function anonymous(glob, ffi) {\n" + bodyOnly + "\n}"); | |
| 171 assertEq(f2.toSource(), "(function anonymous(glob, ffi) {\n" + bodyOnly + "\n})"); | |
| 172 | |
| 173 if (isAsmJSCompilationAvailable() && isCachingEnabled()) { | |
| 174 var m = new Function('glob', 'ffi', bodyOnly); | |
| 175 assertEq(isAsmJSModuleLoadedFromCache(m), true); | |
| 176 assertEq(m.toString(), "function anonymous(glob, ffi) {\n" + bodyOnly + "\n}"); | |
| 177 assertEq(m.toSource(), "(function anonymous(glob, ffi) {\n" + bodyOnly + "\n})"); | |
| 178 } | |
| 179 | |
| 180 })(); | |
| 181 | |
| 182 | |
| 183 (function() { | |
| 184 /* | |
| 185 * THREE ARGUMENTS | |
| 186 */ | |
| 187 function f3(glob, ffi, heap) { | |
| 188 "use asm"; | |
| 189 function g() {} | |
| 190 return g; | |
| 191 | |
| 192 } | |
| 193 | |
| 194 var bodyOnly = '"use asm";\n\ | |
| 195 function g() {}\n\ | |
| 196 return g;\n'; | |
| 197 | |
| 198 var funcBody = 'function f3(glob, ffi, heap) {\n\ | |
| 199 "use asm";\n\ | |
| 200 function g() {}\n\ | |
| 201 return g;\n\n\ | |
| 202 }'; | |
| 203 | |
| 204 assertEq(f3.toString(), funcBody); | |
| 205 assertEq(f3.toSource(), funcBody); | |
| 206 | |
| 207 f3 = function (glob, ffi, heap) { | |
| 208 "use asm"; | |
| 209 function g() {} | |
| 210 return g; | |
| 211 | |
| 212 } | |
| 213 | |
| 214 funcBody1 = funcBody.replace('function f3', 'function '); | |
| 215 assertEq(f3.toString(), funcBody1); | |
| 216 assertEq(f3.toSource(), '(' + funcBody1 + ')'); | |
| 217 | |
| 218 var g = function g0(glob, ffi, heap) { | |
| 219 "use asm"; | |
| 220 function g() {} | |
| 221 return g; | |
| 222 | |
| 223 } | |
| 224 | |
| 225 funcBody2 = funcBody.replace('function f3', 'function g0'); | |
| 226 assertEq(g.toString(), funcBody2); | |
| 227 assertEq(g.toSource(), '(' + funcBody2 + ')'); | |
| 228 | |
| 229 f3 = new Function('glob', 'ffi', 'heap', bodyOnly); | |
| 230 assertEq(f3.toString(), "function anonymous(glob, ffi, heap) {\n" + bodyOnly + "\n}"); | |
| 231 assertEq(f3.toSource(), "(function anonymous(glob, ffi, heap) {\n" + bodyOnly + "\n})"); | |
| 232 | |
| 233 if (isAsmJSCompilationAvailable() && isCachingEnabled()) { | |
| 234 var m = new Function('glob', 'ffi', 'heap', bodyOnly); | |
| 235 assertEq(isAsmJSModuleLoadedFromCache(m), true); | |
| 236 assertEq(m.toString(), "function anonymous(glob, ffi, heap) {\n" + bodyOnly + "\n}"); | |
| 237 assertEq(m.toSource(), "(function anonymous(glob, ffi, heap) {\n" + bodyOnly + "\n})"); | |
| 238 } | |
| 239 | |
| 240 })(); | |
| 241 | |
| 242 /* Implicit "use strict" context */ | |
| 243 (function() { | |
| 244 | |
| 245 var funcHeader = 'function (glob, ffi, heap) {', | |
| 246 funcBody = '\n"use asm";\n\ | |
| 247 function g() {}\n\ | |
| 248 return g;\n\n' | |
| 249 funcFooter = '}', | |
| 250 funcSource = funcHeader + funcBody + funcFooter | |
| 251 useStrict = '\n"use strict";\n'; | |
| 252 | |
| 253 var f4 = eval("\"use strict\";\n(" + funcSource + ")"); | |
| 254 | |
| 255 var expectedToString = funcHeader + useStrict + funcBody + funcFooter | |
| 256 var expectedToSource = '(' + expectedToString + ')' | |
| 257 | |
| 258 assertEq(f4.toString(), expectedToString); | |
| 259 assertEq(f4.toSource(), expectedToSource); | |
| 260 | |
| 261 if (isAsmJSCompilationAvailable() && isCachingEnabled()) { | |
| 262 var f5 = eval("\"use strict\";\n(" + funcSource + ")"); | |
| 263 assertEq(isAsmJSModuleLoadedFromCache(f5), true); | |
| 264 assertEq(f5.toString(), expectedToString); | |
| 265 assertEq(f5.toSource(), expectedToSource); | |
| 266 } | |
| 267 })(); | |
| 268 | |
| 269 /* Functions */ | |
| 270 (function() { | |
| 271 | |
| 272 var noSrc = "function noArgument() {\n\ | |
| 273 return 42;\n\ | |
| 274 }" | |
| 275 var oneSrc = "function oneArgument(x) {\n\ | |
| 276 x = x | 0;\n\ | |
| 277 return x + 1 | 0;\n\ | |
| 278 }"; | |
| 279 var twoSrc = "function twoArguments(x, y) {\n\ | |
| 280 x = x | 0;\n\ | |
| 281 y = y | 0;\n\ | |
| 282 return x + y | 0;\n\ | |
| 283 }"; | |
| 284 var threeSrc = "function threeArguments(a, b, c) {\n\ | |
| 285 a = +a;\n\ | |
| 286 b = +b;\n\ | |
| 287 c = +c;\n\ | |
| 288 return +(+(a * b) + c);\n\ | |
| 289 }"; | |
| 290 | |
| 291 var funcBody = '\n\ | |
| 292 "use asm";\n' | |
| 293 + noSrc + '\n' | |
| 294 + oneSrc + '\n' | |
| 295 + twoSrc + '\n' | |
| 296 + threeSrc + '\n' | |
| 297 + 'return {\n\ | |
| 298 no: noArgument,\n\ | |
| 299 one: oneArgument,\n\ | |
| 300 two: twoArguments,\n\ | |
| 301 three: threeArguments\n\ | |
| 302 }'; | |
| 303 | |
| 304 var g = new Function(funcBody); | |
| 305 var moduleG = g(); | |
| 306 | |
| 307 function checkFuncSrc(m) { | |
| 308 assertEq(m.no.toString(), noSrc); | |
| 309 assertEq(m.no.toSource(), noSrc); | |
| 310 | |
| 311 assertEq(m.one.toString(), oneSrc); | |
| 312 assertEq(m.one.toSource(), oneSrc); | |
| 313 | |
| 314 assertEq(m.two.toString(), twoSrc); | |
| 315 assertEq(m.two.toSource(), twoSrc); | |
| 316 | |
| 317 assertEq(m.three.toString(), threeSrc); | |
| 318 assertEq(m.three.toSource(), threeSrc); | |
| 319 } | |
| 320 checkFuncSrc(moduleG); | |
| 321 | |
| 322 if (isAsmJSCompilationAvailable() && isCachingEnabled()) { | |
| 323 var g2 = new Function(funcBody); | |
| 324 assertEq(isAsmJSModuleLoadedFromCache(g2), true); | |
| 325 m = g2(); | |
| 326 checkFuncSrc(m); | |
| 327 | |
| 328 var moduleDecl = 'function g3() {' + funcBody + '}'; | |
| 329 eval(moduleDecl); | |
| 330 m = g3(); | |
| 331 assertEq(isAsmJSModuleLoadedFromCache(g3), false); | |
| 332 checkFuncSrc(m); | |
| 333 | |
| 334 eval('var x = 42;' + moduleDecl); | |
| 335 m = g3(); | |
| 336 assertEq(isAsmJSModuleLoadedFromCache(g3), true); | |
| 337 checkFuncSrc(m); | |
| 338 } | |
| 339 | |
| 340 })(); |
