The Tor Browser / file revision

js/src/jit-test/tests/asm.js/testBasic.js@6474c204b198

js/src/jit-test/tests/asm.js/testBasic.js

Wed, 31 Dec 2014 06:09:35 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Wed, 31 Dec 2014 06:09:35 +0100
changeset 0
6474c204b198
permissions
-rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 load(libdir + "asm.js");

     2 load(libdir + "asserts.js");

     3 

     4 assertAsmTypeFail(USE_ASM);

     5 assertAsmTypeFail(USE_ASM + 'return');

     6 assertAsmTypeFail(USE_ASM + 'function f() 0');

     7 assertAsmTypeFail(USE_ASM + 'function f(){}');

     8 assertAsmTypeFail(USE_ASM + 'function f(){} return 0');

     9 assertAsmTypeFail(USE_ASM + 'function f() 0; return 0');

    10 assertAsmTypeFail(USE_ASM + 'function f(){} return g');

    11 assertAsmTypeFail(USE_ASM + 'function f(){} function f(){} return f');

    12 assertAsmTypeFail(USE_ASM + 'var f=0; function f(){} return f');

    13 assertAsmTypeFail('glob', USE_ASM + 'var f=glob.Math.imul; function f(){} return f');

    14 assertAsmTypeFail('glob','foreign', USE_ASM + 'var f=foreign.foo; function f(){} return f');

    15 assertAsmTypeFail(USE_ASM + 'function f(){} var f=[f,f]; return f');

    16 assertAsmTypeFail(USE_ASM + 'function f() 0; return f');

    17 assertAsmTypeFail('"use strict";' + USE_ASM + 'function f() {} return f');

    18 assertAsmTypeFail(USE_ASM + '"use strict"; function f() {} return f');

    19 assertEq(asmLink(asmCompile(USE_ASM + 'function f(){} return f'))(), undefined);

    20 assertEq(asmLink(asmCompile(USE_ASM + 'function f(){;} return f'))(), undefined);

    21 assertAsmTypeFail(USE_ASM + 'function f(i,j){;} return f');

    22 assertEq(asmLink(asmCompile('"use asm";; function f(){};;; return f;;'))(), undefined);

    23 assertAsmTypeFail(USE_ASM + 'function f(x){} return f');

    24 assertAsmTypeFail(USE_ASM + 'function f(){return; return 1} return f');

    25 assertEq(asmLink(asmCompile(USE_ASM + 'function f(x){x=x|0} return f'))(42), undefined);

    26 assertEq(asmLink(asmCompile(USE_ASM + 'function f(x){x=x|0; return x|0} return f'))(42), 42);

    27 assertEq(asmLink(asmCompile(USE_ASM + 'function f(x){x=x|0; return x|0;;;} return f'))(42), 42);

    28 assertEq(asmLink(asmCompile(USE_ASM + 'function f(x,y){x=x|0;y=y|0; return (x+y)|0} return f'))(44, -2), 42);

    29 assertAsmTypeFail('a', USE_ASM + 'function a(){} return a');

    30 assertAsmTypeFail('a','b','c', USE_ASM + 'var c');

    31 assertAsmTypeFail('a','b','c', USE_ASM + 'var c=0');

    32 assertAsmTypeFail(USE_ASM + 'c=0;return {}');

    33 assertAsmTypeFail('x','x', USE_ASM + 'function a(){} return a');

    34 assertAsmTypeFail('x','y','x', USE_ASM + 'function a(){} return a');

    35 assertEq(asmLink(asmCompile('x', USE_ASM + 'function a(){} return a'))(), undefined);

    36 assertEq(asmLink(asmCompile('x','y', USE_ASM + 'function a(){} return a'))(), undefined);

    37 assertEq(asmLink(asmCompile('x','y','z', USE_ASM + 'function a(){} return a'))(), undefined);

    38 assertAsmTypeFail('x','y', USE_ASM + 'function y(){} return f');

    39 assertEq(asmLink(asmCompile('x', USE_ASM + 'function f(){} return f'), 1, 2, 3)(), undefined);

    40 assertEq(asmLink(asmCompile('x', USE_ASM + 'function f(){} return f'), 1)(), undefined);

    41 assertEq(asmLink(asmCompile('x','y', USE_ASM + 'function f(){} return f'), 1, 2)(), undefined);

    42 

    43 assertEq(asmLink(asmCompile(USE_ASM + 'function f(i) {i=i|0} return f'))(42), undefined);

    44 assertEq(asmLink(asmCompile(USE_ASM + 'function f() {var i=0;; var j=1;} return f'))(), undefined); // bug 877965 second part

    45 assertAsmTypeFail(USE_ASM + 'function f(i) {i=i|0;var i} return f');

    46 assertAsmTypeFail(USE_ASM + 'function f(i) {i=i|0;var i=0} return f');

    47 

    48 assertAsmTypeFail('glob', USE_ASM + 'var im=glob.imul; function f() {} return f');

    49 assertAsmLinkAlwaysFail(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i,j) {i=i|0;j=j|0; return im(i,j)|0} return f'), null);

    50 assertAsmLinkAlwaysFail(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i,j) {i=i|0;j=j|0; return im(i,j)|0} return f'), {});

    51 assertAsmLinkAlwaysFail(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i,j) {i=i|0;j=j|0; return im(i,j)|0} return f'), {imul:Math.imul});

    52 assertEq(asmLink(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i,j) {i=i|0;j=j|0; return im(i,j)|0} return f'), {Math:{imul:Math.imul}})(2,3), 6);

    53 assertEq(asmLink(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i,j) {i=i|0;j=j|0; return im(i,j)|0} return f'), this)(8,4), 32);

    54 

    55 assertAsmLinkAlwaysFail(asmCompile('glob','i','b', USE_ASM + 'var i32=new glob.Int32Array(b); function f(){} return f'), null, null);

    56 assertAsmLinkAlwaysFail(asmCompile('glob','i','b', USE_ASM + 'var i32=new glob.Int32Array(b); function f(){} return f'), this, null, null);

    57 assertAsmLinkAlwaysFail(asmCompile('glob','i','b', USE_ASM + 'var i32=new glob.Int32Array(b); function f(){} return f'), this, null, null);

    58 assertAsmLinkAlwaysFail(asmCompile('glob','i','b', USE_ASM + 'var i32=new glob.Int32Array(b); function f(){} return f'), this, null, new ArrayBuffer(1));

    59 assertAsmLinkFail(asmCompile('glob','i','b', USE_ASM + 'var i32=new glob.Int32Array(b); function f(){} return f'), this, null, new ArrayBuffer(100));

    60 assertAsmLinkFail(asmCompile('glob','i','b', USE_ASM + 'var i32=new glob.Int32Array(b); function f(){} return f'), this, null, new ArrayBuffer(4000));

    61 assertEq(asmLink(asmCompile('glob','i','b', USE_ASM + 'var i32=new glob.Int32Array(b); function f(){} return f'), this, null, new ArrayBuffer(4096))(), undefined);

    62 assertEq(asmLink(asmCompile('glob','i','b', USE_ASM + 'var i32=new glob.Int32Array(b); function f(){} return f'), this, null, new ArrayBuffer(2*4096))(), undefined);

    63 

    64 assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + HEAP_IMPORTS + 'function f(i) {i=i|0; i = i32[i]|0; return i|0}; return f');

    65 assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + HEAP_IMPORTS + 'function f(i) {i=i|0; i = i32[i>>1]|0; return i|0}; return f');

    66 assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + HEAP_IMPORTS + 'function f(i) {i=i|0; i = i32[i>>1]|0; return i|0}; return f');

    67 assertAsmLinkAlwaysFail(asmCompile('glob', 'imp', 'b', USE_ASM + HEAP_IMPORTS + 'function f(i) {i=i|0; i = i32[i>>2]|0; return i|0}; return f'), this, null, new ArrayBuffer(4095));

    68 assertEq(asmCompile('glob', 'imp', 'b', USE_ASM + HEAP_IMPORTS + 'function f(i) {i=i|0; i = i32[i>>2]|0; return i|0}; return f')(this, null, new ArrayBuffer(4096))(), 0);

    69 

    70 var exp = asmLink(asmCompile(USE_ASM + "return {}"));

    71 assertEq(Object.keys(exp).length, 0);

    72 

    73 var exp = asmLink(asmCompile(USE_ASM + "function f() { return 3 } return {f:f,f:f}"));

    74 assertEq(exp.f(), 3);

    75 assertEq(Object.keys(exp).join(), 'f');

    76 

    77 assertAsmTypeFail(USE_ASM + "function f() { return 3 } return {1:f}");

    78 assertAsmTypeFail(USE_ASM + "function f() { return 3 } return {__proto__:f}");

    79 assertAsmTypeFail(USE_ASM + "function f() { return 3 } return {get x() {} }");

    80 

    81 var exp = asmLink(asmCompile(USE_ASM + 'function internal() { return ((g()|0)+2)|0 } function f() { return 1 } function g() { return 2 } function h() { return internal()|0 } return {f:f,g1:g,h1:h}'));

    82 assertEq(exp.f(), 1);

    83 assertEq(exp.g1(), 2);

    84 assertEq(exp.h1(), 4);

    85 assertEq(Object.keys(exp).join(), 'f,g1,h1');

    86 

    87 // can't test destructuring args with Function constructor

    88 function assertTypeFailInEval(str)

    89 {

    90     if (!isAsmJSCompilationAvailable())

    91         return;

    92 

    93     var caught = false;

    94     var oldOpts = options("werror");

    95     assertEq(oldOpts.indexOf("werror"), -1);

    96     try {

    97         eval(str);

    98     } catch (e) {

    99         assertEq((''+e).indexOf(ASM_TYPE_FAIL_STRING) == -1, false);

   100         caught = true;

   101     }

   102     assertEq(caught, true);

   103     options("werror");

   104 }

   105 assertTypeFailInEval('function f({}) { "use asm"; function g() {} return g }');

   106 assertTypeFailInEval('function f({global}) { "use asm"; function g() {} return g }');

   107 assertTypeFailInEval('function f(global, {imports}) { "use asm"; function g() {} return g }');

   108 assertTypeFailInEval('function f(g = 2) { "use asm"; function g() {} return g }');

   109 assertTypeFailInEval('function *f() { "use asm"; function g() {} return g }');

   110 assertTypeFailInEval('f => { "use asm"; function g() {} return g }');

   111 

   112 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'var)') }, SyntaxError);

   113 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'return)') }, SyntaxError);

   114 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'var z=-2w') }, SyntaxError);

   115 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'var z=-2w;') }, SyntaxError);

   116 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function') }, SyntaxError);

   117 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f') }, SyntaxError);

   118 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f(') }, SyntaxError);

   119 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f()') }, SyntaxError);

   120 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f() {') }, SyntaxError);

   121 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f() {} var') }, SyntaxError);

   122 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f() {} var TBL=-2w; return f') }, SyntaxError);

   123 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f() {} var TBL=-2w return f') }, SyntaxError);

   124 assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function () {}') }, SyntaxError);

   125 assertNoWarning(function() { parse("function f() { 'use asm'; function g() {} return g }") });

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial