From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- js/src/jit-test/tests/self-test/assertDeepEq.js | 111 +++++++++++++++++++++ .../tests/self-test/assertRecoveredOnBailout-0.js | 9 ++ .../tests/self-test/assertRecoveredOnBailout-1.js | 32 ++++++ .../tests/self-test/getBacktrace-bug1138195.js | 8 ++ js/src/jit-test/tests/self-test/inIon.js | 20 ++++ js/src/jit-test/tests/self-test/inJit.js | 20 ++++ .../tests/self-test/isRelazifiableFunction-0.js | 3 + js/src/jit-test/tests/self-test/notInIon.js | 3 + js/src/jit-test/tests/self-test/notInJit.js | 4 + js/src/jit-test/tests/self-test/readlineBuf.js | 40 ++++++++ 10 files changed, 250 insertions(+) create mode 100644 js/src/jit-test/tests/self-test/assertDeepEq.js create mode 100644 js/src/jit-test/tests/self-test/assertRecoveredOnBailout-0.js create mode 100644 js/src/jit-test/tests/self-test/assertRecoveredOnBailout-1.js create mode 100644 js/src/jit-test/tests/self-test/getBacktrace-bug1138195.js create mode 100644 js/src/jit-test/tests/self-test/inIon.js create mode 100644 js/src/jit-test/tests/self-test/inJit.js create mode 100644 js/src/jit-test/tests/self-test/isRelazifiableFunction-0.js create mode 100644 js/src/jit-test/tests/self-test/notInIon.js create mode 100644 js/src/jit-test/tests/self-test/notInJit.js create mode 100644 js/src/jit-test/tests/self-test/readlineBuf.js (limited to 'js/src/jit-test/tests/self-test') diff --git a/js/src/jit-test/tests/self-test/assertDeepEq.js b/js/src/jit-test/tests/self-test/assertDeepEq.js new file mode 100644 index 000000000..b2a949abc --- /dev/null +++ b/js/src/jit-test/tests/self-test/assertDeepEq.js @@ -0,0 +1,111 @@ +// Tests for the assertEqual function in jit-test/lib/asserts.js + +load(libdir + "asserts.js"); + +function assertNotDeepEq(a, b, options) { + assertThrowsInstanceOf(() => assertDeepEq(a, b, options), Error); +} + +// primitives +assertDeepEq(undefined, undefined); +assertDeepEq("1", "1"); +assertNotDeepEq(1, "1"); +assertNotDeepEq(undefined, null); +assertNotDeepEq({}, null); + +// symbols +assertDeepEq(Symbol(), Symbol()); +assertNotDeepEq(Symbol(), Symbol("")); +assertDeepEq(Symbol("tweedledum"), Symbol("tweedledum")); +assertNotDeepEq(Symbol("tweedledum"), Symbol("alice")); +assertNotDeepEq(Symbol("what-its-called"), Symbol.for("what-its-called")); +assertNotDeepEq(Symbol.iterator, Symbol.for("Symbol.iterator")); +assertDeepEq([Symbol(), Symbol(), Symbol()], + [Symbol(), Symbol(), Symbol()]); +var sym = Symbol(); +assertDeepEq([sym, sym], [sym, sym]); +assertNotDeepEq([sym, sym], [Symbol(), Symbol()]); +assertNotDeepEq([sym, sym], [Symbol(), sym]); +var obj1 = {}, obj2 = {}; +obj1[Symbol("x")] = "y"; +obj2[Symbol("x")] = "y"; +assertDeepEq(obj1, obj2); + +// objects +assertDeepEq({}, {}); +assertDeepEq({one: 1, two: 2}, {one: 1, two: 2}); +assertNotDeepEq(Object.freeze({}), {}); +assertDeepEq(Object.create(null), Object.create(null)); +assertNotDeepEq(Object.create(null, {a: {configurable: false, value: 3}}), + Object.create(null, {a: {configurable: true, value: 3}})); +assertNotDeepEq({one: 1}, {one: 1, two: 2}); +assertNotDeepEq({yes: true}, {oui: true}); +assertNotDeepEq({zero: 0}, {zero: "0"}); + +// test the comment +var x = {}, y = {}, ax = [x]; +assertDeepEq([ax, x], [ax, y]); // passes (bogusly) +assertNotDeepEq([ax, x], [ax, y], {strictEquivalence: true}); +assertDeepEq([x, ax], [y, ax]); // passes (bogusly) +assertNotDeepEq([x, ax], [y, ax], {strictEquivalence: true}); + +// object identity +assertNotDeepEq([x, y], [x, x]); +assertDeepEq([x, y], [x, y]); +assertDeepEq([y, x], [x, y]); + +// proto chain +var x = {}; +assertDeepEq(Object.create(x), Object.create(x)); +assertDeepEq(Object.create({}), Object.create({})); // equivalent but not identical proto objects + +// arrays +assertDeepEq([], []); +assertNotDeepEq([], [1]); +assertDeepEq([1], [1]); +assertNotDeepEq([0], [1]); +assertDeepEq([1, 2, 3], [1, 2, 3]); +assertNotDeepEq([1, , 3], [1, undefined, 3]); +var p = [], q = []; +p.prop = 1; +assertNotDeepEq(p, q); +assertNotDeepEq(q, p); +q.prop = 1; +assertDeepEq(q, p); + +// functions +assertNotDeepEq(() => 1, () => 2); +assertNotDeepEq((...x) => 1, x => 1); +assertNotDeepEq(function f(){}, function g(){}); +var f1 = function () {}, f2 = function () {}; +assertDeepEq(f1, f1); +assertDeepEq(f1, f2); // same text, close enough +f1.prop = 1; +assertNotDeepEq(f1, f2); +f2.prop = 1; +assertDeepEq(f1, f2); + +// recursion +var a = [], b = []; +a[0] = a; +b[0] = b; +assertDeepEq(a, b); +a[0] = b; +assertNotDeepEq(a, b); // [#1=[#1#]] is not structurally equivalent to #1=[[#1#]] +b[0] = a; +assertDeepEq(a, b); +b[0] = [a]; // a[0] === b, b[0] === c, c[0] === a +assertDeepEq(a, b); + +// objects that merge +var x = {}; +assertDeepEq({x: x}, {x: x}); +var y = [x]; +assertDeepEq([y], [y]); + +// cross-compartment +var g1 = newGlobal(), g2 = newGlobal(); +assertDeepEq(g1, g2); +assertDeepEq(g1, g2, {strictEquivalence: true}); +Object.preventExtensions(g2.Math.abs); // make some miniscule change +assertNotDeepEq(g1, g2); diff --git a/js/src/jit-test/tests/self-test/assertRecoveredOnBailout-0.js b/js/src/jit-test/tests/self-test/assertRecoveredOnBailout-0.js new file mode 100644 index 000000000..39466f648 --- /dev/null +++ b/js/src/jit-test/tests/self-test/assertRecoveredOnBailout-0.js @@ -0,0 +1,9 @@ +function f () { + var o = {}; + var x = assertRecoveredOnBailout(o, true); + bailout(); + return x; +} + +f(); +f(); diff --git a/js/src/jit-test/tests/self-test/assertRecoveredOnBailout-1.js b/js/src/jit-test/tests/self-test/assertRecoveredOnBailout-1.js new file mode 100644 index 000000000..6285d4932 --- /dev/null +++ b/js/src/jit-test/tests/self-test/assertRecoveredOnBailout-1.js @@ -0,0 +1,32 @@ +// |jit-test| crash + +var opts = getJitCompilerOptions(); +if (!opts['ion.enable'] || !opts['baseline.enable'] || + opts["ion.forceinlineCaches"] || opts["ion.check-range-analysis"]) +{ + crash("Cannot test assertRecoveredOnBailout"); +} + +function g() { + return inIon(); +} + +// Wait until IonMonkey compilation finished. +while(!(res = g())); + +// Check that we entered Ion succesfully. +if (res !== true) + crash("Cannot enter IonMonkey"); + +// Test that assertRecoveredOnBailout fails as expected. +function f () { + var o = {}; + assertRecoveredOnBailout(o, false); + return inIon(); +} + +// Wait until IonMonkey compilation finished. +while(!(res = f())); + +// Ensure that we entered Ion. +assertEq(res, true); diff --git a/js/src/jit-test/tests/self-test/getBacktrace-bug1138195.js b/js/src/jit-test/tests/self-test/getBacktrace-bug1138195.js new file mode 100644 index 000000000..092cdd936 --- /dev/null +++ b/js/src/jit-test/tests/self-test/getBacktrace-bug1138195.js @@ -0,0 +1,8 @@ + +function f(x) { + for (var i = 0; i < 40; ++i) { + var stack = getBacktrace({args: true}); + (function() { g = x;}); + } +} +f(1); diff --git a/js/src/jit-test/tests/self-test/inIon.js b/js/src/jit-test/tests/self-test/inIon.js new file mode 100644 index 000000000..40d1c03af --- /dev/null +++ b/js/src/jit-test/tests/self-test/inIon.js @@ -0,0 +1,20 @@ +// Test that inIon eventually becomes truthy. +// This code should never timeout. + +function callInIon() { + return inIon(); +}; + +function test() { + // Test with OSR. + while(!inIon()); + + // Test with inlining. + while(!callInIon()); + + // Test with zealous gc preventing compilation. + while(!inIon()) gc(); +}; + +test(); + diff --git a/js/src/jit-test/tests/self-test/inJit.js b/js/src/jit-test/tests/self-test/inJit.js new file mode 100644 index 000000000..dd218b516 --- /dev/null +++ b/js/src/jit-test/tests/self-test/inJit.js @@ -0,0 +1,20 @@ +// Test that inJit eventually becomes truthy. +// This code should never timeout. + +function callInJit() { + return inJit(); +}; + +function test() { + // Test with OSR. + while(!inJit()); + + // Test with inlining. + while(!callInJit()); + + // Test with zealous gc preventing compilation. + while(!inJit()) gc(); +}; + +test(); + diff --git a/js/src/jit-test/tests/self-test/isRelazifiableFunction-0.js b/js/src/jit-test/tests/self-test/isRelazifiableFunction-0.js new file mode 100644 index 000000000..a75246668 --- /dev/null +++ b/js/src/jit-test/tests/self-test/isRelazifiableFunction-0.js @@ -0,0 +1,3 @@ +// |jit-test| error: Error: The first argument should be a function. + +isRelazifiableFunction(new Array()); diff --git a/js/src/jit-test/tests/self-test/notInIon.js b/js/src/jit-test/tests/self-test/notInIon.js new file mode 100644 index 000000000..f3da1836e --- /dev/null +++ b/js/src/jit-test/tests/self-test/notInIon.js @@ -0,0 +1,3 @@ +// |jit-test| --no-ion + +assertEq(inIon(), "Ion is disabled."); diff --git a/js/src/jit-test/tests/self-test/notInJit.js b/js/src/jit-test/tests/self-test/notInJit.js new file mode 100644 index 000000000..4bb3469e4 --- /dev/null +++ b/js/src/jit-test/tests/self-test/notInJit.js @@ -0,0 +1,4 @@ +// |jit-test| --no-baseline + +assertEq(inJit(), "Baseline is disabled."); +assertEq(inIon(), "Ion is disabled."); diff --git a/js/src/jit-test/tests/self-test/readlineBuf.js b/js/src/jit-test/tests/self-test/readlineBuf.js new file mode 100644 index 000000000..952b1e545 --- /dev/null +++ b/js/src/jit-test/tests/self-test/readlineBuf.js @@ -0,0 +1,40 @@ +load(libdir + "asserts.js"); + +assertThrowsInstanceOf(function () { readlineBuf() }, Error); + +var testBuffers = [ + "foo\nbar\nbaz\n", + "foo\nbar\nbaz", + "foo\n\nbar\nbaz", + "f", + "\n", + "\nf", + "" +]; + +var expected = [ + [ "foo", "bar", "baz" ], + [ "foo", "bar", "baz" ], + [ "foo", "", "bar", "baz" ], + [ "f" ], + [ "" ], + [ "", "f" ], + [] +]; + +for (var idx in testBuffers) { + readlineBuf(testBuffers[idx]); + var result = []; + + while ((line = readlineBuf()) != null) { + result.push(line); + } + + assertDeepEq(result, expected[idx]); +} + +readlineBuf(testBuffers[0]); +readlineBuf(); +readlineBuf(); +readlineBuf(testBuffers[3]); +assertEq(readlineBuf(), expected[3][0]); -- cgit v1.2.3