KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta 
How to use glob method in stryker-parent
Best JavaScript code snippet using stryker-parent
testFloat32.js
Source:testFloat32.js 
1load(libdir + "asm.js");2const TO_FLOAT32 = "var toF = glob.Math.fround;";3const HEAP32 = "var f32 = new glob.Float32Array(heap);";4const HEAP64 = "var f64 = new glob.Float64Array(heap);"5var heap = new ArrayBuffer(BUF_MIN);6// Module linking7assertAsmLinkAlwaysFail(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() {} return f"), null);8assertAsmLinkAlwaysFail(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() {} return f"), {fround: Math.fround});9assertAsmLinkFail(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() {} return f"), {Math: {fround: Math.imul}});10assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() {} return f"), {Math:{fround: Math.fround}})(), undefined);11// Argument coercions12assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = unknown(x); } return f");13assertAsmTypeFail('glob', USE_ASM + "function f(i) { i = toF(i); } return f");14assertAsmTypeFail('glob', USE_ASM + "var cos = glob.Math.cos; function f(x) { x = cos(x); } return f");15assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = toF(); } return f");16assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = toF(x, x); } return f");17assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = toF('hi'); } return f");18assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = toF(loat); } return f");19assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(i) { i = toF(i); } return f"), this)(), undefined);20// Local variables declarations21assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = unknown(); } return f");22assertAsmTypeFail('glob', USE_ASM + "var cos = glob.Math.cos; function f() { var i = cos(); } return f");23assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(); } return f");24assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(x, x); } return f");25assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF('hi'); } return f");26assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(5); } return f"), this)(), undefined);27assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(5.); } return f"), this)(), undefined);28// Return values29assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(4, 4); } return f");30assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(); } return f");31assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF({}); } return f");32assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(x); } return f");33assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(42); } return f"), this)(), 42);34assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(0.); } return f"), this)(), 0);35assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(-0.); } return f"), this)(), -0);36assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var inf = glob.Infinity; function f() { return toF(inf); } return f"), this)(), Infinity);37assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(13.37); } return f"), this)(), Math.fround(13.37));38assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return +toF(4.); } return f"), this)(), 4);39assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return +~~toF(4.5); } return f"), this)(), 4);40// Assign values41assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(5.); i = 5; return toF(i); } return f");42assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(5.); i = 6.; return toF(i); } return f");43assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(-0.); return toF(i); } return f"), this)(), -0);44assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(0.); return toF(i); } return f"), this)(), 0);45assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(5.); return toF(i); } return f"), this)(), 5);46assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(5.); i = toF(42); return toF(i); } return f"), this)(), 42);47assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(5.); i = toF(6.); return toF(i); } return f"), this)(), 6);48assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { var i = toF(5.); f32[0] = toF(6.); i = f32[0]; return toF(i); } return f");49assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { var i = toF(5.); f32[0] = toF(6.); i = toF(f32[0]); return toF(i); } return f"), this, null, heap)(), 6);50// Special array assignments (the other ones are tested in testHeapAccess)51assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { var i = 5.; f32[0] = i; return toF(f32[0]); } return f"), this, null, heap)(), 5);52assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "var f64 = new glob.Float64Array(heap); function f() { var i = toF(5.); f64[0] = i; return +f64[0]; } return f"), this, null, heap)(), 5);53assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 1.5; return +f32[0]; } return f"), this, null, heap)(), 1.5);54assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + HEAP64 + "function f() { f64[0] = 1.5; return toF(f64[0]); } return f"), this, null, heap)(), 1.5);55assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + HEAP64 + "function f() { f32[0] = toF(42); f64[0] = f32[0]; return +f64[0]; } return f"), this, null, heap)(), 42);56assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = toF(-1.4013e-45) / toF(42.); } return f"), this, null, heap)(), undefined);57// Coercions58// -> from Float3259assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { var n = 0; n = toF(4.5) | 0; } return f");60assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { var i = toF(5.); var n = 0; n = i | 0; return n | 0; } return f");61assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = toF(x); var n = 0; n = ~~(x + x) >>> 0; return n | 0; } return f");62assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = toF(x); var n = 0.; n = +x; return +n; } return f"), this)(16.64), Math.fround(16.64));63assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = toF(x); var n = 0; n = ~~x; return n | 0; } return f"), this)(16.64), 16);64assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = toF(x); var n = 0; n = ~~x >>> 0; return n | 0; } return f"), this)(16.64), 16);65// -> from float?66function makeCoercion(coercionFunc) {67 return USE_ASM + HEAP32 + TO_FLOAT32 + "function f(x) { x = toF(x); f32[0] = x; return " + coercionFunc('f32[0]') + " } return f";68}69assertAsmTypeFail('glob', 'ffi', 'heap', makeCoercion(x => x + '|0'));70assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', makeCoercion(x => '+' + x)), this, null, heap)(16.64), Math.fround(16.64));71assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', makeCoercion(x => 'toF(' + x + ')')), this, null, heap)(16.64), Math.fround(16.64));72assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', makeCoercion(x => '~~+' + x + '|0')), this, null, heap)(16.64), 16);73assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', makeCoercion(x => '~~toF(' + x + ')|0')), this, null, heap)(16.64), 16);74// -> to Float3275assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = x|0; return toF(~~x); } return f"), this)(23), 23);76assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = x|0; return toF(x >> 0); } return f"), this)(23), 23);77assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = +x; return toF(x); } return f"), this)(13.37), Math.fround(13.37));78UINT32_MAX = Math.pow(2, 32)-1;79assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = x|0; return toF(x >>> 0); } return f"), this)(-1), Math.fround(UINT32_MAX));80var tof = asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = x|0; return toF(x>>>0) } return f"), this);81for (x of [0, 1, 10, 64, 1025, 65000, Math.pow(2,30), Math.pow(2,31), Math.pow(2,32)-2, Math.pow(2,32)-1])82 assertEq(tof(x), Math.fround(x));83// Global variables imports84assertAsmTypeFail('glob', USE_ASM + "var x = toF(); function f() {} return f");85assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var x = some(3); function f() {} return f");86assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var x = toF(); function f() {} return f");87assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var x = toF(3, 4); function f() {} return f");88assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var x = toF({x: 3}); function f() {} return f");89assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var x = toF(true); function f() {} return f");90assertAsmTypeFail('glob', USE_ASM + "var x = toF(3);" + TO_FLOAT32 + "function f() {} return f");91assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var x = toF(3.5); function f() {} return f"), this)(), undefined);92assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var x = toF(3); function f() {} return f"), this)(), undefined);93assertEq(asmLink(asmCompile('glob', 'ffi', USE_ASM + TO_FLOAT32 + "var x = toF(ffi.x); function f() {} return f"), this, {x:3})(), undefined);94assertEq(asmLink(asmCompile('glob', 'ffi', USE_ASM + TO_FLOAT32 + "var x = toF(ffi.x); function f() {} return f"), this, {x:3.5})(), undefined);95// Global variables uses96values = [2.01, 13.37, -3.141592653]97specials = [NaN, Infinity]98for (v of values) {99 assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var x = toF(" + v + "); function f() {return toF(x);} return f"), this)(), Math.fround(v));100 assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "const x = toF(" + v + "); function f() {return toF(x);} return f"), this)(), Math.fround(v));101 assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var x = toF(0.); function f() {x = toF(" + v + "); return toF(x);} return f"), this)(), Math.fround(v));102 assertEq(asmLink(asmCompile('glob', 'ffi', USE_ASM + TO_FLOAT32 + "var x = toF(ffi.x); function f() {return toF(x);} return f"), this, {x:v})(), Math.fround(v));103}104for (v of specials) {105 assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var special = glob." + v + "; var g=toF(0.); function f() {g=toF(special); return toF(g);} return f"), this)(), Math.fround(v));106}107// Math builtins108assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var imul = glob.Math.imul; function f() {var x = toF(1.5), y = toF(2.4); return imul(x, y) | 0;} return f");109assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var abs = glob.Math.abs; function f() {var x = toF(1.5); return abs(x) | 0;} return f");110assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var abs = glob.Math.abs; function f() {var x = toF(1.5); return +abs(x);} return f");111assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var abs = glob.Math.abs; function f() {var x = toF(1.5); return +toF(abs(x));} return f"), this)(), 1.5);112assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var abs = glob.Math.abs; function f() {var x = toF(1.5); return toF(abs(x))} return f"), this)(), Math.fround(1.5));113assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var abs = glob.Math.abs; function f() {var x = toF(-1.5); return toF(abs(x))} return f"), this)(), Math.fround(1.5));114assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var sqrt = glob.Math.sqrt; function f() {var x = toF(1.5); return sqrt(x) | 0;} return f");115assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var sqrt = glob.Math.sqrt; function f() {var x = toF(1.5); return +sqrt(x);} return f");116assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var sqrt = glob.Math.sqrt; function f() {var x = toF(1.5); return +toF(sqrt(x));} return f"), this)(), Math.fround(Math.sqrt(Math.fround(1.5))));117assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var sqrt = glob.Math.sqrt; function f() {var x = toF(2.25); return toF(sqrt(x))} return f"), this)(), Math.fround(1.5));118assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var sqrt = glob.Math.sqrt; function f() {var x = toF(-1.); return toF(sqrt(x))} return f"), this)(), NaN);119assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var sqrt = glob.Math.sqrt; var inf = glob.Infinity; function f() {var x = toF(0.); x = toF(inf); return toF(sqrt(x))} return f"), this)(), Infinity);120// float?s121assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + HEAP32 + TO_FLOAT32 + "var sqrt = glob.Math.sqrt; function f(x) { x = toF(x); f32[0] = x; return toF(sqrt(f32[0])) } return f"), this, null, heap)(64), Math.fround(8));122// The only other Math functions that can receive float32 as arguments and that strictly commute are floor and ceil (see123// also bug 969203).124var floorModule = asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.floor; function f(x) {x = toF(x); return toF(g(x))} return f"), this);125for (v of [-10.5, -1.2345, -1, 0, 1, 3.141592653, 13.37, Math.Infinity, NaN])126 assertEq(floorModule(v), Math.fround(Math.floor(Math.fround(v))));127assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + HEAP32 + TO_FLOAT32 + "var floor = glob.Math.floor; function f(x) { x = toF(x); f32[0] = x; return toF(floor(f32[0])) } return f"), this, null, heap)(13.37), 13);128var ceilModule = asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.ceil; function f(x) {x = toF(x); return toF(g(x))} return f"), this);129for (v of [-10.5, -1.2345, -1, 0, 1, 3.141592653, 13.37, Math.Infinity, NaN])130 assertEq(ceilModule(v), Math.fround(Math.ceil(Math.fround(v))));131assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + HEAP32 + TO_FLOAT32 + "var ceil = glob.Math.ceil; function f(x) { x = toF(x); f32[0] = x; return toF(ceil(f32[0])) } return f"), this, null, heap)(13.37), 14);132assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.cos; function f(x) {x = toF(x); return toF(g(x))} return f");133assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.cos; function f(x) {x = toF(x); return +(g(x))} return f");134assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.cos; function f(x) {x = x|0; return toF(g(x))} return f");135assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.cos; function f(x) {x = toF(x); return g(x) | 0} return f");136assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.cos; function f(x) {x = +x; return toF(g(+x))} return f"), this)(5), Math.fround(Math.cos(5)));137assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.cos; function f(x) {x = +x; return toF(g(x))} return f"), this)(5), Math.fround(Math.cos(5)));138assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + HEAP32 + TO_FLOAT32 + "var g = glob.Math.cos; function f(x) { x = toF(x); return toF(+g(+x)) } return f"), this, null, heap)(3.14159265358), -1);139// Math functions with arity of two are not specialized for floats, so we shouldn't feed them with floats arguments or140// return type141assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.pow; function f(x) {x = toF(x); return toF(g(x, 2.))} return f");142assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.pow; function f(x) {x = toF(x); return +g(x, 2.)} return f");143assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.pow; function f(x) {x = toF(x); return toF(g(+x, 2.))} return f"), this)(3), 9);144assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.pow; function f(x) {x = toF(x); return +g(+x, 2.)} return f"), this)(3), 9);145assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = glob.Math.pow; function f(x) {x = toF(x); return toF(+g(+x, 2.))} return f"), this)(3), 9);146// Other function calls147// -> Signature comparisons148assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function g(x){x=toF(x); return toF(x);} function f() {var x=toF(4.); var y=toF(0.); var z = 0.; y=toF(g(x)); z = +g(x); return toF(z); } return f");149assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var sqrt=glob.Math.sqrt; function g(x){x=toF(x); return toF(sqrt(x));} function f() {var x=toF(4.); var y=toF(0.); var z = 0.; y = toF(g(x)); z = +toF(g(x)); return toF(z); } return f"), this)(), 2);150// -> FFI151var FFI = "var ffi = env.ffi;";152assertAsmTypeFail('glob', 'env', USE_ASM + TO_FLOAT32 + FFI + "function f() {var x = toF(3.14); return +ffi(x);} return f");153assertAsmTypeFail('glob', 'env', USE_ASM + TO_FLOAT32 + FFI + "function f() {var x = toF(3.14); return toF(ffi(+x));} return f");154var env = {ffi: function(x) { return x+1; }}; // use registers155assertEq(asmLink(asmCompile('glob', 'env', USE_ASM + TO_FLOAT32 + FFI + "function f(x) {x = toF(x); return toF(+ffi(+x));} return f"), this, env)(5), Math.fround(6));156env = {ffi: function(a,b,c,d,e,f,g,h,i) { return a+b+c+d+e+f+g+h+i; }}; // use stack arguments (> 8 arguments on linux x64)157assertEq(asmLink(asmCompile('glob', 'env', USE_ASM + TO_FLOAT32 + FFI + "function f(x) {x = toF(x); return toF(+ffi(+x, 1., 2., 3., 4., 5., -5., -4., 1.));} return f"), this, env)(5), Math.fround(12));158// -> Internal calls159assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function g(x){x=toF(x);return toF(+x + 1.);} function f(x) {x = +x; return toF(g(x));} return f");160assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function g(x){x=toF(x);return toF(+x + 1.);} function f(x) {x = x|0; return toF(g(x));} return f");161assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function g(x){x=toF(x);return toF(+x + 1.);} function f(x) {x = x|0; return toF(g(x));} return f");162assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function g(x){x=toF(x);return toF(+x + 1.);} function f(x) {x = toF(x); return toF(g(x));} return f"), this, env)(5), Math.fround(6));163assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function g(x,y){x=toF(x);y=toF(y);return toF(+x + +y);} function f(x) {x = toF(x); return toF(g(x, toF(1.)));} return f"), this, env)(5), Math.fround(6));164// --> internal calls with unused return values165assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "var g = 4; function s(x) { x = +x; g = (g + ~~x)|0; return g|0;} function f(x) { x = +x; toF(s(x)); return g|0} return f");166assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = 4; function s(x) { x = +x; g = (g + ~~x)|0; return toF(g|0);} function f(x) { x = +x; toF(s(x)); return g|0} return f"), this)(3), 7);167assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = 4; function s(x) { x = toF(x); g = (g + ~~x)|0; return toF(g|0);} function f(x) { x = toF(x); return (toF(s(x)), g)|0} return f"), this)(3), 7);168// --> coerced calls169assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = 4; function s(x) { x = toF(x); g = (g + ~~x)|0; return +(g|0);} function f(x) { x = toF(x); return toF(+s(x))} return f"), this)(3), 7);170assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = 4; function s(x) { x = toF(x); g = (g + ~~x)|0; return g|0;} function f(x) { x = toF(x); return toF(s(x)|0)} return f"), this)(3), 7);171assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "var g = 4; function s(x) { x = toF(x); g = (g + ~~x)|0; return toF(g|0);} function f(x) { x = toF(x); return toF(toF(s(x)))} return f"), this)(3), 7);172// --> test pressure on registers in internal calls when there are |numArgs| arguments173for (numArgs of [5, 9, 17, 33, 65, 129]) {174 let code = (function(n) {175 let args = "", coercions = "", sum = "", call="x";176 for (let i = 0; i < n; i++) {177 let name = 'a' + i;178 args += name + ((i == n-1)?'':',');179 coercions += name + '=toF(' + name + ');';180 sum += ((i>0)?'+':'') + ' +' + name;181 call += (i==0)?'':',toF(' + i + '.)'182 }183 return "function g(" + args + "){" + coercions + "return toF(" + sum + ");}"184 +"function f(x) { x = toF(x); return toF(g(" + call + "))}";185 })(numArgs);186 assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + code + "return f"), this, env)(5), Math.fround(5 + numArgs * (numArgs-1) / 2));187}188// -> Pointer calls189assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function a(x){x=toF(x);return toF(+x + .5);} function b(x){x=toF(x);return toF(+x - .5);} function f(x, n) {x=+x;n=n|0;return toF(t[n&1](x));} var t=[a,b]; return f");190assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function a(x){x=toF(x);return toF(+x + .5);} function b(x){x=toF(x);return toF(+x - .5);} function f(x, n) {x=x|0;n=n|0;return toF(t[n&1](x));} var t=[a,b]; return f");191assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function a(x){x=toF(x);return toF(+x + .5);} function b(x){x=toF(x);return toF(+x - .5);} function f(x, n) {x=toF(x);n=n|0;return t[n&1](x)|0;} var t=[a,b]; return f");192assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function a(x){x=toF(x);return toF(+x + .5);} function b(x){x=toF(x);return toF(+x - .5);} function f(x, n) {x=toF(x);n=n|0;return +t[n&1](x);} var t=[a,b]; return f");193code = asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function a(x){x=toF(x);return toF(+x + .5);} function b(x){x=toF(x);return toF(+x - .5);}"194 + "function f(x, n) {x=toF(x);n=n|0;return toF(t[n&1](x));} var t=[a,b]; return f"), this);195assertEq(code(0, 0), .5);196assertEq(code(0, 1), -.5);197assertEq(code(13.37, 0), Math.fround(13.37 + .5));198assertEq(code(13.37, 1), Math.fround(13.37 - .5));199// Arithmetic operations200// -> mul201assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(3 * toF(4.));} return f");202assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(3. * toF(4.)); } return f");203assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return +(toF(3.) * toF(4.));} return f");204assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(3) * toF(4) * toF(5));} return f");205assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(3.) * toF(4.)); } return f"), this)(), 12);206assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(3 * f32[0]);} return f");207assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(3. * f32[0]);} return f");208assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return +(toF(3.) * f32[0]);} return f");209assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(toF(3.) * f32[0]);} return f"), this, null, heap)(), 12);210var mul = asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x=toF(x); return toF(x * toF(4.));} return f"), this);211assertEq(mul(Infinity), Infinity);212assertEq(mul(NaN), NaN);213assertEq(mul(0), 0);214assertEq(mul(1), 4);215assertEq(mul(0.33), Math.fround(0.33 * 4));216// -> add217assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(3 + toF(4.));} return f");218assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(3.5 + toF(4.));} return f");219assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return +(toF(3.5) + toF(4.));} return f");220assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(3.5) + toF(4.)); } return f"), this)(), 7.5);221assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(3.5) + toF(4.) + toF(4.5));} return f");222assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(toF(3.5) + toF(4.)) + toF(4.5)); } return f"), this)(), 12);223assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(toF(3) + f32[0]);} return f"), this, null, heap)(), 7);224// --> no additions with float? or floatish225assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(3 + f32[0]);} return f");226assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(3. + f32[0]);} return f");227// -> sub228assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(3 - toF(4.));} return f");229assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(3.5 - toF(4.));} return f");230assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return +(toF(3.5) - toF(4.));} return f");231assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(3.5) - toF(4.)); } return f"), this)(), -.5);232assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(3.5) - toF(4.) - toF(4.5));} return f");233assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(toF(3.5) - toF(4.)) - toF(4.5)); } return f"), this)(), -5);234assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(3.5) + toF(4.) - toF(4.5));} return f");235assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(3.5) - toF(4.) + toF(4.5));} return f");236assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(toF(3.5) + toF(4.)) - toF(4.5)); } return f"), this)(), 3);237assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(toF(3.5) - toF(4.)) + toF(4.5)); } return f"), this)(), 4);238assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(3 - f32[0]);} return f");239assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(3. - f32[0]);} return f");240assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return +(toF(3) - f32[0]);} return f");241assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(toF(3) - f32[0]);} return f"), this, null, heap)(), -1);242// -> div243assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(3 / toF(4.));} return f");244assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(3.5 / toF(4.));} return f");245assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return +(toF(3.5) / toF(4.));} return f");246assertEq(asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(12.) / toF(4.)); } return f"), this)(), 3);247assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(3 / f32[0]);} return f");248assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return toF(3. / f32[0]);} return f");249assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 4.; return +(toF(3) / f32[0]);} return f");250assertEq(asmLink(asmCompile('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { f32[0] = 2.; return toF(toF(4) / f32[0]);} return f"), this, null, heap)(), 2);251// -> mod252assertAsmTypeFail('glob', USE_ASM + TO_FLOAT32 + "function f() { return toF(toF(3.5) % toF(4.));} return f");253assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { return toF(f32[0] % toF(4.));} return f");254assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { return toF(toF(3.5) % f32[0]);} return f");255assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { return toF(f32[1] % f32[0]);} return f");256// Comparisons257for (op of ['==', '!=', '<', '>', '<=', '>=']) {258 let code = asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = toF(x); if( x " + op + " toF(3.) ) return 1; else return 0; return -1; } return f"), this);259 let ternary = asmLink(asmCompile('glob', USE_ASM + TO_FLOAT32 + "function f(x) { x = toF(x); return ((x " + op + " toF(3.)) ? 1 : 0)|0 } return f"), this);260 for (v of [-5, 0, 2.5, 3, 13.37, NaN, Infinity]) {261 let expected = eval("("+ v + " " + op + " 3)|0");262 assertEq(code(v) | 0, expected);263 assertEq(ternary(v) | 0, expected);264 }265 assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { if( f32[0] " + op + " toF(3.) ) return 1; else return 0; return -1; } return f");266 assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + TO_FLOAT32 + HEAP32 + "function f() { if( (toF(1.) + toF(2.)) " + op + " toF(3.) ) return 1; else return 0; return -1; } return f");...
testMathLib.js
Source:testMathLib.js
1load(libdir + "asm.js");2function testUnary(f, g) {3 var numbers = [NaN, Infinity, -Infinity, -10000, -3.4, -0, 0, 3.4, 10000];4 for (n of numbers)5 assertEq(f(n), g(n));6}7const FROUND = 'var fround=glob.Math.fround;';8assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var sq=glob.Math.sin; function f(d) { d=+d; return +sq(d) } return f'), {Math:{sin:Math.sqrt}});9assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var sq=glob.Math.sin; function f(d) { d=+d; return +sq(d) } return f'), {Math:{sin:null}});10testUnary(asmLink(asmCompile('glob', USE_ASM + 'var sq=glob.Math.sin; function f(d) { d=+d; return +sq(d) } return f'), {Math:{sin:Math.sin}}), Math.sin);11testUnary(asmLink(asmCompile('glob', USE_ASM + 'const sq=glob.Math.sin; function f(d) { d=+d; return +sq(d) } return f'), {Math:{sin:Math.sin}}), Math.sin);12assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var co=glob.Math.cos; function f(d) { d=+d; return +co(d) } return f'), {Math:{cos:Math.sqrt}});13assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var co=glob.Math.cos; function f(d) { d=+d; return +co(d) } return f'), {Math:{cos:null}});14testUnary(asmLink(asmCompile('glob', USE_ASM + 'var co=glob.Math.cos; function f(d) { d=+d; return +co(d) } return f'), {Math:{cos:Math.cos}}), Math.cos);15assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var ta=glob.Math.tan; function f(d) { d=+d; return +ta(d) } return f'), {Math:{tan:Math.sqrt}});16assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var ta=glob.Math.tan; function f(d) { d=+d; return +ta(d) } return f'), {Math:{tan:null}});17testUnary(asmLink(asmCompile('glob', USE_ASM + 'var ta=glob.Math.tan; function f(d) { d=+d; return +ta(d) } return f'), {Math:{tan:Math.tan}}), Math.tan);18assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var as=glob.Math.asin; function f(d) { d=+d; return +as(d) } return f'), {Math:{asin:Math.sqrt}});19assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var as=glob.Math.asin; function f(d) { d=+d; return +as(d) } return f'), {Math:{asin:null}});20testUnary(asmLink(asmCompile('glob', USE_ASM + 'var as=glob.Math.asin; function f(d) { d=+d; return +as(d) } return f'), {Math:{asin:Math.asin}}), Math.asin);21assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var ac=glob.Math.acos; function f(d) { d=+d; return +ac(d) } return f'), {Math:{acos:Math.sqrt}});22assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var ac=glob.Math.acos; function f(d) { d=+d; return +ac(d) } return f'), {Math:{acos:null}});23testUnary(asmLink(asmCompile('glob', USE_ASM + 'var ac=glob.Math.acos; function f(d) { d=+d; return +ac(d) } return f'), {Math:{acos:Math.acos}}), Math.acos);24assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var at=glob.Math.atan; function f(d) { d=+d; return +at(d) } return f'), {Math:{atan:Math.sqrt}});25assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var at=glob.Math.atan; function f(d) { d=+d; return +at(d) } return f'), {Math:{atan:null}});26testUnary(asmLink(asmCompile('glob', USE_ASM + 'var at=glob.Math.atan; function f(d) { d=+d; return +at(d) } return f'), {Math:{atan:Math.atan}}), Math.atan);27assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var ce=glob.Math.ceil; function f(d) { d=+d; return +ce(d) } return f'), {Math:{ceil:Math.sqrt}});28assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var ce=glob.Math.ceil; function f(d) { d=+d; return +ce(d) } return f'), {Math:{ceil:null}});29testUnary(asmLink(asmCompile('glob', USE_ASM + 'var ce=glob.Math.ceil; function f(d) { d=+d; return +ce(d) } return f'), {Math:{ceil:Math.ceil}}), Math.ceil);30assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var fl=glob.Math.floor; function f(d) { d=+d; return +fl(d) } return f'), {Math:{floor:Math.sqrt}});31assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var fl=glob.Math.floor; function f(d) { d=+d; return +fl(d) } return f'), {Math:{floor:null}});32testUnary(asmLink(asmCompile('glob', USE_ASM + 'var fl=glob.Math.floor; function f(d) { d=+d; return +fl(d) } return f'), {Math:{floor:Math.floor}}), Math.floor);33assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var exq=glob.Math.exp; function f(d) { d=+d; return +exq(d) } return f'), {Math:{exp:Math.sqrt}});34assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var exq=glob.Math.exp; function f(d) { d=+d; return +exq(d) } return f'), {Math:{exp:null}});35testUnary(asmLink(asmCompile('glob', USE_ASM + 'var exq=glob.Math.exp; function f(d) { d=+d; return +exq(d) } return f'), {Math:{exp:Math.exp}}), Math.exp);36assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var lo=glob.Math.log; function f(d) { d=+d; return +lo(d) } return f'), {Math:{log:Math.sqrt}});37assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var lo=glob.Math.log; function f(d) { d=+d; return +lo(d) } return f'), {Math:{log:null}});38testUnary(asmLink(asmCompile('glob', USE_ASM + 'var lo=glob.Math.log; function f(d) { d=+d; return +lo(d) } return f'), {Math:{log:Math.log}}), Math.log);39assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var sq=glob.Math.sqrt; function f(d) { d=+d; return +sq(d) } return f'), {Math:{sqrt:Math.sin}});40assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var sq=glob.Math.sqrt; function f(d) { d=+d; return +sq(d) } return f'), {Math:{sqrt:null}});41testUnary(asmLink(asmCompile('glob', USE_ASM + 'var sq=glob.Math.sqrt; function f(d) { d=+d; return +sq(d) } return f'), {Math:{sqrt:Math.sqrt}}), Math.sqrt);42assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var abs=glob.Math.abs; function f(d) { d=+d; return +abs(d) } return f'), {Math:{abs:Math.sin}});43assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var abs=glob.Math.abs; function f(d) { d=+d; return +abs(d) } return f'), {Math:{abs:null}});44testUnary(asmLink(asmCompile('glob', USE_ASM + 'var abs=glob.Math.abs; function f(d) { d=+d; return +abs(d) } return f'), {Math:{abs:Math.abs}}), Math.abs);45var f = asmLink(asmCompile('glob', USE_ASM + 'var abs=glob.Math.abs; function f(i) { i=i|0; return abs(i|0)|0 } return f'), this);46for (n of [-Math.pow(2,31)-1, -Math.pow(2,31), -Math.pow(2,31)+1, -1, 0, 1, Math.pow(2,31)-2, Math.pow(2,31)-1, Math.pow(2,31)])47 assertEq(f(n), Math.abs(n|0)|0);48var f = asmLink(asmCompile('glob', USE_ASM + 'var clz32=glob.Math.clz32; function f(i) { i=i|0; return clz32(i)|0 } return f'), this);49for (n of [0, 1, 2, 15, 16, Math.pow(2,31)-1, Math.pow(2,31), Math.pow(2,31)+1, Math.pow(2,32)-1, Math.pow(2,32), Math.pow(2,32)+1])50 assertEq(f(n), Math.clz32(n|0));51assertEq(asmLink(asmCompile('glob', USE_ASM + 'var clz32=glob.Math.clz32; function f(i, j) { i=i|0;j=j|0; return (clz32(i) < (j|0))|0 } return f'), this)(0x1, 30), 0);52assertEq(asmLink(asmCompile('glob', USE_ASM + 'var clz32=glob.Math.clz32; function f(i, j) { i=i|0;j=j|0; return (clz32(i) < (j>>>0))|0 } return f'), this)(0x1, 30), 0);53var doubleNumbers = [NaN, Infinity, -Infinity, -10000, -3.4, -0, 0, 3.4, 10000];54var floatNumbers = [];55for (var x of doubleNumbers) floatNumbers.push(Math.fround(x));56var intNumbers = [-Math.pow(2,31), -10000, -3, -1, 0, 3, 10000, Math.pow(2,31), Math.pow(2,31)+1];57function testBinary(f, g, numbers) {58 for (n of numbers)59 for (o of numbers)60 assertEq(f(n,o), g(n,o));61}62assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var po=glob.Math.pow; function f(d,e) { d=+d;e=+e; return +po(d,e) } return f'), {Math:{pow:Math.sin}});63assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var po=glob.Math.pow; function f(d,e) { d=+d;e=+e; return +po(d,e) } return f'), {Math:{pow:null}});64testBinary(asmLink(asmCompile('glob', USE_ASM + 'var po=glob.Math.pow; function f(d,e) { d=+d;e=+e; return +po(d,e) } return f'), {Math:{pow:Math.pow}}), Math.pow, doubleNumbers);65assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var at=glob.Math.atan2; function f(d,e) { d=+d;e=+e; return +at(d,e) } return f'), {Math:{atan2:Math.sin}});66assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var at=glob.Math.atan2; function f(d,e) { d=+d;e=+e; return +at(d,e) } return f'), {Math:{atan2:null}});67testBinary(asmLink(asmCompile('glob', USE_ASM + 'var at=glob.Math.atan2; function f(d,e) { d=+d;e=+e; return +at(d,e) } return f'), {Math:{atan2:Math.atan2}}), Math.atan2, doubleNumbers);68function coercedMin(...args) { for (var i = 0; i < args.length; i++) args[i] = args[i]|0; return Math.min(...args) }69function coercedMax(...args) { for (var i = 0; i < args.length; i++) args[i] = args[i]|0; return Math.max(...args) }70assertAsmTypeFail('glob', USE_ASM + 'var min=glob.Math.min; function f(d) { d=+d; return +min(d) } return f');71assertAsmTypeFail('glob', 'ffi', 'heap', USE_ASM + 'var i32=new glob.Int32Array(heap); var min=glob.Math.min; function f() { return min(i32[0], 5)|0 } return f');72assertAsmTypeFail('glob', USE_ASM + 'var min=glob.Math.min; function f(x) { x=x|0; return min(3 + x, 5)|0 } return f');73assertAsmTypeFail('glob', USE_ASM + 'var min=glob.Math.min; function f(x) { x=x|0; return min(5, 3 + x)|0 } return f');74assertAsmTypeFail('glob', USE_ASM + 'var min=glob.Math.min; function f(x) { x=x|0; return min(x, 1)|0 } return f');75assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; function f(d,e) { d=+d;e=+e; return +min(d,e) } return f'), {Math:{min:Math.sin}});76assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; function f(d,e) { d=+d;e=+e; return +min(d,e) } return f'), {Math:{min:null}});77testBinary(asmLink(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; function f(d,e) { d=+d;e=+e; return +min(d,e) } return f'), {Math:{min:Math.min}}), Math.min, doubleNumbers);78testBinary(asmLink(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; var f32=glob.Math.fround; function f(d,e) { d=f32(d);e=f32(e); return f32(min(d,e)) } return f'), this), Math.min, floatNumbers);79testBinary(asmLink(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; function f(d,e) { d=d|0;e=e|0; return min(d|0,e|0)|0} return f'), {Math:{min:Math.min}}), coercedMin, intNumbers);80assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; function f(d,e) { d=+d;e=+e; return +max(d,e) } return f'), {Math:{max:Math.sin}});81assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; function f(d,e) { d=+d;e=+e; return +max(d,e) } return f'), {Math:{max:null}});82testBinary(asmLink(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; function f(d,e) { d=+d;e=+e; return +max(d,e) } return f'), {Math:{max:Math.max}}), Math.max, doubleNumbers);83testBinary(asmLink(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; var f32=glob.Math.fround; function f(d,e) { d=f32(d);e=f32(e); return f32(max(d,e)) } return f'), this), Math.max, floatNumbers);84testBinary(asmLink(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; function f(d,e) { d=d|0;e=e|0; return max(d|0,e|0)|0} return f'), {Math:{max:Math.max}}), coercedMax, intNumbers);85function testTernary(f, g, numbers) {86 for (n of numbers)87 for (o of numbers)88 for (p of numbers)89 assertEq(f(n,o,p), g(n,o,p));90}91assertAsmTypeFail('glob', USE_ASM + 'var min=glob.Math.min; function f(d,e,g) { d=+d;e=+e;g=g|0; return +min(d,e,g) } return f');92assertAsmTypeFail('glob', USE_ASM + 'var max=glob.Math.max; function f(d,e,g) { d=d|0;e=e|0;g=+g; return max(d,e,g)|0 } return f');93assertAsmTypeFail('glob', USE_ASM + 'var min=glob.Math.min; function f(d,e,g) { d=+d;e=+e;g=+g; return min(d,e,g)|0 } return f');94testTernary(asmLink(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; function f(d,e,g) { d=d|0;e=e|0;g=g|0; return +max(d|0,e|0,g|0) } return f'), {Math:{max:Math.max}}), coercedMax, intNumbers);95testTernary(asmLink(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; function f(d,e,g) { d=d|0;e=e|0;g=g|0; return max(d|0,e|0,g|0)|0 } return f'), {Math:{max:Math.max}}), coercedMax, intNumbers);96testTernary(asmLink(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; function f(d,e,g) { d=+d;e=+e;g=+g; return +max(d,e,g) } return f'), {Math:{max:Math.max}}), Math.max, doubleNumbers);97testTernary(asmLink(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; var _=glob.Math.fround; function f(d,e,g) { d=_(d);e=_(e);g=_(g); return _(max(d,e,g)) } return f'), this), Math.max, floatNumbers);98testTernary(asmLink(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; function f(d,e,g) { d=d|0;e=e|0;g=g|0; return min(d|0,e|0,g|0)|0 } return f'), {Math:{min:Math.min}}), coercedMin, intNumbers);99testTernary(asmLink(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; function f(d,e,g) { d=+d;e=+e;g=+g; return +min(d,e,g) } return f'), {Math:{min:Math.min}}), Math.min, doubleNumbers);100testTernary(asmLink(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; var _=glob.Math.fround; function f(d,e,g) { d=_(d);e=_(e);g=_(g); return _(min(d,e,g)) } return f'), this), Math.min, floatNumbers);101// Implicit return coercions of math functions102assertEq(asmLink(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i) { i=i|0; i = im(i,i); return i|0 } return f'), this)(3), 9);103assertAsmTypeFail('glob', USE_ASM + 'var im=glob.Math.imul; function f(d) { d=+d; d = im(d, d) } return f');104assertAsmTypeFail('glob', USE_ASM + FROUND + 'var im=glob.Math.imul; function f(d) { d=fround(d); d = im(d, d) } return f');105assertEq(asmLink(asmCompile('glob', USE_ASM + 'var abs=glob.Math.abs; function f(d) { d=d|0; d = abs(d|0); return +(d>>>0) } return f'), this)(-1), 1);106assertEq(asmLink(asmCompile('glob', USE_ASM + 'var abs=glob.Math.abs; function f(d) { d=d|0; var m = 0; m = (-1)>>>0; return (abs(d|0) < (m>>>0))|0 } return f'), this)(42), 1);107assertEq(asmLink(asmCompile('glob', USE_ASM + 'var abs=glob.Math.abs; function f(d) { d=+d; d = abs(d); return +d } return f'), this)(-1.5), 1.5);108assertEq(asmLink(asmCompile('glob', USE_ASM + FROUND + 'var abs=glob.Math.abs; function f(d) { d=fround(d); d = fround(abs(d)); return +d } return f'), this)(-1.5), 1.5);109assertAsmTypeFail('glob', USE_ASM + FROUND + 'var abs=glob.Math.abs; function f(d) { d=fround(d); d = abs(d); return +d } return f');110assertAsmTypeFail('glob', USE_ASM + 'var abs=glob.Math.abs; function f(d) { d=d|0; var m = 0; m = -1; return (abs(d|0) < (m|0))|0 } return f');111assertEq(asmLink(asmCompile('glob', USE_ASM + 'var sqrt=glob.Math.sqrt; function f(d) { d=+d; d = sqrt(d); return +d } return f'), this)(256), 16);112assertEq(asmLink(asmCompile('glob', USE_ASM + FROUND + 'var sqrt=glob.Math.sqrt; function f(d) { d=fround(d); d = fround(sqrt(d)); return +d } return f'), this)(13.37), Math.fround(Math.sqrt(Math.fround(13.37))));113assertAsmTypeFail('glob', USE_ASM + FROUND + 'var sqrt=glob.Math.sqrt; function f(d) { d=fround(d); d = sqrt(d); return fround(d) } return f');114assertAsmTypeFail('glob', USE_ASM + FROUND + 'var sqrt=glob.Math.sqrt; function f(d) { d=fround(d); d = sqrt(d); return d } return f');115assertAsmTypeFail('glob', USE_ASM + 'var sqrt=glob.Math.sqrt; function f(n) { n=n|0; var d=0.; d = sqrt(n|0) } return f');116assertAsmTypeFail('glob', USE_ASM + 'var sqrt=glob.Math.sqrt; function f(n) { n=n|0; var d=3.; n = sqrt(d)|0 } return f');117assertEq(asmLink(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; function f(d) { d=+d; d = min(d, 13.); return +d } return f'), this)(12), 12);118assertEq(asmLink(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; function f(d) { d=d|0; d = min(d|0, 11); return d|0 } return f'), this)(12), 11);119assertEq(asmLink(asmCompile('glob', USE_ASM + FROUND + 'var min=glob.Math.min; function f(d) { d=fround(d); d = min(d, fround(13.37)); return fround(d) } return f'), this)(14), Math.fround(13.37));120assertEq(asmLink(asmCompile('glob', USE_ASM + 'var sin=glob.Math.sin; function f(d) { d=+d; d = sin(d); return +d } return f'), this)(Math.PI), Math.sin(Math.PI));121assertAsmTypeFail('glob', USE_ASM + FROUND + 'var sin=glob.Math.sin; function f(d) { d=fround(d); d = sin(d) } return f');122assertAsmTypeFail('glob', USE_ASM + 'var sin=glob.Math.sin; function f(d) { d=d|0; d = sin(d) } return f');123assertEq(asmLink(asmCompile('glob', USE_ASM + 'var pow=glob.Math.pow; function f(d) { d=+d; d = pow(d,d); return +d } return f'), this)(3), 27);124assertAsmTypeFail('glob', USE_ASM + FROUND + 'var pow=glob.Math.pow; function f(d) { d=fround(d); d = pow(d, d) } return f');125assertAsmTypeFail('glob', USE_ASM + 'var pow=glob.Math.pow; function f(d) { d=d|0; d = pow(d, d) } return f');126assertAsmTypeFail('glob', USE_ASM + 'var sin=glob.Math.sin; function f(d) { d=+d; var i=0; i = sin(d)|0; } return f');127assertAsmTypeFail('glob', USE_ASM + 'var pow=glob.Math.pow; function f(d) { d=+d; var i=0; i = pow(d,d)|0; } return f');128assertAsmTypeFail('glob', USE_ASM + 'var atan2=glob.Math.atan2; function f(d) { d=+d; var i=0; i = atan2(d,d)|0; } return f');129assertAsmTypeFail('glob', USE_ASM + 'var sqrt=glob.Math.sqrt; function f(d) { d=+d; sqrt(d)|0; } return f');130assertAsmTypeFail('glob', USE_ASM + 'var abs=glob.Math.abs; function f(d) { d=+d; abs(d)|0; } return f');131assertEq(asmLink(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i) { i=i|0; var d=0.0; d = +im(i,i); return +d } return f'), this)(42), Math.imul(42, 42));132assertEq(asmLink(asmCompile('glob', USE_ASM + 'var abs=glob.Math.abs; function f(i) { i=i|0; var d=0.0; d = +abs(i|0); return +d } return f'), this)(-42), 42);133assertEq(asmLink(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; function f(i) { i=i|0; var d=0.0; d = +min(i|0, 0); return +d } return f'), this)(-42), -42);134assertEq(asmLink(asmCompile('glob', USE_ASM + FROUND + 'var min=glob.Math.min; function f(i) { i=i|0; var d=fround(0); d = fround(min(i|0, 0)); return +d } return f'), this)(-42), -42);135assertEq(asmLink(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; function f(i) { i=i|0; var d=0.0; d = +max(i|0, 0); return +d } return f'), this)(-42), 0);136assertEq(asmLink(asmCompile('glob', USE_ASM + FROUND + 'var max=glob.Math.max; function f(i) { i=i|0; var d=fround(0); d = fround(max(i|0, 0)); return +d } return f'), this)(-42), 0);137assertEq(asmLink(asmCompile('glob', USE_ASM + 'var min=glob.Math.min; function f(d) { d=+d; var i=0; i = ~~min(d, 0.)|0; return i|0 } return f'), this)(-42), -42);138assertEq(asmLink(asmCompile('glob', USE_ASM + FROUND + 'var min=glob.Math.min; function f(d) { d=fround(d); var i=0; i = ~~min(d, fround(0))|0; return i|0 } return f'), this)(-42), -42);139assertEq(asmLink(asmCompile('glob', USE_ASM + 'var max=glob.Math.max; function f(d) { d=+d; var i=0; i = ~~max(d, 0.)|0; return i|0 } return f'), this)(-42), 0);140assertEq(asmLink(asmCompile('glob', USE_ASM + FROUND + 'var max=glob.Math.max; function f(d) { d=fround(d); var i=0; i = ~~max(d, fround(0))|0; return i|0 } return f'), this)(-42), 0);141assertEq(asmLink(asmCompile('glob', USE_ASM + 'var abs=glob.Math.abs; function f(i) { i=i|0; var d=0.0; return +d; +abs(i|0); return 3.0;} return f'), this)(-42), 0);142assertAsmTypeFail('glob', USE_ASM + 'var tau=glob.Math.TAU; function f() {} return f');143assertAsmTypeFail('glob', USE_ASM + 'var pi=glob.Math.PI; function f() { return pi | 0 } return f');144assertAsmTypeFail('glob', USE_ASM + 'var pi=glob.Math.PI; function f() { return +pi() } return f');145assertAsmTypeFail('glob', USE_ASM + 'var pi=glob.Math.PI; function f() { pi = +3; } return f');146assertAsmLinkAlwaysFail(asmCompile('glob', USE_ASM + 'var pi=glob.Math.PI; function f() {} return f'), {});147assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var pi=glob.Math.PI; function f() {} return f'), {Math: {}});148assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var pi=glob.Math.PI; function f() {} return f'), {Math: {PI: Math.cos}});149assertAsmLinkFail(asmCompile('glob', USE_ASM + 'var pi=glob.Math.PI; function f() {} return f'), {Math: {PI: Math.SQRT2}});150for (var c of ['E', 'LN10', 'LN2', 'LOG2E', 'LOG10E', 'PI', 'SQRT1_2', 'SQRT2']) {151 var f = asmLink(asmCompile('glob', USE_ASM + 'var x=glob.Math.' + c +'; function f() { return +x } return f'), this);152 assertEq(f(), eval('Math.' + c));...
expand.js
Source:expand.js
...85 glob.track('after braces');86 // expand extglobs, e.g `foo/!(a|b)`87 glob.track('before extglob');88 if (tok.is.extglob) {89 glob.extglob();90 }91 glob.track('after extglob');92 // expand brackets, e.g `[[:alpha:]]`93 glob.track('before brackets');94 if (tok.is.brackets) {95 glob.brackets();96 }97 glob.track('after brackets');98 // special patterns99 glob._replace('[!', '[^');100 glob._replace('(?', '(%~');101 glob._replace(/\[\]/, '\\[\\]');102 glob._replace('/[', '/' + (opts.dot ? dotfiles : nodot) + '[', true);103 glob._replace('/?', '/' + (opts.dot ? dotfiles : nodot) + '[^/]', true);...
circular-countdown.js
Source:circular-countdown.js
1/** circular countdown.2--------------------------------------------------------------------------------------------------- */3function JBCountDown(settings) {4 var glob = settings;5 function deg(deg) {6 return (Math.PI/180) * deg - (Math.PI/180) * 90;7 }8 glob.total = Math.floor((glob.endDate - glob.startDate)/86400);9 glob.days = Math.floor((glob.endDate - glob.now) / 86400);10 glob.hours = 24 - Math.floor(((glob.endDate - glob.now) % 86400) / 3600);11 glob.minutes = 60 - Math.floor((((glob.endDate - glob.now) % 86400) % 3600) / 60);12 glob.seconds = 60 - Math.floor((glob.endDate - glob.now) % 86400 % 3600 % 60);13 if (glob.now >= glob.endDate) {14 return;15 }16 var clock = {17 set: {18 days: function() {19 var cdays = jQuery(".canvas_days").get(0);20 var ctx = cdays.getContext("2d");21 ctx.clearRect(0, 0, cdays.width, cdays.height);22 ctx.beginPath();23 ctx.strokeStyle = glob.daysColor;24 ctx.shadowBlur = 10;25 ctx.shadowOffsetX = 0;26 ctx.shadowOffsetY = 0;27 ctx.shadowColor = glob.daysGlow;28 ctx.arc(54.5, 54.5, 52.5, deg(0), deg(360 / glob.total * (glob.total - glob.days)));29 ctx.lineWidth = 14;30 ctx.stroke();31 jQuery(".clock-days .val").text(glob.days);32 },33 hours: function() {34 var cHr = jQuery(".canvas_hours").get(0);35 var ctx = cHr.getContext("2d");36 ctx.clearRect(0, 0, cHr.width, cHr.height);37 ctx.beginPath();38 ctx.strokeStyle = glob.hoursColor;39 ctx.shadowBlur = 6;40 ctx.shadowOffsetX = 0;41 ctx.shadowOffsetY = 0;42 ctx.shadowColor = glob.hoursGlow;43 ctx.arc(54.5, 54.5, 52.5, deg(0), deg(15 * glob.hours));44 ctx.lineWidth = 6;45 ctx.stroke();46 jQuery(".clock-hours .val").text(24 - glob.hours);47 },48 minutes: function() {49 var cMin = jQuery(".canvas_minutes").get(0);50 var ctx = cMin.getContext("2d");51 ctx.clearRect(0, 0, cMin.width, cMin.height);52 ctx.beginPath();53 ctx.strokeStyle = glob.minutesColor;54 ctx.shadowBlur = 6;55 ctx.shadowOffsetX = 0;56 ctx.shadowOffsetY = 0;57 ctx.shadowColor = glob.minutesGlow;58 ctx.arc(54.5, 54.5, 52.5, deg(0), deg(6 * glob.minutes));59 ctx.lineWidth = 6;60 ctx.stroke();61 jQuery(".clock-minutes .val").text(60 - glob.minutes);62 },63 seconds: function() {64 var cSec = jQuery(".canvas_seconds").get(0);65 var ctx = cSec.getContext("2d");66 ctx.clearRect(0, 0, cSec.width, cSec.height);67 ctx.beginPath();68 ctx.strokeStyle = glob.secondsColor;69 ctx.shadowBlur = 6;70 ctx.shadowOffsetX = 0;71 ctx.shadowOffsetY = 0;72 ctx.shadowColor = glob.secondsGlow;73 ctx.arc(54.5, 54.5, 52.5, deg(0), deg(6 * glob.seconds));74 ctx.lineWidth = 6;75 ctx.stroke();76 jQuery(".clock-seconds .val").text(60 - glob.seconds);77 }78 },79 start: function() {80 /* Seconds */81 var cdown = setInterval(function() {82 if (glob.seconds > 59) {83 if (60 - glob.minutes === 0 && 24 - glob.hours === 0 && glob.days === 0) {84 clearInterval(cdown);85 /* Countdown is complete */86 return;87 }88 glob.seconds = 1;89 if (glob.minutes > 59) {90 glob.minutes = 1;91 clock.set.minutes();92 if (glob.hours > 23) {93 glob.hours = 1;94 if (glob.days > 0) {95 glob.days--;96 clock.set.days();97 }98 } else {99 glob.hours++;100 }101 clock.set.hours();102 } else {103 glob.minutes++;104 }105 clock.set.minutes();106 } else {107 glob.seconds++;108 }109 clock.set.seconds();110 }, 1000);111 }112 };113 clock.set.seconds();114 clock.set.minutes();115 clock.set.hours();116 clock.set.days();117 clock.start();118}119 /** circular countdown.120 --------------------------------------------------------------------------------------------------- */121 var findClass = jQuery('.banner-right-content');122 if (findClass.length) {123 jQuery(document).ready(function() {124 "use strict";125 JBCountDown({126 secondsColor: "#0fbcf9",127 secondsGlow: "none",128 minutesColor: "#0be881",129 minutesGlow: "none",130 hoursColor: "#f53b57",131 hoursGlow: "none",132 daysColor: "#ffd32a",133 daysGlow: "none",134 // startDate : "1443657600",135 endDate: "1445385600",136 now: "1444200921"137 });138 });...
index.js
Source:index.js
1'use strict';2var through2 = require('through2');3var Combine = require('ordered-read-streams');4var unique = require('unique-stream');5var glob = require('glob');6var micromatch = require('micromatch');7var resolveGlob = require('to-absolute-glob');8var globParent = require('glob-parent');9var path = require('path');10var extend = require('extend');11var sepRe = (process.platform === 'win32' ? /[\/\\]/ : /\/+/);12var gs = {13 // Creates a stream for a single glob or filter14 createStream: function(ourGlob, negatives, opt) {15 var ourOpt = extend({}, opt);16 delete ourOpt.root;17 // Extract base path from glob18 var basePath = ourOpt.base || getBasePath(ourGlob, opt);19 // Remove path relativity to make globs make sense20 ourGlob = resolveGlob(ourGlob, opt);21 // Create globbing stuff22 var globber = new glob.Glob(ourGlob, ourOpt);23 // Create stream and map events from globber to it24 var stream = through2.obj(opt,25 negatives.length ? filterNegatives : undefined);26 var found = false;27 globber.on('error', stream.emit.bind(stream, 'error'));28 globber.once('end', function() {29 if (opt.allowEmpty !== true && !found && globIsSingular(globber)) {30 stream.emit('error',31 new Error('File not found with singular glob: ' + ourGlob));32 }33 stream.end();34 });35 globber.on('match', function(filename) {36 found = true;37 stream.write({38 cwd: opt.cwd,39 base: basePath,40 path: path.normalize(filename),41 });42 });43 return stream;44 function filterNegatives(filename, enc, cb) {45 var matcha = isMatch.bind(null, filename);46 if (negatives.every(matcha)) {47 cb(null, filename); // Pass48 } else {49 cb(); // Ignore50 }51 }52 },53 // Creates a stream for multiple globs or filters54 create: function(globs, opt) {55 if (!opt) {56 opt = {};57 }58 if (typeof opt.cwd !== 'string') {59 opt.cwd = process.cwd();60 }61 if (typeof opt.dot !== 'boolean') {62 opt.dot = false;63 }64 if (typeof opt.silent !== 'boolean') {65 opt.silent = true;66 }67 if (typeof opt.nonull !== 'boolean') {68 opt.nonull = false;69 }70 if (typeof opt.cwdbase !== 'boolean') {71 opt.cwdbase = false;72 }73 if (opt.cwdbase) {74 opt.base = opt.cwd;75 }76 // Only one glob no need to aggregate77 if (!Array.isArray(globs)) {78 globs = [globs];79 }80 var positives = [];81 var negatives = [];82 var ourOpt = extend({}, opt);83 delete ourOpt.root;84 globs.forEach(function(glob, index) {85 if (typeof glob !== 'string' && !(glob instanceof RegExp)) {86 throw new Error('Invalid glob at index ' + index);87 }88 var globArray = isNegative(glob) ? negatives : positives;89 // Create Minimatch instances for negative glob patterns90 if (globArray === negatives && typeof glob === 'string') {91 var ourGlob = resolveGlob(glob, opt);92 glob = micromatch.matcher(ourGlob, ourOpt);93 }94 globArray.push({95 index: index,96 glob: glob,97 });98 });99 if (positives.length === 0) {100 throw new Error('Missing positive glob');101 }102 // Only one positive glob no need to aggregate103 if (positives.length === 1) {104 return streamFromPositive(positives[0]);105 }106 // Create all individual streams107 var streams = positives.map(streamFromPositive);108 // Then just pipe them to a single unique stream and return it109 var aggregate = new Combine(streams);110 var uniqueStream = unique('path');111 var returnStream = aggregate.pipe(uniqueStream);112 aggregate.on('error', function(err) {113 returnStream.emit('error', err);114 });115 return returnStream;116 function streamFromPositive(positive) {117 var negativeGlobs = negatives.filter(indexGreaterThan(positive.index))118 .map(toGlob);119 return gs.createStream(positive.glob, negativeGlobs, opt);120 }121 },122};123function isMatch(file, matcher) {124 if (typeof matcher === 'function') {125 return matcher(file.path);126 }127 if (matcher instanceof RegExp) {128 return matcher.test(file.path);129 }130}131function isNegative(pattern) {132 if (typeof pattern === 'string') {133 return pattern[0] === '!';134 }135 if (pattern instanceof RegExp) {136 return true;137 }138}139function indexGreaterThan(index) {140 return function(obj) {141 return obj.index > index;142 };143}144function toGlob(obj) {145 return obj.glob;146}147function globIsSingular(glob) {148 var globSet = glob.minimatch.set;149 if (globSet.length !== 1) {150 return false;151 }152 return globSet[0].every(function isString(value) {153 return typeof value === 'string';154 });155}156function getBasePath(ourGlob, opt) {157 var basePath;158 var parent = globParent(ourGlob);159 if (parent === '/' && opt && opt.root) {160 basePath = path.normalize(opt.root);161 } else {162 basePath = resolveGlob(parent, opt);163 }164 if (!sepRe.test(basePath.charAt(basePath.length - 1))) {165 basePath += path.sep;166 }167 return basePath;168}...
countdown.js
Source:countdown.js
1function HangoutCountDown(settings) {2 var glob = settings;3 4 function deg(deg) {5 return (Math.PI/180)*deg - (Math.PI/180)*906 }7 8 glob.total = Math.floor((glob.endDate - glob.startDate)/86400);9 glob.days = Math.floor((glob.endDate - glob.now ) / 86400);10 glob.hours = 24 - Math.floor(((glob.endDate - glob.now) % 86400) / 3600);11 glob.minutes = 60 - Math.floor((((glob.endDate - glob.now) % 86400) % 3600) / 60) ;12 13 if (glob.now >= glob.endDate){14 return;15 }16 17 var clock = {18 set: {19 days: function(){20 var cdays = $("#canvas_days").get(0);21 var ctx = cdays.getContext("2d");22 ctx.clearRect(0, 0, cdays.width, cdays.height);23 ctx.beginPath();24 ctx.strokeStyle = glob.daysColor;25 26 ctx.shadowBlur = 10;27 ctx.shadowOffsetX = 0;28 ctx.shadowOffsetY = 0;29 ctx.shadowColor = glob.daysGlow;30 31 ctx.arc(45,45,35, deg(0), deg((360/glob.total)*(glob.total - glob.days)));32 ctx.lineWidth = 5;33 ctx.stroke();34 $(".clock_days .val").text(glob.days);35 },36 37 hours: function(){38 var cHr = $("#canvas_hours").get(0);39 var ctx = cHr.getContext("2d");40 ctx.clearRect(0, 0, cHr.width, cHr.height);41 ctx.beginPath();42 ctx.strokeStyle = glob.hoursColor;43 44 ctx.shadowBlur = 10;45 ctx.shadowOffsetX = 0;46 ctx.shadowOffsetY = 0;47 ctx.shadowColor = glob.hoursGlow;48 49 ctx.arc(45,45,35, deg(0), deg(15*glob.hours));50 ctx.lineWidth = 5;51 ctx.stroke();52 $(".clock_hours .val").text(24 - glob.hours);53 },54 55 minutes : function(){56 var cMin = $("#canvas_minutes").get(0);57 var ctx = cMin.getContext("2d");58 ctx.clearRect(0, 0, cMin.width, cMin.height);59 ctx.beginPath();60 ctx.strokeStyle = glob.minutesColor;61 62 ctx.shadowBlur = 10;63 ctx.shadowOffsetX = 0;64 ctx.shadowOffsetY = 0;65 ctx.shadowColor = glob.minutesGlow;66 67 ctx.arc(45,45,35, deg(0), deg(6*glob.minutes));68 ctx.lineWidth = 5;69 ctx.stroke();70 $(".clock_minutes .val").text(60 - glob.minutes);71 },72 seconds: function(){73 var cSec = $("#canvas_seconds").get(0);74 var ctx = cSec.getContext("2d");75 ctx.clearRect(0, 0, cSec.width, cSec.height);76 ctx.beginPath();77 ctx.strokeStyle = glob.secondsColor;78 79 ctx.shadowBlur = 10;80 ctx.shadowOffsetX = 0;81 ctx.shadowOffsetY = 0;82 ctx.shadowColor = glob.secondsGlow;83 84 ctx.arc(45,45,35, deg(0), deg(6*glob.seconds));85 ctx.lineWidth = 5;86 ctx.stroke();87 88 $(".clock_seconds .val").text(60 - glob.seconds);89 }90 },91 92 start: function(){93 /* Seconds */94 var cdown = setInterval(function(){95 if ( glob.seconds > 59 ) {96 if (60 - glob.minutes == 0 && 24 - glob.hours == 0 && glob.days == 0) {97 clearInterval(cdown);98 99 /* Countdown is complete */100 101 window.location.reload();102 103 104 return;105 }106 glob.seconds = 1;107 if (glob.minutes > 59) {108 glob.minutes = 1;109 clock.set.minutes();110 if (glob.hours > 23) {111 glob.hours = 1;112 if (glob.days > 0) {113 glob.days--;114 clock.set.days();115 }116 } else {117 glob.hours++;118 }119 clock.set.hours();120 } else {121 glob.minutes++;122 }123 clock.set.minutes();124 } else {125 glob.seconds++;126 }127 clock.set.seconds();128 129 },1000);130 }131 }132 clock.set.seconds();133 clock.set.minutes();134 clock.set.hours();135 clock.set.days();136 clock.start();...
testAddressErrors.js
Source:testAddressErrors.js
1load(libdir + "asm.js");2setIonCheckGraphCoherency(false);3setCachingEnabled(false);4// constants5var buf = new ArrayBuffer(BUF_MIN);6// An unshifted literal constant byte index in the range 0 to 2^31-1 inclusive should give a link failure.7assertAsmLinkFail(asmCompile('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int8Array(b); function f() {return arr[0x7fffffff]|0 } return f'), this, null, buf);8assertAsmLinkFail(asmCompile('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0x1fffffff]|0 } return f'), this, null, buf);9// An unshifted literal constant byte index outside the range 0 to 2^31-1 inclusive should cause an error compiling.10assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0x20000000]|0 } return f');11assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0x3fffffff]|0 } return f');12assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0x40000000]|0 } return f');13assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0x7fffffff]|0 } return f');14assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0x80000000]|0 } return f');15assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0x8fffffff]|0 } return f');16assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0xffffffff]|0 } return f');17assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0x100000000]|0 } return f');18assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int8Array(b); function f() {return arr[0x80000000]|0 } return f');19assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int8Array(b); function f() {return arr[0xffffffff]|0 } return f');20assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int8Array(b); function f() {return arr[0x100000000]|0 } return f');21assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int16Array(b); function f() {return arr[-1]|0 } return f');22assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[-2]|0 } return f');23assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[10-12]|0 } return f');24// An intish shifted literal constant index should not fail to compile or link.25assertEq(asmLink(asmCompile('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int8Array(b); function f() {return arr[0x3fffffff>>0]|0 } return f'), this, null, buf)(), 0);26assertEq(asmLink(asmCompile('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0x3fffffff>>2]|0 } return f'), this, null, buf)(), 0);27assertEq(asmLink(asmCompile('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int8Array(b); function f() {return arr[0xffffffff>>0]|0 } return f'), this, null, buf)(), 0);28assertEq(asmLink(asmCompile('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0xffffffff>>2]|0 } return f'), this, null, buf)(), 0);29assertEq(asmLink(asmCompile('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int8Array(b); function f() {return arr[-1>>0]|0 } return f'), this, null, buf)(), 0);30assertEq(asmLink(asmCompile('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[-1>>2]|0 } return f'), this, null, buf)(), 0);31// Unsigned (intish) folded constant index.32assertEq(asmLink(asmCompile('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int8Array(b); function f() {return arr[0xffffffff>>>0]|0 } return f'), this, null, buf)(), 0);33assertEq(asmLink(asmCompile('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int8Array(b); function f() {arr[0] = 1; return arr[(0xffffffff+1)>>>0]|0 } return f'), this, null, buf)(), 1);34// A non-intish shifted literal constant index should cause an error compiling.35assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int8Array(b); function f() {return arr[0x100000000>>0]|0 } return f');36assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + 'var arr=new glob.Int32Array(b); function f() {return arr[0x100000000>>2]|0 } return f');37// Folded non-intish constant expressions should cause an error compiling....
readable.js
Source:readable.js
1'use strict';2var inherits = require('util').inherits;3var glob = require('glob');4var extend = require('extend');5var Readable = require('readable-stream').Readable;6var globParent = require('glob-parent');7var toAbsoluteGlob = require('to-absolute-glob');8var removeTrailingSeparator = require('remove-trailing-separator');9var globErrMessage1 = 'File not found with singular glob: ';10var globErrMessage2 = ' (if this was purposeful, use `allowEmpty` option)';11function getBasePath(ourGlob, opt) {12 return globParent(toAbsoluteGlob(ourGlob, opt));13}14function globIsSingular(glob) {15 var globSet = glob.minimatch.set;16 if (globSet.length !== 1) {17 return false;18 }19 return globSet[0].every(function isString(value) {20 return typeof value === 'string';21 });22}23function GlobStream(ourGlob, negatives, opt) {24 if (!(this instanceof GlobStream)) {25 return new GlobStream(ourGlob, negatives, opt);26 }27 var ourOpt = extend({}, opt);28 Readable.call(this, {29 objectMode: true,30 highWaterMark: ourOpt.highWaterMark || 16,31 });32 // Delete `highWaterMark` after inheriting from Readable33 delete ourOpt.highWaterMark;34 var self = this;35 function resolveNegatives(negative) {36 return toAbsoluteGlob(negative, ourOpt);37 }38 var ourNegatives = negatives.map(resolveNegatives);39 ourOpt.ignore = ourNegatives;40 var cwd = ourOpt.cwd;41 var allowEmpty = ourOpt.allowEmpty || false;42 // Extract base path from glob43 var basePath = ourOpt.base || getBasePath(ourGlob, ourOpt);44 // Remove path relativity to make globs make sense45 ourGlob = toAbsoluteGlob(ourGlob, ourOpt);46 // Delete `root` after all resolving done47 delete ourOpt.root;48 var globber = new glob.Glob(ourGlob, ourOpt);49 this._globber = globber;50 var found = false;51 globber.on('match', function(filepath) {52 found = true;53 var obj = {54 cwd: cwd,55 base: basePath,56 path: removeTrailingSeparator(filepath),57 };58 if (!self.push(obj)) {59 globber.pause();60 }61 });62 globber.once('end', function() {63 if (allowEmpty !== true && !found && globIsSingular(globber)) {64 var err = new Error(globErrMessage1 + ourGlob + globErrMessage2);65 return self.destroy(err);66 }67 self.push(null);68 });69 function onError(err) {70 self.destroy(err);71 }72 globber.once('error', onError);73}74inherits(GlobStream, Readable);75GlobStream.prototype._read = function() {76 this._globber.resume();77};78GlobStream.prototype.destroy = function(err) {79 var self = this;80 this._globber.abort();81 process.nextTick(function() {82 if (err) {83 self.emit('error', err);84 }85 self.emit('close');86 });87};...
Using AI Code Generation
1const glob = require('glob');2const glob = require('glob');3const glob = require('glob');4const glob = require('glob');5const glob = require('glob');6const glob = require('glob');7const glob = require('glob');8const glob = require('glob');9const glob = require('glob');10const glob = require('glob');11const glob = require('glob');12const glob = require('glob');13const glob = require('glob');14const glob = require('glob');15const glob = require('glob');16const glob = require('glob');17const glob = require('glob');18const glob = require('glob');19const glob = require('glob');20const glob = require('glob');21const glob = require('glob');22const glob = require('glob');23const glob = require('glob');
Using AI Code Generation
1const glob = require('glob');2const childGlob = require('stryker-child/node_modules/glob');3const parentGlob = require('stryker-parent/node_modules/glob');4module.exports = function (config) {5 config.set({6 { pattern: glob.sync('stryker-parent/**/*.js'), included: false },7 { pattern: childGlob.sync('stryker-child/**/*.js'), included: false },8 { pattern: parentGlob.sync('stryker-parent/**/*.js'), included: false },9 });10};
Using AI Code Generation
1const glob = require('glob');2const strykerParent = require('stryker-parent');3const strykerParentGlob = strykerParent.glob;4const globResult = glob.sync('**/*.js');5const strykerParentGlobResult = strykerParentGlob.sync('**/*.js');6console.log(globResult);7console.log(strykerParentGlobResult);8const glob = require('glob');9const strykerParent = require('stryker-parent');10const strykerParentGlob = strykerParent.glob;11const globResult = glob.sync('**/*.js');12const strykerParentGlobResult = strykerParentGlob.sync('**/*.js');13console.log(globResult);14console.log(strykerParentGlobResult);15Your name to display (optional):16Your name to display (optional):17{ 'glob': '^7.1.2', 'lodash': '^4.17.4' }18Your name to display (optional):19{ 'glob': '^7.1.2', 'lodash': '^4.17.4' }20Your name to display (optional):
Using AI Code Generation
1const glob = require('glob');2const files = glob.sync('**/*.js', { cwd: __dirname, ignore: ['**/node_modules/**'] });3console.log(files);4module.exports = function (config) {5 config.set({6 });7};8const files = glob.sync('**/*.js', { cwd: __dirname, ignore: ['**/node_modules/**'] });9const files = glob.sync('**/*.js', { cwd: __dirname, ignore: ['**/node_modules/**'] });10const files = glob.sync('**/*.js', { cwd: __dirname, ignore: ['**/node_modules/**'] });11const files = glob.sync('**/*.js', { cwd: __dirname, ignore: ['**/node_modules/**'] });12const files = glob.sync('**/*.js', { cwd: __dirname, ignore: ['**/node_modules/**'] });
Using AI Code Generation
1const { glob } = require('stryker-parent/glob');2glob('**/*.js', { cwd: __dirname }, (err, files) => {3 console.log('files', files);4});5const { glob } = require('stryker/glob');6glob('**/*.js', { cwd: __dirname }, (err, files) => {7 console.log('files', files);8});
Using AI Code Generation
1var glob = require('glob');2var files = glob.sync('**/*.js', {cwd: '/path/to/your/project'});3console.log(files);4var glob = require('stryker/node_modules/glob');5var files = glob.sync('**/*.js', {cwd: '/path/to/your/project'});6console.log(files);7var glob = require('stryker-child/node_modules/glob');8var files = glob.sync('**/*.js', {cwd: '/path/to/your/project'});9console.log(files);
Using AI Code Generation
1var glob = require('glob');2var files = glob.sync('**/*.js', { cwd: '/home/str/stryker-parent' });3console.log(files);4var glob = require('glob');5var files = glob.sync('**/*.js', { cwd: '/home/str/stryker-parent' });6console.log(files);7var glob = require('glob');8var files = glob.sync('**/*.js', { cwd: '/home/str/stryker-parent' });9console.log(files);10var glob = require('glob');11var files = glob.sync('**/*.js', { cwd: '/home/str/stryker-parent' });12console.log(files);13var glob = require('glob');14var files = glob.sync('**/*.js', { cwd: '/home/str/stryker-parent' });15console.log(files);16var glob = require('glob');17var files = glob.sync('**/*.js', { cwd: '/home/str/stryker-parent' });18console.log(files);19var glob = require('glob');20var files = glob.sync('**/*.js', { cwd: '/home/str/stryker-parent' });21console.log(files);22var glob = require('glob');23var files = glob.sync('**/*.js', { cwd: '/home/str/stryker-parent' });24console.log(files);25var glob = require('glob');26var files = glob.sync('**/*.js', { cwd: '/home/str/stryker-parent' });27console.log(files);28var glob = require('glob');
Using AI Code Generation
1var glob = require('glob');2var globber = new glob.Glob('**/*.js', {cwd: 'C:/Users/MyName/stryker/stryker-parent/'}, function (err, matches) {3 if (err) {4 throw err;5 }6 console.log(matches);7});8var glob = require('glob');9var globber = new glob.Glob('**/*.js', {cwd: 'C:/Users/MyName/stryker/stryker/'}, function (err, matches) {10 if (err) {11 throw err;12 }13 console.log(matches);14});15var glob = require('glob');16var globber = new glob.Glob('**/*.js', {cwd: 'C:/Users/MyName/stryker/stryker-api/'}, function (err, matches) {17 if (err) {18 throw err;19 }20 console.log(matches);21});22var glob = require('glob');23var globber = new glob.Glob('**/*.js', {cwd: 'C:/Users/MyName/stryker/stryker-html-reporter/'}, function (err, matches) {24 if (err) {25 throw err;26 }27 console.log(matches);28});29var glob = require('glob');30var globber = new glob.Glob('**/*.js', {cwd: 'C:/Users/MyName/stryker/stryker-cli/'}, function (err, matches) {31 if (err) {32 throw err;33 }34 console.log(matches);35});36var glob = require('glob');37var globber = new glob.Glob('**/*.js', {cwd: 'C:/Users/MyName/stryker/stryker-jasmine-runner/'}, function (err, matches) {38 if (err) {39 throw err;40 }41 console.log(matches);42});43var glob = require('glob');44var globber = new glob.Glob('**/*.js', {cwd: 'C:/Users/MyName/stryker/stry
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run stryker-parent automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
