diff options
Diffstat (limited to 'deps/v8/test/mjsunit')
208 files changed, 15321 insertions, 1135 deletions
diff --git a/deps/v8/test/mjsunit/array-functions-prototype-misc.js b/deps/v8/test/mjsunit/array-functions-prototype-misc.js index 7ff5d4f2f5..dd95e2d266 100644 --- a/deps/v8/test/mjsunit/array-functions-prototype-misc.js +++ b/deps/v8/test/mjsunit/array-functions-prototype-misc.js @@ -31,13 +31,8 @@ * should work on other objects too, so we test that too. */ -var LARGE = 400000; -var VERYLARGE = 4000000000; - -// Nicer for firefox 1.5. Unless you uncomment the following two lines, -// smjs will appear to hang on this file. -//var LARGE = 40000; -//var VERYLARGE = 40000; +var LARGE = 40000; +var VERYLARGE = 40000; var fourhundredth = LARGE/400; @@ -45,7 +40,7 @@ function PseudoArray() { }; for (var use_real_arrays = 0; use_real_arrays <= 1; use_real_arrays++) { - var poses = [0, 140, 20000, VERYLARGE]; + var poses = [0, 140, 20000]; var the_prototype; var new_function; var push_function; @@ -252,19 +247,22 @@ for (var use_real_arrays = 0; use_real_arrays <= 1; use_real_arrays++) { assertEquals("bar", a[2]); // Shift. - var baz = shift_function(a); - assertEquals("baz", baz); - assertEquals("boo", a[0]); - assertEquals(pos + 3, a.length); - assertEquals("foo", a[pos + 2]); - - // Slice. - var bar = slice_function(a, 1, 0); // don't throw an exception please. - bar = slice_function(a, 1, 2); - assertEquals("bar", bar[0]); - assertEquals(1, bar.length); - assertEquals("bar", a[1]); - + // Skip VERYLARGE arrays, as we removed sparse support for shift. + // Slice is also skipped, since it relies on the "shift" test to be run. + if (pos < VERYLARGE) { + var baz = shift_function(a); + assertEquals("baz", baz); + assertEquals("boo", a[0]); + assertEquals(pos + 3, a.length); + assertEquals("foo", a[pos + 2]); + + // Slice. + var bar = slice_function(a, 1, 0); // don't throw an exception please. + bar = slice_function(a, 1, 2); + assertEquals("bar", bar[0]); + assertEquals(1, bar.length); + assertEquals("bar", a[1]); + } } } diff --git a/deps/v8/test/mjsunit/array-splice.js b/deps/v8/test/mjsunit/array-splice.js index 75ff2d174b..460172edd7 100644 --- a/deps/v8/test/mjsunit/array-splice.js +++ b/deps/v8/test/mjsunit/array-splice.js @@ -445,3 +445,21 @@ "array.hasOwnProperty(Math.pow(2, 32) - 2)"); } })(); + +// Verify that fast implementations aren't confused by empty DOUBLE element arrays +(function() { + + function foo(dontAddAnything) { + let a = []; + if (dontAddAnything === undefined) { + a[1] = 0.5; + } + return a.splice(0, 0, 3.5); + } + + // Learn via allocation site tracking to create double arrays in foo(). + foo(); + foo(); + // force splice to copy the input array. + foo(true); +})(); diff --git a/deps/v8/test/mjsunit/array-unshift.js b/deps/v8/test/mjsunit/array-unshift.js index 50aab4f52a..cbc8d4091d 100644 --- a/deps/v8/test/mjsunit/array-unshift.js +++ b/deps/v8/test/mjsunit/array-unshift.js @@ -190,15 +190,12 @@ (function() { for (var i = 0; i < 7; i++) { try { - new Array(Math.pow(2, 32) - 3).unshift(1, 2, 3, 4, 5); - throw 'Should have thrown RangeError'; + let obj = { length: 2 ** 53 - 3}; + Array.prototype.unshift.call(obj, 1, 2, 3, 4, 5); + throw 'Should have thrown TypeError'; } catch (e) { - assertTrue(e instanceof RangeError); + assertTrue(e instanceof TypeError); } - - // Check smi boundary - var bigNum = (1 << 30) - 3; - assertEquals(bigNum + 7, new Array(bigNum).unshift(1, 2, 3, 4, 5, 6, 7)); } })(); diff --git a/deps/v8/test/mjsunit/async-stack-traces-prepare-stacktrace-1.js b/deps/v8/test/mjsunit/async-stack-traces-prepare-stacktrace-1.js new file mode 100644 index 0000000000..42482595cc --- /dev/null +++ b/deps/v8/test/mjsunit/async-stack-traces-prepare-stacktrace-1.js @@ -0,0 +1,31 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --async-stack-traces + +// Check that Error.prepareStackTrace doesn't expose strict +// mode closures, even in the presence of async frames. +Error.prepareStackTrace = (e, frames) => { + assertEquals(two, frames[0].getFunction()); + assertEquals(two.name, frames[0].getFunctionName()); + assertEquals(undefined, frames[1].getFunction()); + assertEquals(one.name, frames[1].getFunctionName()); + return frames; +}; + +async function one(x) { + "use strict"; + return await two(x); +} + +async function two(x) { + try { + x = await x; + throw new Error(); + } catch (e) { + return e.stack; + } +} + +one(1).catch(e => setTimeout(_ => {throw e}, 0)); diff --git a/deps/v8/test/mjsunit/async-stack-traces-prepare-stacktrace-2.js b/deps/v8/test/mjsunit/async-stack-traces-prepare-stacktrace-2.js new file mode 100644 index 0000000000..8126a83dc9 --- /dev/null +++ b/deps/v8/test/mjsunit/async-stack-traces-prepare-stacktrace-2.js @@ -0,0 +1,31 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --async-stack-traces + +// Check that Error.prepareStackTrace doesn't expose strict +// mode closures, even in the presence of async frames. +Error.prepareStackTrace = (e, frames) => { + assertEquals(undefined, frames[0].getFunction()); + assertEquals(two.name, frames[0].getFunctionName()); + assertEquals(undefined, frames[1].getFunction()); + assertEquals(one.name, frames[1].getFunctionName()); + return frames; +}; + +async function one(x) { + return await two(x); +} + +async function two(x) { + "use strict"; + try { + x = await x; + throw new Error(); + } catch (e) { + return e.stack; + } +} + +one(1).catch(e => setTimeout(_ => {throw e}, 0)); diff --git a/deps/v8/test/mjsunit/async-stack-traces-prepare-stacktrace-3.js b/deps/v8/test/mjsunit/async-stack-traces-prepare-stacktrace-3.js new file mode 100644 index 0000000000..429b0f64c3 --- /dev/null +++ b/deps/v8/test/mjsunit/async-stack-traces-prepare-stacktrace-3.js @@ -0,0 +1,31 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --async-stack-traces + +// Check that Error.prepareStackTrace properly marks async frames. +Error.prepareStackTrace = (e, frames) => { + assertEquals(two, frames[0].getFunction()); + assertEquals(two.name, frames[0].getFunctionName()); + assertFalse(frames[0].isAsync()); + assertEquals(two, frames[1].getFunction()); + assertEquals(one.name, frames[1].getFunctionName()); + assertTrue(frames[1].isAsync()); + return frames; +}; + +async function one(x) { + return await two(x); +} + +async function two(x) { + try { + x = await x; + throw new Error(); + } catch (e) { + return e.stack; + } +} + +one(1).catch(e => setTimeout(_ => {throw e}, 0)); diff --git a/deps/v8/test/mjsunit/async-stack-traces.js b/deps/v8/test/mjsunit/async-stack-traces.js new file mode 100644 index 0000000000..05cf8a095f --- /dev/null +++ b/deps/v8/test/mjsunit/async-stack-traces.js @@ -0,0 +1,270 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --async-stack-traces + +// Basic test with an explicit throw. +(function() { + async function one(x) { + await two(x); + } + + async function two(x) { + await x; + throw new Error(); + } + + async function test(f) { + try { + await f(1); + assertUnreachable(); + } catch (e) { + assertInstanceof(e, Error); + assertMatches(/Error.+at two.+at async one.+at async test/ms, e.stack); + } + } + + assertPromiseResult((async () => { + await test(one); + await test(one); + %OptimizeFunctionOnNextCall(two); + await test(one); + %OptimizeFunctionOnNextCall(one); + await test(one); + })()); +})(); + +// Basic test with an implicit throw (via ToNumber on Symbol). +(function() { + async function one(x) { + return await two(x); + } + + async function two(x) { + await x; + return +x; // This will raise a TypeError. + } + + async function test(f) { + try { + await f(Symbol()); + assertUnreachable(); + } catch (e) { + assertInstanceof(e, TypeError); + assertMatches(/TypeError.+at two.+at async one.+at async test/ms, e.stack); + } + } + + assertPromiseResult((async() => { + await test(one); + await test(one); + %OptimizeFunctionOnNextCall(two); + await test(one); + %OptimizeFunctionOnNextCall(one); + await test(one); + })()); +})(); + +// Basic test with throw in inlined function. +(function() { + function throwError() { + throw new Error(); + } + + async function one(x) { + return await two(x); + } + + async function two(x) { + await x; + return throwError(); + } + + async function test(f) { + try { + await f(1); + assertUnreachable(); + } catch (e) { + assertInstanceof(e, Error); + assertMatches(/Error.+at two.+at async one.+at async test/ms, e.stack); + } + } + + assertPromiseResult((async() => { + await test(one); + await test(one); + %OptimizeFunctionOnNextCall(two); + await test(one); + %OptimizeFunctionOnNextCall(one); + await test(one); + })()); +})(); + +// Basic test with async function inlined into sync function. +(function() { + function callOne(x) { + return one(x); + } + + function callTwo(x) { + return two(x); + } + + async function one(x) { + return await callTwo(x); + } + + async function two(x) { + await x; + throw new Error(); + } + + async function test(f) { + try { + await f(1); + assertUnreachable(); + } catch (e) { + assertInstanceof(e, Error); + assertMatches(/Error.+at two.+at async one.+at async test/ms, e.stack); + } + } + + assertPromiseResult((async() => { + await test(callOne); + await test(callOne); + %OptimizeFunctionOnNextCall(callTwo); + await test(callOne); + %OptimizeFunctionOnNextCall(callOne); + await test(callOne); + })()); +})(); + +// Basic test with async functions and promises chained via +// Promise.prototype.then(), which should still work following +// the generic chain upwards. +(function() { + async function one(x) { + return await two(x).then(x => x); + } + + async function two(x) { + await x.then(x => x); + throw new Error(); + } + + async function test(f) { + try { + await f(Promise.resolve(1)); + assertUnreachable(); + } catch (e) { + assertInstanceof(e, Error); + assertMatches(/Error.+at two.+at async one.+at async test/ms, e.stack); + } + } + + assertPromiseResult((async() => { + await test(one); + await test(one); + %OptimizeFunctionOnNextCall(two); + await test(one); + %OptimizeFunctionOnNextCall(one); + await test(one); + })()); +})(); + +// Basic test for async generators called from async +// functions with an explicit throw. +(function() { + async function one(x) { + for await (const y of two(x)) {} + } + + async function* two(x) { + await x; + throw new Error(); + } + + async function test(f) { + try { + await f(1); + assertUnreachable(); + } catch (e) { + assertInstanceof(e, Error); + assertMatches(/Error.+at two.+at async one.+at async test/ms, e.stack); + } + } + + assertPromiseResult((async () => { + await test(one); + await test(one); + %OptimizeFunctionOnNextCall(two); + await test(one); + %OptimizeFunctionOnNextCall(one); + await test(one); + })()); +})(); + +// Basic test for async functions called from async +// generators with an explicit throw. +(function() { + async function* one(x) { + await two(x); + } + + async function two(x) { + await x; + throw new Error(); + } + + async function test(f) { + try { + for await (const x of f(1)) {} + assertUnreachable(); + } catch (e) { + assertInstanceof(e, Error); + assertMatches(/Error.+at two.+at async one.+at async test/ms, e.stack); + } + } + + assertPromiseResult((async () => { + await test(one); + await test(one); + %OptimizeFunctionOnNextCall(two); + await test(one); + %OptimizeFunctionOnNextCall(one); + await test(one); + })()); +})(); + +// Basic test for async functions called from async +// generators with an explicit throw (with yield). +(function() { + async function* one(x) { + yield two(x); + } + + async function two(x) { + await x; + throw new Error(); + } + + async function test(f) { + try { + for await (const x of f(1)) {} + assertUnreachable(); + } catch (e) { + assertInstanceof(e, Error); + assertMatches(/Error.+at two.+at async one.+at async test/ms, e.stack); + } + } + + assertPromiseResult((async () => { + await test(one); + await test(one); + %OptimizeFunctionOnNextCall(two); + await test(one); + %OptimizeFunctionOnNextCall(one); + await test(one); + })()); +})(); diff --git a/deps/v8/test/mjsunit/code-coverage-block.js b/deps/v8/test/mjsunit/code-coverage-block.js index 8cbb2969f7..61ed87fc13 100644 --- a/deps/v8/test/mjsunit/code-coverage-block.js +++ b/deps/v8/test/mjsunit/code-coverage-block.js @@ -471,7 +471,7 @@ TestCoverage( {"start":472,"end":503,"count":0}, {"start":626,"end":653,"count":0}, {"start":768,"end":803,"count":0}, - {"start":867,"end":869,"count":0}] + {"start":867,"end":868,"count":0}] ); TestCoverage( @@ -850,46 +850,4 @@ Util.escape("foo.bar"); // 0400 {"start":268,"end":350,"count":0}] ); -TestCoverage( -"https://crbug.com/v8/8237", -` -!function() { // 0000 - if (true) // 0050 - while (false) return; else nop(); // 0100 -}(); // 0150 -!function() { // 0200 - if (true) l0: { break l0; } else // 0250 - if (nop()) { } // 0300 -}(); // 0350 -!function() { // 0400 - if (true) { if (false) { return; } // 0450 - } else if (nop()) { } }(); // 0500 -!function(){ // 0550 - if(true)while(false)return;else nop() // 0600 -}(); // 0650 -!function(){ // 0700 - if(true) l0:{break l0}else if (nop()){} // 0750 -}(); // 0800 -!function(){ // 0850 - if(true){if(false){return}}else // 0900 - if(nop()){} // 0950 -}(); // 1000 -`, -[{"start":0,"end":1049,"count":1}, - {"start":1,"end":151,"count":1}, - {"start":118,"end":137,"count":0}, - {"start":201,"end":351,"count":1}, - {"start":277,"end":318,"count":0}, - {"start":401,"end":525,"count":1}, - {"start":475,"end":486,"count":0}, - {"start":503,"end":523,"count":0}, - {"start":551,"end":651,"count":1}, - {"start":622,"end":639,"count":0}, - {"start":701,"end":801,"count":1}, - {"start":773,"end":791,"count":0}, - {"start":851,"end":1001,"count":1}, - {"start":920,"end":928,"count":0}, - {"start":929,"end":965,"count":0}] -); - %DebugToggleBlockCoverage(false); diff --git a/deps/v8/test/mjsunit/code-coverage-class-fields.js b/deps/v8/test/mjsunit/code-coverage-class-fields.js new file mode 100644 index 0000000000..a91c25824f --- /dev/null +++ b/deps/v8/test/mjsunit/code-coverage-class-fields.js @@ -0,0 +1,199 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --no-always-opt --harmony-public-fields --harmony-static-fields +// Files: test/mjsunit/code-coverage-utils.js + +%DebugToggleBlockCoverage(true); + +TestCoverage( +"class with no fields", +`class X { // 000 +}; // 050 +`, + [ + { start: 0, end: 98, count: 1 }, + { start: 0, end: 0, count: 0 }, + ] +); + +TestCoverage( +"class that's not created", +`class X { // 000 + x = function() { } // 050 +}; // 100 +`, + [ + { start: 0, end: 148, count: 1 }, + { start: 0, end: 0, count: 0 }, + { start: 51, end: 69, count: 0 }, + ] +); + +TestCoverage( +"class with field thats not called", +`class X { // 000 + x = function() { } // 050 +}; // 100 +let x = new X(); // 150 +`, + [ + { start: 0, end: 198, count: 1 }, + { start: 0, end: 0, count: 1 }, + { start: 51, end: 69, count: 1 }, + { start: 55, end: 69, count: 0 } + ] +); + +TestCoverage( +"class field", +`class X { // 000 + x = function() { } // 050 +}; // 100 +let x = new X(); // 150 +x.x(); // 200 +`, + [ + { start: 0, end: 248, count: 1 }, + { start: 0, end: 0, count: 1 }, + { start: 51, end: 69, count: 1 }, + { start: 55, end: 69, count: 1 } + ] +); + +TestCoverage( +"non contiguous class field", +`class X { // 000 + x = function() { } // 050 + foo() { } // 100 + y = function() {} // 150 +}; // 200 +let x = new X(); // 250 +x.x(); // 300 +x.y(); // 350 +`, + [ + { start: 0, end: 398, count: 1 }, + { start: 0, end: 0, count: 1 }, + { start: 51, end: 168, count: 1 }, + { start: 55, end: 69, count: 1 }, + { start: 101, end: 110, count: 0 }, + { start: 155, end: 168, count: 1 }, + ] +); + +TestCoverage( +"non contiguous class field thats called", +`class X { // 000 + x = function() { } // 050 + foo() { } // 100 + y = function() {} // 150 +}; // 200 +let x = new X(); // 250 +x.x(); // 300 +x.y(); // 350 +x.foo(); // 400 +`, + [ + { start: 0, end: 448, count: 1 }, + { start: 0, end: 0, count: 1 }, + { start: 51, end: 168, count: 1 }, + { start: 55, end: 69, count: 1 }, + { start: 101, end: 110, count: 1 }, + { start: 155, end: 168, count: 1 }, + ] +); + +TestCoverage( +"class with initializer iife", +`class X { // 000 + x = (function() { })() // 050 +}; // 100 +let x = new X(); // 150 +`, + [ + { start: 0, end: 198, count: 1 }, + { start: 0, end: 0, count: 1 }, + { start: 51, end: 73, count: 1 }, + { start: 56, end: 70, count: 1 } + ] +); + +TestCoverage( +"class with computed field", +` +function f() {}; // 000 +class X { // 050 + [f()] = (function() { })() // 100 +}; // 150 +let x = new X(); // 200 +`, + [ + { start: 0, end: 249, count: 1 }, + { start: 0, end: 15, count: 1 }, + { start: 50, end: 50, count: 1 }, + { start: 102, end: 128, count: 1 }, + { start: 111, end: 125, count: 1 } + ] +); + +TestCoverage( +"static class field that's not called", +`class X { // 000 + static x = function() { } // 050 +}; // 100 +`, + [ + { start: 0, end: 148, count: 1 }, + { start: 0, end: 0, count: 0 }, + { start: 51, end: 76, count: 1 }, + { start: 62, end: 76, count: 0 } + ] +); + +TestCoverage( +"static class field", +`class X { // 000 + static x = function() { } // 050 +}; // 100 +X.x(); // 150 +`, + [ + { start: 0, end: 198, count: 1 }, + { start: 0, end: 0, count: 0 }, + { start: 51, end: 76, count: 1 }, + { start: 62, end: 76, count: 1 } + ] +); + +TestCoverage( +"static class field with iife", +`class X { // 000 + static x = (function() { })() // 050 +}; // 100 +`, + [ + { start: 0, end: 148, count: 1 }, + { start: 0, end: 0, count: 0 }, + { start: 51, end: 80, count: 1 }, + { start: 63, end: 77, count: 1 } + ] +); + +TestCoverage( +"computed static class field", +` +function f() {} // 000 +class X { // 050 + static [f()] = (function() { })() // 100 +}; // 150 +`, + [ + { start: 0, end: 199, count: 1 }, + { start: 0, end: 15, count: 1 }, + { start: 50, end: 50, count: 0 }, + { start: 102, end: 135, count: 1 }, + { start: 118, end: 132, count: 1 } + ] +); diff --git a/deps/v8/test/mjsunit/compiler/abstract-equal-symbol.js b/deps/v8/test/mjsunit/compiler/abstract-equal-symbol.js new file mode 100644 index 0000000000..c1057e1d1b --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/abstract-equal-symbol.js @@ -0,0 +1,135 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt --noalways-opt + +// Known symbols abstract equality. +(function() { + const a = Symbol("a"); + const b = Symbol("b"); + + function foo() { return a == b; } + + assertFalse(foo()); + assertFalse(foo()); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo()); +})(); + +// Known symbols abstract in-equality. +(function() { + const a = Symbol("a"); + const b = Symbol("b"); + + function foo() { return a != b; } + + assertTrue(foo()); + assertTrue(foo()); + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo()); +})(); + +// Known symbol on one side abstract equality. +(function() { + const a = Symbol("a"); + const b = Symbol("b"); + + function foo(a) { return a == b; } + + // Warmup + assertTrue(foo(b)); + assertFalse(foo(a)); + assertTrue(foo(b)); + assertFalse(foo(a)); + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo(b)); + assertFalse(foo(a)); + assertOptimized(foo); + + // Make optimized code bail out + assertFalse(foo("a")); + assertUnoptimized(foo); + + // Make sure TurboFan learns the new feedback + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo("a")); + assertOptimized(foo); +})(); + +// Known symbol on one side abstract in-equality. +(function() { + const a = Symbol("a"); + const b = Symbol("b"); + + function foo(a) { return a != b; } + + // Warmup + assertFalse(foo(b)); + assertTrue(foo(a)); + assertFalse(foo(b)); + assertTrue(foo(a)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(b)); + assertTrue(foo(a)); + + // Make optimized code bail out + assertTrue(foo("a")); + assertUnoptimized(foo); + + // Make sure TurboFan learns the new feedback + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo("a")); + assertOptimized(foo); +})(); + +// Feedback based symbol abstract equality. +(function() { + const a = Symbol("a"); + const b = Symbol("b"); + + function foo(a, b) { return a == b; } + + // Warmup + assertTrue(foo(b, b)); + assertFalse(foo(a, b)); + assertTrue(foo(a, a)); + assertFalse(foo(b, a)); + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo(a, a)); + assertFalse(foo(b, a)); + + // Make optimized code bail out + assertFalse(foo("a", b)); + assertUnoptimized(foo); + + // Make sure TurboFan learns the new feedback + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo("a", b)); + assertOptimized(foo); +})(); + +// Feedback based symbol abstract in-equality. +(function() { + const a = Symbol("a"); + const b = Symbol("b"); + + function foo(a, b) { return a != b; } + + assertFalse(foo(b, b)); + assertTrue(foo(a, b)); + assertFalse(foo(a, a)); + assertTrue(foo(b, a)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(a, a)); + assertTrue(foo(b, a)); + + // Make optimized code bail out + assertTrue(foo("a", b)); + assertUnoptimized(foo); + + // Make sure TurboFan learns the new feedback + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo("a", b)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/array-buffer-is-view.js b/deps/v8/test/mjsunit/compiler/array-buffer-is-view.js new file mode 100644 index 0000000000..b56763b5b2 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/array-buffer-is-view.js @@ -0,0 +1,64 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test that ObjectIsArrayBufferView lowering works correctly +// in EffectControlLinearizer in the case that the input is +// known to be a HeapObject by TurboFan. For this we use the +// simple trick with an object literal whose field `x` will +// only ever contain HeapObjects and so the representation +// tracking is going to pick it up. +(function() { + function foo(x) { + return ArrayBuffer.isView({x}.x); + } + + assertFalse(foo(Symbol())); + assertFalse(foo("some string")); + assertFalse(foo(new Object())); + assertFalse(foo(new Array())); + assertFalse(foo(new ArrayBuffer(1))); + assertTrue(foo(new Int32Array(1))); + assertTrue(foo(new DataView(new ArrayBuffer(1)))); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(Symbol())); + assertFalse(foo("some string")); + assertFalse(foo(new Object())); + assertFalse(foo(new Array())); + assertFalse(foo(new ArrayBuffer(1))); + assertTrue(foo(new Int32Array(1))); + assertTrue(foo(new DataView(new ArrayBuffer(1)))); + assertOptimized(foo); +})(); + +// Test that ObjectIsArrayBufferView lowering works correctly +// in EffectControlLinearizer in the case that the input is +// some arbitrary tagged value. +(function() { + function foo(x) { + return ArrayBuffer.isView(x); + } + + assertFalse(foo(1)); + assertFalse(foo(1.1)); + assertFalse(foo(Symbol())); + assertFalse(foo("some string")); + assertFalse(foo(new Object())); + assertFalse(foo(new Array())); + assertFalse(foo(new ArrayBuffer(1))); + assertTrue(foo(new Int32Array(1))); + assertTrue(foo(new DataView(new ArrayBuffer(1)))); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(1)); + assertFalse(foo(1.1)); + assertFalse(foo(Symbol())); + assertFalse(foo("some string")); + assertFalse(foo(new Object())); + assertFalse(foo(new Array())); + assertFalse(foo(new ArrayBuffer(1))); + assertTrue(foo(new Int32Array(1))); + assertTrue(foo(new DataView(new ArrayBuffer(1)))); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/array-is-array.js b/deps/v8/test/mjsunit/compiler/array-is-array.js new file mode 100644 index 0000000000..37c916ddac --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/array-is-array.js @@ -0,0 +1,105 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Test JSObjectIsArray in JSTypedLowering for the case that the +// input value is known to be an Array literal. +(function() { + function foo() { + return Array.isArray([]); + } + + assertTrue(foo()); + assertTrue(foo()); + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo()); +})(); + +// Test JSObjectIsArray in JSTypedLowering for the case that the +// input value is known to be a Proxy for an Array literal. +(function() { + function foo() { + return Array.isArray(new Proxy([], {})); + } + + assertTrue(foo()); + assertTrue(foo()); + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo()); +})(); + +// Test JSObjectIsArray in JSTypedLowering for the case that the +// input value is known to be an Object literal. +(function() { + function foo() { + return Array.isArray({}); + } + + assertFalse(foo()); + assertFalse(foo()); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo()); +})(); + +// Test JSObjectIsArray in JSTypedLowering for the case that the +// input value is known to be a Proxy for an Object literal. +(function() { + function foo() { + return Array.isArray(new Proxy({}, {})); + } + + assertFalse(foo()); + assertFalse(foo()); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo()); +})(); + +// Test JSObjectIsArray in JSTypedLowering for the case that +// TurboFan doesn't know anything about the input value. +(function() { + function foo(x) { + return Array.isArray(x); + } + + assertFalse(foo({})); + assertFalse(foo(new Proxy({}, {}))); + assertTrue(foo([])); + assertTrue(foo(new Proxy([], {}))); + assertThrows(() => { + const {proxy, revoke} = Proxy.revocable([], {}); + revoke(); + foo(proxy); + }, TypeError); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo({})); + assertFalse(foo(new Proxy({}, {}))); + assertTrue(foo([])); + assertTrue(foo(new Proxy([], {}))); + assertThrows(() => { + const {proxy, revoke} = Proxy.revocable([], {}); + revoke(); + foo(proxy); + }, TypeError); +})(); + +// Test JSObjectIsArray in JSTypedLowering for the case that +// we pass a revoked proxy and catch the exception locally. +(function() { + function foo(x) { + const {proxy, revoke} = Proxy.revocable(x, {}); + revoke(); + try { + return Array.isArray(proxy); + } catch (e) { + return e; + } + } + + assertInstanceof(foo([]), TypeError); + assertInstanceof(foo({}), TypeError); + %OptimizeFunctionOnNextCall(foo); + assertInstanceof(foo([]), TypeError); + assertInstanceof(foo({}), TypeError); +})(); diff --git a/deps/v8/test/mjsunit/compiler/context-sensitivity.js b/deps/v8/test/mjsunit/compiler/context-sensitivity.js new file mode 100644 index 0000000000..1f0f1f274a --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/context-sensitivity.js @@ -0,0 +1,550 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +const object1 = {[Symbol.toPrimitive]() { return 1; }}; +const thrower = {[Symbol.toPrimitive]() { throw new Error(); }}; + +// Test that JSAdd is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y + x); + } + + assertEquals(1, foo(0)); + assertEquals(2, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(0)); + assertEquals(2, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSSubtract is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y - x); + } + + assertEquals(1, foo(0)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(0)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSMultiply is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y * x); + } + + assertEquals(1, foo(1)); + assertEquals(1, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1)); + assertEquals(1, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSDivide is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y / x); + } + + assertEquals(1, foo(1)); + assertEquals(1, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1)); + assertEquals(1, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSModulus is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y % x); + } + + assertEquals(0, foo(1)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSExponentiate is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y ** x); + } + + assertEquals(1, foo(1)); + assertEquals(1, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1)); + assertEquals(1, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSBitwiseOr is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y | x); + } + + assertEquals(1, foo(1)); + assertEquals(1, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1)); + assertEquals(1, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSBitwiseAnd is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y & x); + } + + assertEquals(1, foo(1)); + assertEquals(1, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1)); + assertEquals(1, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSBitwiseXor is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y ^ x); + } + + assertEquals(0, foo(1)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSShiftLeft is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y << x); + } + + assertEquals(2, foo(1)); + assertEquals(2, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(1)); + assertEquals(2, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSShiftRight is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y >> x); + } + + assertEquals(0, foo(1)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSShiftRightLogical is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y >>> x); + } + + assertEquals(0, foo(1)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSEqual is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y == x); + } + + assertFalse(foo(0)); + assertTrue(foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(0)); + assertTrue(foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSLessThan is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y < x); + } + + assertFalse(foo(0)); + assertFalse(foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(0)); + assertFalse(foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSGreaterThan is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => x > y); + } + + assertFalse(foo(0)); + assertFalse(foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(0)); + assertFalse(foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSLessThanOrEqual is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => y <= x); + } + + assertFalse(foo(0)); + assertTrue(foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(0)); + assertTrue(foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSGreaterThanOrEqual is not context-sensitive. +(function() { + function bar(fn) { + return fn(1); + } + + function foo(x) { + return bar(y => x >= y); + } + + assertFalse(foo(0)); + assertTrue(foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(0)); + assertTrue(foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSInstanceOf is not context-sensitive. +(function() { + function bar(fn) { + return fn({}); + } + + function foo(c) { + return bar(o => o instanceof c); + } + + assertTrue(foo(Object)); + assertFalse(foo(Array)); + assertThrows(() => foo({[Symbol.hasInstance]() { throw new Error(); }})); + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo(Object)); + assertFalse(foo(Array)); + assertThrows(() => foo({[Symbol.hasInstance]() { throw new Error(); }})); +})(); + +// Test that JSBitwiseNot is not context-sensitive. +(function() { + function bar(fn) { + return fn(); + } + + function foo(x) { + return bar(() => ~x); + } + + assertEquals(0, foo(-1)); + assertEquals(~1, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(-1)); + assertEquals(~1, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSNegate is not context-sensitive. +(function() { + function bar(fn) { + return fn(); + } + + function foo(x) { + return bar(() => -x); + } + + assertEquals(1, foo(-1)); + assertEquals(-1, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(-1)); + assertEquals(-1, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSIncrement is not context-sensitive. +(function() { + function bar(fn) { + return fn(); + } + + function foo(x) { + return bar(() => ++x); + } + + assertEquals(1, foo(0)); + assertEquals(2, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(0)); + assertEquals(2, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSDecrement is not context-sensitive. +(function() { + function bar(fn) { + return fn(); + } + + function foo(x) { + return bar(() => --x); + } + + assertEquals(1, foo(2)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(2)); + assertEquals(0, foo(object1)); + assertThrows(() => foo(thrower)); +})(); + +// Test that JSCreateArguments[UnmappedArguments] is not context-sensitive. +(function() { + function bar(fn) { + return fn(); + } + + function foo() { + "use strict"; + return bar(() => arguments)[0]; + } + + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 2)); + assertEquals(undefined, foo()); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 2)); + assertEquals(undefined, foo()); +})(); + +// Test that JSCreateArguments[RestParameters] is not context-sensitive. +(function() { + function bar(fn) { + return fn(); + } + + function foo(...args) { + return bar(() => args)[0]; + } + + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 2)); + assertEquals(undefined, foo()); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 2)); + assertEquals(undefined, foo()); +})(); + +// Test that JSLoadGlobal/JSStoreGlobal are not context-sensitive. +(function(global) { + var actualValue = 'Some value'; + + Object.defineProperty(global, 'globalValue', { + configurable: true, + enumerable: true, + get: function() { + return actualValue; + }, + set: function(v) { + actualValue = v; + } + }); + + function bar(fn) { + return fn(); + } + + function foo(v) { + return bar(() => { + const o = globalValue; + globalValue = v; + return o; + }); + } + + assertEquals('Some value', foo('Another value')); + assertEquals('Another value', actualValue); + assertEquals('Another value', foo('Some value')); + assertEquals('Some value', actualValue); + %OptimizeFunctionOnNextCall(foo); + assertEquals('Some value', foo('Another value')); + assertEquals('Another value', actualValue); + assertEquals('Another value', foo('Some value')); + assertEquals('Some value', actualValue); +})(this); + +// Test that for..in is not context-sensitive. +(function() { + function bar(fn) { + return fn(); + } + + function foo(o) { + return bar(() => { + var s = ""; + for (var k in o) { s += k; } + return s; + }); + } + + assertEquals('abc', foo({a: 1, b: 2, c: 3})); + assertEquals('ab', foo(Object.create({a: 1, b: 2}))); + %OptimizeFunctionOnNextCall(foo); + assertEquals('abc', foo({a: 1, b: 2, c: 3})); + assertEquals("ab", foo(Object.create({a:1, b:2}))); +})(); + +// Test that most generator operations are not context-sensitive. +(function() { + function bar(fn) { + let s = undefined; + for (const x of fn()) { + if (s === undefined) s = x; + else s += x; + } + return s; + } + + function foo(x, y, z) { + return bar(function*() { + yield x; + yield y; + yield z; + }); + } + + assertEquals(6, foo(1, 2, 3)); + assertEquals("abc", foo("a", "b", "c")); + %OptimizeFunctionOnNextCall(foo); + assertEquals(6, foo(1, 2, 3)); + assertEquals("abc", foo("a", "b", "c")); +})(); diff --git a/deps/v8/test/mjsunit/compiler/dataview-constant.js b/deps/v8/test/mjsunit/compiler/dataview-constant.js new file mode 100644 index 0000000000..f5f0b5e955 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/dataview-constant.js @@ -0,0 +1,173 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Test DataView.prototype.getInt8()/setInt8() for constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setInt8(0, 42); + dv.setInt8(1, 24); + + function foo(i) { + const x = dv.getInt8(i); + dv.setInt8(i, x+1); + return x; + } + + assertEquals(42, foo(0)); + assertEquals(24, foo(1)); + assertEquals(43, foo(0)); + assertEquals(25, foo(1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(0)); + assertEquals(26, foo(1)); +})(); + +// Test DataView.prototype.getUint8()/setUint8() for constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setUint8(0, 42); + dv.setUint8(1, 24); + + function foo(i) { + const x = dv.getUint8(i); + dv.setUint8(i, x+1); + return x; + } + + assertEquals(42, foo(0)); + assertEquals(24, foo(1)); + assertEquals(43, foo(0)); + assertEquals(25, foo(1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(0)); + assertEquals(26, foo(1)); +})(); + +// Test DataView.prototype.getInt16()/setInt16() for constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setInt16(0, 42, true); + dv.setInt16(2, 24, true); + + function foo(i) { + const x = dv.getInt16(i, true); + dv.setInt16(i, x+1, true); + return x; + } + + assertEquals(42, foo(0)); + assertEquals(24, foo(2)); + assertEquals(43, foo(0)); + assertEquals(25, foo(2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(0)); + assertEquals(26, foo(2)); +})(); + +// Test DataView.prototype.getUint16()/setUint16() for constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setUint16(0, 42, true); + dv.setUint16(2, 24, true); + + function foo(i) { + const x = dv.getUint16(i, true); + dv.setUint16(i, x+1, true); + return x; + } + + assertEquals(42, foo(0)); + assertEquals(24, foo(2)); + assertEquals(43, foo(0)); + assertEquals(25, foo(2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(0)); + assertEquals(26, foo(2)); +})(); + +// Test DataView.prototype.getInt32()/setInt32() for constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setInt32(0, 42, true); + dv.setInt32(4, 24, true); + + function foo(i) { + const x = dv.getInt32(i, true); + dv.setInt32(i, x+1, true); + return x; + } + + assertEquals(42, foo(0)); + assertEquals(24, foo(4)); + assertEquals(43, foo(0)); + assertEquals(25, foo(4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(0)); + assertEquals(26, foo(4)); +})(); + +// Test DataView.prototype.getUint32()/setUint32() for constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setUint32(0, 42, true); + dv.setUint32(4, 24, true); + + function foo(i) { + const x = dv.getUint32(i, true); + dv.setUint32(i, x+1, true); + return x; + } + + assertEquals(42, foo(0)); + assertEquals(24, foo(4)); + assertEquals(43, foo(0)); + assertEquals(25, foo(4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(0)); + assertEquals(26, foo(4)); +})(); + +// Test DataView.prototype.getFloat32()/setFloat32() for constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setFloat32(0, 42, true); + dv.setFloat32(4, 24, true); + + function foo(i) { + const x = dv.getFloat32(i, true); + dv.setFloat32(i, x+1, true); + return x; + } + + assertEquals(42, foo(0)); + assertEquals(24, foo(4)); + assertEquals(43, foo(0)); + assertEquals(25, foo(4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(0)); + assertEquals(26, foo(4)); +})(); + +// Test DataView.prototype.getFloat64()/setFloat64() for constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setFloat64(0, 42, true); + dv.setFloat64(8, 24, true); + + function foo(i) { + const x = dv.getFloat64(i, true); + dv.setFloat64(i, x+1, true); + return x; + } + + assertEquals(42, foo(0)); + assertEquals(24, foo(8)); + assertEquals(43, foo(0)); + assertEquals(25, foo(8)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(0)); + assertEquals(26, foo(8)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/dataview-neutered.js b/deps/v8/test/mjsunit/compiler/dataview-neutered.js new file mode 100644 index 0000000000..54b35f73c8 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/dataview-neutered.js @@ -0,0 +1,376 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt --noalways-opt + +// Invalidate the neutering protector. +%ArrayBufferNeuter(new ArrayBuffer(1)); + +// Check DataView.prototype.getInt8() optimization. +(function() { + const ab = new ArrayBuffer(1); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getInt8(0); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getUint8() optimization. +(function() { + const ab = new ArrayBuffer(1); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getUint8(0); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getInt16() optimization. +(function() { + const ab = new ArrayBuffer(2); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getInt16(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getUint16() optimization. +(function() { + const ab = new ArrayBuffer(2); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getUint16(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getInt32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getInt32(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getUint32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getUint32(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getFloat32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getFloat32(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getFloat64() optimization. +(function() { + const ab = new ArrayBuffer(8); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getFloat64(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setInt8() optimization. +(function() { + const ab = new ArrayBuffer(1); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setInt8(0, x); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getInt8(0)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getInt8(0)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setUint8() optimization. +(function() { + const ab = new ArrayBuffer(1); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setUint8(0, x); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getUint8(0)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getUint8(0)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setInt16() optimization. +(function() { + const ab = new ArrayBuffer(2); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setInt16(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getInt16(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getInt16(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setUint16() optimization. +(function() { + const ab = new ArrayBuffer(2); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setUint16(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getUint16(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getUint16(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setInt32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setInt32(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getInt32(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getInt32(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setUint32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setUint32(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getUint32(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getUint32(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setFloat32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setFloat32(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getFloat32(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getFloat32(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setFloat64() optimization. +(function() { + const ab = new ArrayBuffer(8); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setFloat64(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getFloat64(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getFloat64(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/dataview-nonconstant.js b/deps/v8/test/mjsunit/compiler/dataview-nonconstant.js new file mode 100644 index 0000000000..0420660c83 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/dataview-nonconstant.js @@ -0,0 +1,173 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Test DataView.prototype.getInt8()/setInt8() for non-constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setInt8(0, 42); + dv.setInt8(1, 24); + + function foo(dv, i) { + const x = dv.getInt8(i); + dv.setInt8(i, x+1); + return x; + } + + assertEquals(42, foo(dv, 0)); + assertEquals(24, foo(dv, 1)); + assertEquals(43, foo(dv, 0)); + assertEquals(25, foo(dv, 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(dv, 0)); + assertEquals(26, foo(dv, 1)); +})(); + +// Test DataView.prototype.getUint8()/setUint8() for non-constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setUint8(0, 42); + dv.setUint8(1, 24); + + function foo(dv, i) { + const x = dv.getUint8(i); + dv.setUint8(i, x+1); + return x; + } + + assertEquals(42, foo(dv, 0)); + assertEquals(24, foo(dv, 1)); + assertEquals(43, foo(dv, 0)); + assertEquals(25, foo(dv, 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(dv, 0)); + assertEquals(26, foo(dv, 1)); +})(); + +// Test DataView.prototype.getInt16()/setInt16() for non-constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setInt16(0, 42, true); + dv.setInt16(2, 24, true); + + function foo(dv, i) { + const x = dv.getInt16(i, true); + dv.setInt16(i, x+1, true); + return x; + } + + assertEquals(42, foo(dv, 0)); + assertEquals(24, foo(dv, 2)); + assertEquals(43, foo(dv, 0)); + assertEquals(25, foo(dv, 2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(dv, 0)); + assertEquals(26, foo(dv, 2)); +})(); + +// Test DataView.prototype.getUint16()/setUint16() for non-constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setUint16(0, 42, true); + dv.setUint16(2, 24, true); + + function foo(dv, i) { + const x = dv.getUint16(i, true); + dv.setUint16(i, x+1, true); + return x; + } + + assertEquals(42, foo(dv, 0)); + assertEquals(24, foo(dv, 2)); + assertEquals(43, foo(dv, 0)); + assertEquals(25, foo(dv, 2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(dv, 0)); + assertEquals(26, foo(dv, 2)); +})(); + +// Test DataView.prototype.getInt32()/setInt32() for non-constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setInt32(0, 42, true); + dv.setInt32(4, 24, true); + + function foo(dv, i) { + const x = dv.getInt32(i, true); + dv.setInt32(i, x+1, true); + return x; + } + + assertEquals(42, foo(dv, 0)); + assertEquals(24, foo(dv, 4)); + assertEquals(43, foo(dv, 0)); + assertEquals(25, foo(dv, 4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(dv, 0)); + assertEquals(26, foo(dv, 4)); +})(); + +// Test DataView.prototype.getUint32()/setUint32() for non-constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setUint32(0, 42, true); + dv.setUint32(4, 24, true); + + function foo(dv, i) { + const x = dv.getUint32(i, true); + dv.setUint32(i, x+1, true); + return x; + } + + assertEquals(42, foo(dv, 0)); + assertEquals(24, foo(dv, 4)); + assertEquals(43, foo(dv, 0)); + assertEquals(25, foo(dv, 4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(dv, 0)); + assertEquals(26, foo(dv, 4)); +})(); + +// Test DataView.prototype.getFloat32()/setFloat32() for non-constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setFloat32(0, 42, true); + dv.setFloat32(4, 24, true); + + function foo(dv, i) { + const x = dv.getFloat32(i, true); + dv.setFloat32(i, x+1, true); + return x; + } + + assertEquals(42, foo(dv, 0)); + assertEquals(24, foo(dv, 4)); + assertEquals(43, foo(dv, 0)); + assertEquals(25, foo(dv, 4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(dv, 0)); + assertEquals(26, foo(dv, 4)); +})(); + +// Test DataView.prototype.getFloat64()/setFloat64() for non-constant DataViews. +(function() { + const dv = new DataView(new ArrayBuffer(1024)); + dv.setFloat64(0, 42, true); + dv.setFloat64(8, 24, true); + + function foo(dv, i) { + const x = dv.getFloat64(i, true); + dv.setFloat64(i, x+1, true); + return x; + } + + assertEquals(42, foo(dv, 0)); + assertEquals(24, foo(dv, 8)); + assertEquals(43, foo(dv, 0)); + assertEquals(25, foo(dv, 8)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(44, foo(dv, 0)); + assertEquals(26, foo(dv, 8)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/escape-analysis-arguments.js b/deps/v8/test/mjsunit/compiler/escape-analysis-arguments.js index f520167e19..65e736c706 100644 --- a/deps/v8/test/mjsunit/compiler/escape-analysis-arguments.js +++ b/deps/v8/test/mjsunit/compiler/escape-analysis-arguments.js @@ -185,3 +185,56 @@ %OptimizeFunctionOnNextCall(f); f(); f(); })(); + +// Test variable index access to strict arguments +// with up to 2 elements. +(function testArgumentsVariableIndexStrict() { + function g() { + "use strict"; + var s = 0; + for (var i = 0; i < arguments.length; ++i) s += arguments[i]; + return s; + } + + function f(x, y) { + // (a) arguments[i] is dead code since arguments.length is 0. + const a = g(); + // (b) arguments[i] always yields the first element. + const b = g(x); + // (c) arguments[i] can yield either x or y. + const c = g(x, y); + return a + b + c; + } + + assertEquals(4, f(1, 2)); + assertEquals(5, f(2, 1)); + %OptimizeFunctionOnNextCall(f); + assertEquals(4, f(1, 2)); + assertEquals(5, f(2, 1)); +})(); + +// Test variable index access to sloppy arguments +// with up to 2 elements. +(function testArgumentsVariableIndexSloppy() { + function g() { + var s = 0; + for (var i = 0; i < arguments.length; ++i) s += arguments[i]; + return s; + } + + function f(x, y) { + // (a) arguments[i] is dead code since arguments.length is 0. + const a = g(); + // (b) arguments[i] always yields the first element. + const b = g(x); + // (c) arguments[i] can yield either x or y. + const c = g(x, y); + return a + b + c; + } + + assertEquals(4, f(1, 2)); + assertEquals(5, f(2, 1)); + %OptimizeFunctionOnNextCall(f); + assertEquals(4, f(1, 2)); + assertEquals(5, f(2, 1)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/escape-analysis-array.js b/deps/v8/test/mjsunit/compiler/escape-analysis-array.js new file mode 100644 index 0000000000..2c44fa8c9b --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/escape-analysis-array.js @@ -0,0 +1,32 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Test variable index access to array with 1 element. +(function testOneElementArrayVariableIndex() { + function f(i) { + const a = new Array("first"); + return a[i]; + } + + assertEquals("first", f(0)); + assertEquals("first", f(0)); + %OptimizeFunctionOnNextCall(f); + assertEquals("first", f(0)); +})(); + +// Test variable index access to array with 2 elements. +(function testTwoElementArrayVariableIndex() { + function f(i) { + const a = new Array("first", "second"); + return a[i]; + } + + assertEquals("first", f(0)); + assertEquals("second", f(1)); + %OptimizeFunctionOnNextCall(f); + assertEquals("first", f(0)); + assertEquals("second", f(1)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/escape-analysis-rest-parameters.js b/deps/v8/test/mjsunit/compiler/escape-analysis-rest-parameters.js new file mode 100644 index 0000000000..2ac1253a18 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/escape-analysis-rest-parameters.js @@ -0,0 +1,31 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Test variable index access to rest parameters +// with up to 2 elements. +(function testRestParametersVariableIndex() { + function g(...args) { + let s = 0; + for (let i = 0; i < args.length; ++i) s += args[i]; + return s; + } + + function f(x, y) { + // (a) args[i] is dead code since args.length is 0. + const a = g(); + // (b) args[i] always yields the first element. + const b = g(x); + // (c) args[i] can yield either x or y. + const c = g(x, y); + return a + b + c; + } + + assertEquals(4, f(1, 2)); + assertEquals(5, f(2, 1)); + %OptimizeFunctionOnNextCall(f); + assertEquals(4, f(1, 2)); + assertEquals(5, f(2, 1)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/instanceof2.js b/deps/v8/test/mjsunit/compiler/instanceof2.js new file mode 100644 index 0000000000..ca006e3046 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/instanceof2.js @@ -0,0 +1,233 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + + +// Without instance creation: + +(function() { + function Goo() {}; + const goo = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertFalse(IsGoo(goo)); +})(); + +(function() { + function Goo() {}; + const goo = {}; + Goo.prototype = Object.prototype; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertTrue(IsGoo(goo)); + assertTrue(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertTrue(IsGoo(goo)); +})(); + +(function() { + function Goo() {}; + const goo = {}; + Goo.prototype = 42 + + function IsGoo(x) { + return x instanceof Goo; + } + + assertThrows(_ => IsGoo(goo), TypeError); + assertThrows(_ => IsGoo(goo), TypeError); + %OptimizeFunctionOnNextCall(IsGoo); + assertThrows(_ => IsGoo(goo), TypeError); +})(); + +(function() { + function Goo() {}; + const goo = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertFalse(IsGoo(goo)); + Goo.prototype = Object.prototype; + assertTrue(IsGoo(goo)); +})(); + +(function() { + function Goo() {}; + const goo = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertFalse(IsGoo(goo)); + Goo.prototype = 42; + assertThrows(_ => IsGoo(goo), TypeError); +})(); + + +// With instance creation: + +(function() { + function Goo() {}; + const goo = new Goo(); + + function IsGoo(x) { + return x instanceof Goo; + } + + assertTrue(IsGoo(goo)); + assertTrue(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertTrue(IsGoo(goo)); +})(); + +(function() { + function Goo() {}; + const goo = new Goo(); + Goo.prototype = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertFalse(IsGoo(goo)); +})(); + +(function() { + function Goo() {}; + const goo = new Goo(); + Goo.prototype = 42; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertThrows(_ => IsGoo(goo), TypeError); + assertThrows(_ => IsGoo(goo), TypeError); + %OptimizeFunctionOnNextCall(IsGoo); + assertThrows(_ => IsGoo(goo), TypeError); +})(); + +(function() { + function Goo() {}; + const goo = new Goo(); + + function IsGoo(x) { + return x instanceof Goo; + } + + assertTrue(IsGoo(goo)); + assertTrue(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertTrue(IsGoo(goo)); + Goo.prototype = {}; + assertFalse(IsGoo(goo)); +})(); + +(function() { + function Goo() {}; + const goo = new Goo(); + + function IsGoo(x) { + return x instanceof Goo; + } + + assertTrue(IsGoo(goo)); + assertTrue(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertTrue(IsGoo(goo)); + Goo.prototype = 42 + assertThrows(_ => IsGoo(goo), TypeError); +})(); + +(function() { + function Goo() {}; + Goo.prototype = 42; + const goo = new Goo(); + + function IsGoo(x) { + return x instanceof Goo; + } + + assertThrows(_ => IsGoo(goo), TypeError); + assertThrows(_ => IsGoo(goo), TypeError); + %OptimizeFunctionOnNextCall(IsGoo); + assertThrows(_ => IsGoo(goo), TypeError); + Goo.prototype = {}; + assertFalse(IsGoo(goo)); +})(); + +(function() { + function Goo() {}; + Goo.prototype = 42; + const goo = new Goo(); + Goo.prototype = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertFalse(IsGoo(goo)); + Goo.prototype = Object.prototype; + assertTrue(IsGoo(goo)); +})(); + +(function() { + function Goo() {}; + Goo.prototype = {}; + const goo = new Goo(); + Goo.prototype = 42; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertThrows(_ => IsGoo(goo), TypeError); + assertThrows(_ => IsGoo(goo), TypeError); + %OptimizeFunctionOnNextCall(IsGoo); + assertThrows(_ => IsGoo(goo), TypeError); + Goo.prototype = Object.prototype; + assertTrue(IsGoo(goo)); +})(); + +(function() { + function Goo() {}; + Goo.prototype = {}; + const goo = new Goo(); + Goo.prototype = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + Goo.prototype = Object.prototype; + assertTrue(IsGoo(goo)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/instanceof3.js b/deps/v8/test/mjsunit/compiler/instanceof3.js new file mode 100644 index 0000000000..e390c42092 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/instanceof3.js @@ -0,0 +1,233 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + + +// Without instance creation: + +(function() { + function* Goo() {}; + const goo = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertFalse(IsGoo(goo)); +})(); + +(function() { + function* Goo() {}; + const goo = {}; + Goo.prototype = Object.prototype; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertTrue(IsGoo(goo)); + assertTrue(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertTrue(IsGoo(goo)); +})(); + +(function() { + function* Goo() {}; + const goo = {}; + Goo.prototype = 42 + + function IsGoo(x) { + return x instanceof Goo; + } + + assertThrows(_ => IsGoo(goo), TypeError); + assertThrows(_ => IsGoo(goo), TypeError); + %OptimizeFunctionOnNextCall(IsGoo); + assertThrows(_ => IsGoo(goo), TypeError); +})(); + +(function() { + function* Goo() {}; + const goo = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertFalse(IsGoo(goo)); + Goo.prototype = Object.prototype; + assertTrue(IsGoo(goo)); +})(); + +(function() { + function* Goo() {}; + const goo = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertFalse(IsGoo(goo)); + Goo.prototype = 42; + assertThrows(_ => IsGoo(goo), TypeError); +})(); + + +// With instance creation: + +(function() { + function* Goo() {}; + const goo = Goo(); + + function IsGoo(x) { + return x instanceof Goo; + } + + assertTrue(IsGoo(goo)); + assertTrue(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertTrue(IsGoo(goo)); +})(); + +(function() { + function* Goo() {}; + const goo = Goo(); + Goo.prototype = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertFalse(IsGoo(goo)); +})(); + +(function() { + function* Goo() {}; + const goo = Goo(); + Goo.prototype = 42; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertThrows(_ => IsGoo(goo), TypeError); + assertThrows(_ => IsGoo(goo), TypeError); + %OptimizeFunctionOnNextCall(IsGoo); + assertThrows(_ => IsGoo(goo), TypeError); +})(); + +(function() { + function* Goo() {}; + const goo = Goo(); + + function IsGoo(x) { + return x instanceof Goo; + } + + assertTrue(IsGoo(goo)); + assertTrue(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertTrue(IsGoo(goo)); + Goo.prototype = {}; + assertFalse(IsGoo(goo)); +})(); + +(function() { + function* Goo() {}; + const goo = Goo(); + + function IsGoo(x) { + return x instanceof Goo; + } + + assertTrue(IsGoo(goo)); + assertTrue(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertTrue(IsGoo(goo)); + Goo.prototype = 42 + assertThrows(_ => IsGoo(goo), TypeError); +})(); + +(function() { + function* Goo() {}; + Goo.prototype = 42; + const goo = Goo(); + + function IsGoo(x) { + return x instanceof Goo; + } + + assertThrows(_ => IsGoo(goo), TypeError); + assertThrows(_ => IsGoo(goo), TypeError); + %OptimizeFunctionOnNextCall(IsGoo); + assertThrows(_ => IsGoo(goo), TypeError); + Goo.prototype = {}; + assertFalse(IsGoo(goo)); +})(); + +(function() { + function* Goo() {}; + Goo.prototype = 42; + const goo = Goo(); + Goo.prototype = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + assertFalse(IsGoo(goo)); + Goo.prototype = Object.prototype; + assertTrue(IsGoo(goo)); +})(); + +(function() { + function* Goo() {}; + Goo.prototype = {}; + const goo = Goo(); + Goo.prototype = 42; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertThrows(_ => IsGoo(goo), TypeError); + assertThrows(_ => IsGoo(goo), TypeError); + %OptimizeFunctionOnNextCall(IsGoo); + assertThrows(_ => IsGoo(goo), TypeError); + Goo.prototype = Object.prototype; + assertTrue(IsGoo(goo)); +})(); + +(function() { + function* Goo() {}; + Goo.prototype = {}; + const goo = Goo(); + Goo.prototype = {}; + + function IsGoo(x) { + return x instanceof Goo; + } + + assertFalse(IsGoo(goo)); + assertFalse(IsGoo(goo)); + %OptimizeFunctionOnNextCall(IsGoo); + Goo.prototype = Object.prototype; + assertTrue(IsGoo(goo)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/int64.js b/deps/v8/test/mjsunit/compiler/int64.js new file mode 100644 index 0000000000..0a88a95895 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/int64.js @@ -0,0 +1,91 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Test NumberAdd with PositiveSafeInteger -> PositiveSafeInteger (as Tagged). +(function() { + function foo(x) { + const i = x ? 0xFFFFFFFF : 0; + return i + 1; + } + + assertEquals(0x000000001, foo(false)); + assertEquals(0x000000001, foo(false)); + assertEquals(0x100000000, foo(true)); + assertEquals(0x100000000, foo(true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0x000000001, foo(false)); + assertEquals(0x100000000, foo(true)); +})(); + +// Test NumberAdd with SafeInteger -> SafeInteger (as Tagged). +(function() { + function foo(x) { + const i = x ? 0xFFFFFFFF : -1; + return i + 1; + } + + assertEquals(0x000000000, foo(false)); + assertEquals(0x000000000, foo(false)); + assertEquals(0x100000000, foo(true)); + assertEquals(0x100000000, foo(true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0x000000000, foo(false)); + assertEquals(0x100000000, foo(true)); +})(); + +// NumberAdd: Smi x Unsigned32 -> SafeInteger (as Float64). +(function() { + const a = new Float64Array(1); + + function foo(o) { + a[0] = o.x + 0xFFFFFFFF; + return a[0]; + } + + assertEquals(0x0FFFFFFFF, foo({x:0})); + assertEquals(0x100000000, foo({x:1})); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0x100000000, foo({x:1})); +})(); + +// NumberAdd: Smi x Unsigned32 -> SafeInteger (as TaggedSigned). +(function() { + function foo(o) { + return {x: Math.floor((o.x + 11123456789) + -11123456788)}.x; + } + + assertEquals(1, foo({x:0})); + assertEquals(2, foo({x:1})); + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo({x:1})); +})(); + +// NumberSubtract: Unsigned32 x Unsigned32 -> SafeInteger (as Word32). +(function() { + function foo(a, i) { + i = ((i >>> 0)) - 0xFFFFFFFF; + return a[i]; + } + + assertEquals(1, foo([1], 0xFFFFFFFF)); + assertEquals(2, foo([2], 0xFFFFFFFF)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(3, foo([3], 0xFFFFFFFF)); +})(); + +// Test that the Deoptimizer can handle Word64 properly. +(function() { + function foo(b) { + const i = ((b >>> 0)) - 0xFFFFFFFF; + %DeoptimizeFunction(foo); + return i; + } + + assertEquals(0, foo(0xFFFFFFFF)); + assertEquals(0, foo(0xFFFFFFFF)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(0xFFFFFFFF)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/math-imul.js b/deps/v8/test/mjsunit/compiler/math-imul.js new file mode 100644 index 0000000000..1de18a6a2d --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/math-imul.js @@ -0,0 +1,76 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test Math.imul() with no inputs. +(function() { + function foo() { return Math.imul(); } + + assertEquals(0, foo()); + assertEquals(0, foo()); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo()); +})(); + +// Test Math.imul() with only one input. +(function() { + function foo(x) { return Math.imul(x); } + + assertEquals(0, foo(1)); + assertEquals(0, foo(2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(3)); +})(); + +// Test Math.imul() with wrong types. +(function() { + function foo(x, y) { return Math.imul(x, y); } + + assertEquals(0, foo(null, 1)); + assertEquals(0, foo(2, undefined)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(null, 1)); + assertEquals(0, foo(2, undefined)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(null, 1)); + assertEquals(0, foo(2, undefined)); + assertOptimized(foo); +})(); + +// Test Math.imul() with signed integers (statically known). +(function() { + function foo(x, y) { return Math.imul(x|0, y|0); } + + assertEquals(1, foo(1, 1)); + assertEquals(2, foo(2, 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1, 1)); + assertEquals(2, foo(2, 1)); + assertOptimized(foo); +})(); + +// Test Math.imul() with unsigned integers (statically known). +(function() { + function foo(x, y) { return Math.imul(x>>>0, y>>>0); } + + assertEquals(1, foo(1, 1)); + assertEquals(2, foo(2, 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1, 1)); + assertEquals(2, foo(2, 1)); + assertOptimized(foo); +})(); + +// Test Math.imul() with floating-point numbers. +(function() { + function foo(x, y) { return Math.imul(x, y); } + + assertEquals(1, foo(1.1, 1.1)); + assertEquals(2, foo(2.1, 1.1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1.1, 1.1)); + assertEquals(2, foo(2.1, 1.1)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/math-max.js b/deps/v8/test/mjsunit/compiler/math-max.js new file mode 100644 index 0000000000..350bdfba88 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/math-max.js @@ -0,0 +1,38 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Test the case where TurboFan can statically rule out -0 from the +// Math.max type. +(function() { + function foo(x) { + // Arrange x such that TurboFan infers type [-inf, inf] \/ MinusZero. + x = +x; + x = Math.round(x); + return Object.is(-0, Math.max(1, x)) + } + + assertFalse(foo(-0)); + assertFalse(foo(-1)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(-0)); + assertFalse(foo(-1)); +})(); + +// Test the case where -0 is ruled out because it's strictly less than +0. +(function() { + function foo(x) { + // Arrange x such that TurboFan infers type [-inf, inf] \/ MinusZero. + x = +x; + x = Math.round(x); + return Object.is(-0, Math.max(0, x)) + } + + assertFalse(foo(-0)); + assertFalse(foo(-1)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(-0)); + assertFalse(foo(-1)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/math-min.js b/deps/v8/test/mjsunit/compiler/math-min.js new file mode 100644 index 0000000000..882103984d --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/math-min.js @@ -0,0 +1,38 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Test the case where TurboFan can statically rule out -0 from the +// Math.min type. +(function() { + function foo(x) { + // Arrange x such that TurboFan infers type [-inf, inf] \/ MinusZero. + x = +x; + x = Math.round(x); + return Object.is(-0, Math.min(-1, x)) + } + + assertFalse(foo(-0)); + assertFalse(foo(-1)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(-0)); + assertFalse(foo(-1)); +})(); + +// Test the case where +0 is ruled out because it's strictly greater than -0. +(function() { + function foo(x) { + // Arrange x such that TurboFan infers type [-inf, inf] \/ MinusZero. + x = +x; + x = Math.round(x); + return Object.is(+0, Math.min(-0, x)) + } + + assertFalse(foo(-0)); + assertFalse(foo(-1)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(-0)); + assertFalse(foo(-1)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-abs.js b/deps/v8/test/mjsunit/compiler/number-abs.js new file mode 100644 index 0000000000..9eb8ab5bb5 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-abs.js @@ -0,0 +1,76 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test that NumberAbs correctly deals with PositiveInteger \/ MinusZero +// and turns the -0 into a 0. +(function() { + function foo(x) { + x = Math.floor(x); + x = Math.max(x, -0); + return 1 / Math.abs(x); + } + + assertEquals(Infinity, foo(-0)); + assertEquals(Infinity, foo(-0)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(Infinity, foo(-0)); +})(); + +// Test that NumberAbs properly passes the kIdentifyZeros truncation +// for Signed32 \/ MinusZero inputs. +(function() { + function foo(x) { + return Math.abs(x * -2); + } + + assertEquals(2, foo(-1)); + assertEquals(4, foo(-2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(-1)); + assertEquals(4, foo(-2)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(0, foo(0)); + assertOptimized(foo); +})(); + +// Test that NumberAbs properly passes the kIdentifyZeros truncation +// for Unsigned32 \/ MinusZero inputs. +(function() { + function foo(x) { + x = x | 0; + return Math.abs(Math.max(x * -2, 0)); + } + + assertEquals(2, foo(-1)); + assertEquals(4, foo(-2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(-1)); + assertEquals(4, foo(-2)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(0, foo(0)); + assertOptimized(foo); +})(); + +// Test that NumberAbs properly passes the kIdentifyZeros truncation +// for OrderedNumber inputs. +(function() { + function foo(x) { + x = x | 0; + return Math.abs(Math.min(x * -2, 2 ** 32)); + } + + assertEquals(2, foo(-1)); + assertEquals(4, foo(-2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(-1)); + assertEquals(4, foo(-2)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(0, foo(0)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-add.js b/deps/v8/test/mjsunit/compiler/number-add.js new file mode 100644 index 0000000000..61e6495c52 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-add.js @@ -0,0 +1,62 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// This tests that NumberAdd passes on the right truncations +// even if it figures out during SimplifiedLowering that it +// can indeed do a Word32 operation (based on the feedback +// baked in for its inputs by other operators). +(function() { + // We need a + with Number feedback to get to a NumberAdd + // during the typed lowering pass of TurboFan's frontend. + function foo(x, y) { return x + y; } + foo(0.1, 0.2); + foo(0.1, 0.2); + + // Now we need to fool TurboFan to think that it has to + // perform the `foo(x,-1)` on Float64 values until the + // very last moment (after the RETYPE phase of the + // SimplifiedLowering) where it realizes that the inputs + // and outputs of the NumberAdd allow it perform the + // operation on Word32. + function bar(x) { + x = Math.trunc(foo(x - 1, 1)); + return foo(x, -1); + } + + assertEquals(0, bar(1)); + assertEquals(1, bar(2)); + %OptimizeFunctionOnNextCall(bar); + assertEquals(2, bar(3)); +})(); + +// This tests that SpeculativeNumberAdd can still lower to +// Int32Add in SimplifiedLowering, which requires some magic +// to make sure that SpeculativeNumberAdd survives to that +// point, especially the JSTypedLowering needs to be unable +// to tell that the inputs to SpeculativeNumberAdd are non +// String primitives. +(function() { + // We need a function that has a + with feedback Number or + // NumberOrOddball, but for whose inputs the JSTypedLowering + // cannot reduce it to NumberAdd (with SpeculativeToNumber + // conversions). We achieve this utilizing an object literal + // indirection here. + function baz(x) { + return {x}.x + x; + } + baz(null); + baz(undefined); + + // Now we just need to truncate the result. + function foo(x) { + return baz(1) | 0; + } + + assertEquals(2, foo()); + assertEquals(2, foo()); + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo()); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-ceil.js b/deps/v8/test/mjsunit/compiler/number-ceil.js new file mode 100644 index 0000000000..ce87cd0fc0 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-ceil.js @@ -0,0 +1,22 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test that NumberCeil propagates kIdentifyZeros truncations. +(function() { + function foo(x) { + return Math.abs(Math.ceil(x * -2)); + } + + assertEquals(2, foo(1)); + assertEquals(4, foo(2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(1)); + assertEquals(4, foo(2)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(0, foo(0)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-comparison-truncations.js b/deps/v8/test/mjsunit/compiler/number-comparison-truncations.js new file mode 100644 index 0000000000..33abf6b913 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-comparison-truncations.js @@ -0,0 +1,152 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test that SpeculativeNumberEqual[SignedSmall] properly passes the +// kIdentifyZeros truncation. +(function() { + function foo(x, y) { + if (x * y === 0) return 0; + return 1; + } + + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + assertOptimized(foo); + // Even if x*y produces -0 now, it should stay optimized. + assertEquals(0, foo(-3, 0)); + assertEquals(0, foo(0, -3)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberEqual[Number] properly passes the +// kIdentifyZeros truncation. +(function() { + // Produce a SpeculativeNumberEqual with Number feedback. + function bar(x, y) { return x === y; } + bar(0.1, 0.5); + bar(-0, 100); + + function foo(x, y) { + if (bar(x * y, 0)) return 0; + return 1; + } + + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + assertOptimized(foo); + // Even if x*y produces -0 now, it should stay optimized. + assertEquals(0, foo(-3, 0)); + assertEquals(0, foo(0, -3)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberLessThan[SignedSmall] properly passes the +// kIdentifyZeros truncation. +(function() { + function foo(x, y) { + if (x * y < 0) return 0; + return 1; + } + + assertEquals(0, foo(1, -1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1, -1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + assertOptimized(foo); + // Even if x*y produces -0 now, it should stay optimized. + assertEquals(1, foo(-3, 0)); + assertEquals(1, foo(0, -3)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberLessThan[Number] properly passes the +// kIdentifyZeros truncation. +(function() { + // Produce a SpeculativeNumberLessThan with Number feedback. + function bar(x, y) { return x < y; } + bar(0.1, 0.5); + bar(-0, 100); + + function foo(x, y) { + if (bar(x * y, 0)) return 0; + return 1; + } + + assertEquals(0, foo(1, -1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1, -1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + assertOptimized(foo); + // Even if x*y produces -0 now, it should stay optimized. + assertEquals(1, foo(-3, 0)); + assertEquals(1, foo(0, -3)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberLessThanOrEqual[SignedSmall] properly passes the +// kIdentifyZeros truncation. +(function() { + function foo(x, y) { + if (x * y <= 0) return 0; + return 1; + } + + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + assertOptimized(foo); + // Even if x*y produces -0 now, it should stay optimized. + assertEquals(0, foo(-3, 0)); + assertEquals(0, foo(0, -3)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberLessThanOrEqual[Number] properly passes the +// kIdentifyZeros truncation. +(function() { + // Produce a SpeculativeNumberLessThanOrEqual with Number feedback. + function bar(x, y) { return x <= y; } + bar(0.1, 0.5); + bar(-0, 100); + + function foo(x, y) { + if (bar(x * y, 0)) return 0; + return 1; + } + + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(0, 1)); + assertEquals(1, foo(1, 1)); + assertEquals(1, foo(1, 2)); + assertOptimized(foo); + // Even if x*y produces -0 now, it should stay optimized. + assertEquals(0, foo(-3, 0)); + assertEquals(0, foo(0, -3)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-divide.js b/deps/v8/test/mjsunit/compiler/number-divide.js new file mode 100644 index 0000000000..c4cc8fa881 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-divide.js @@ -0,0 +1,207 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt --noalways-opt + +// Test that NumberDivide with Number feedback works if only in the +// end SimplifiedLowering figures out that the inputs to this operation +// are actually Unsigned32. +(function() { + // We need a separately polluted % with NumberOrOddball feedback. + function bar(x) { return x / 2; } + bar(undefined); // The % feedback is now NumberOrOddball. + + // Now just use the gadget above in a way that only after RETYPE + // in SimplifiedLowering we find out that the `x` is actually in + // Unsigned32 range (based on taking the SignedSmall feedback on + // the + operator). + function foo(x) { + x = (x >>> 0) + 1; + return bar(x) | 0; + } + + assertEquals(1, foo(1)); + assertEquals(1, foo(2)); + assertEquals(2, foo(3)); + assertEquals(2, foo(4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1)); + assertEquals(1, foo(2)); + assertEquals(2, foo(3)); + assertEquals(2, foo(4)); + assertOptimized(foo); +})(); + +// Test that NumberDivide with Number feedback works if only in the +// end SimplifiedLowering figures out that the inputs to this operation +// are actually Signed32. +(function() { + // We need a separately polluted % with NumberOrOddball feedback. + function bar(x) { return x / 2; } + bar(undefined); // The % feedback is now NumberOrOddball. + + // Now just use the gadget above in a way that only after RETYPE + // in SimplifiedLowering we find out that the `x` is actually in + // Signed32 range (based on taking the SignedSmall feedback on + // the + operator). + function foo(x) { + x = (x | 0) + 1; + return bar(x) | 0; + } + + assertEquals(1, foo(1)); + assertEquals(1, foo(2)); + assertEquals(2, foo(3)); + assertEquals(2, foo(4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1)); + assertEquals(1, foo(2)); + assertEquals(2, foo(3)); + assertEquals(2, foo(4)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberDivide turns into CheckedInt32Div, and +// that the "known power of two divisor" optimization works correctly. +(function() { + function foo(x) { return (x | 0) / 2; } + + // Warmup with proper int32 divisions. + assertEquals(1, foo(2)); + assertEquals(2, foo(4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(3, foo(6)); + assertOptimized(foo); + + // Make optimized code fail. + assertEquals(0.5, foo(1)); + assertUnoptimized(foo); + + // Try again with the new feedback, and now it should stay optimized. + %OptimizeFunctionOnNextCall(foo); + assertEquals(4, foo(8)); + assertOptimized(foo); + assertEquals(0.5, foo(1)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberDivide turns into CheckedInt32Div, and +// that the optimized code properly bails out on "division by zero". +(function() { + function foo(x, y) { return x / y; } + + // Warmup with proper int32 divisions. + assertEquals(2, foo(4, 2)); + assertEquals(2, foo(8, 4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(2, 2)); + assertOptimized(foo); + + // Make optimized code fail. + assertEquals(Infinity, foo(1, 0)); + assertUnoptimized(foo); + + // Try again with the new feedback, and now it should stay optimized. + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(2, 1)); + assertOptimized(foo); + assertEquals(Infinity, foo(1, 0)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberDivide turns into CheckedInt32Div, and +// that the optimized code properly bails out on minus zero. +(function() { + function foo(x, y) { return x / y; } + + // Warmup with proper int32 divisions. + assertEquals(2, foo(4, 2)); + assertEquals(2, foo(8, 4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(2, 2)); + assertOptimized(foo); + + // Make optimized code fail. + assertEquals(-0, foo(0, -1)); + assertUnoptimized(foo); + + // Try again with the new feedback, and now it should stay optimized. + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(2, 1)); + assertOptimized(foo); + assertEquals(-0, foo(0, -1)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberDivide turns into CheckedInt32Div, and +// that the optimized code properly bails out if result is -kMinInt. +(function() { + function foo(x, y) { return x / y; } + + // Warmup with proper int32 divisions. + assertEquals(2, foo(4, 2)); + assertEquals(2, foo(8, 4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(2, 2)); + assertOptimized(foo); + + // Make optimized code fail. + assertEquals(2147483648, foo(-2147483648, -1)); + assertUnoptimized(foo); + + // Try again with the new feedback, and now it should stay optimized. + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(2, 1)); + assertOptimized(foo); + assertEquals(2147483648, foo(-2147483648, -1)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberDivide turns into CheckedUint32Div, and +// that the "known power of two divisor" optimization works correctly. +(function() { + function foo(s) { return s.length / 2; } + + // Warmup with proper uint32 divisions. + assertEquals(1, foo("ab".repeat(1))); + assertEquals(2, foo("ab".repeat(2))); + %OptimizeFunctionOnNextCall(foo); + assertEquals(3, foo("ab".repeat(3))); + assertOptimized(foo); + + // Make optimized code fail. + assertEquals(0.5, foo("a")); + assertUnoptimized(foo); + + // Try again with the new feedback, and now it should stay optimized. + %OptimizeFunctionOnNextCall(foo); + assertEquals(4, foo("ab".repeat(4))); + assertOptimized(foo); + assertEquals(0.5, foo("a")); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberDivide turns into CheckedUint32Div, and +// that the optimized code properly bails out on "division by zero". +(function() { + function foo(x, y) { return (x >>> 0) / (y >>> 0); } + + // Warmup with proper uint32 divisions. + assertEquals(2, foo(4, 2)); + assertEquals(2, foo(8, 4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(2, 2)); + assertOptimized(foo); + + // Make optimized code fail. + assertEquals(Infinity, foo(1, 0)); + assertUnoptimized(foo); + + // Try again with the new feedback, and now it should stay optimized. + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(2, 1)); + assertOptimized(foo); + assertEquals(Infinity, foo(1, 0)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-floor.js b/deps/v8/test/mjsunit/compiler/number-floor.js new file mode 100644 index 0000000000..180b89e559 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-floor.js @@ -0,0 +1,22 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test that NumberFloor propagates kIdentifyZeros truncations. +(function() { + function foo(x) { + return Math.abs(Math.floor(x * -2)); + } + + assertEquals(2, foo(1)); + assertEquals(4, foo(2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(1)); + assertEquals(4, foo(2)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(0, foo(0)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-issafeinteger.js b/deps/v8/test/mjsunit/compiler/number-issafeinteger.js index 192fb6c124..b705e95ed5 100644 --- a/deps/v8/test/mjsunit/compiler/number-issafeinteger.js +++ b/deps/v8/test/mjsunit/compiler/number-issafeinteger.js @@ -40,11 +40,19 @@ function test(f) { assertFalse(f(2 * near_lower - 7)); } -function f(x) { - return Number.isSafeInteger(+x); -} +// Check that the NumberIsSafeInteger simplified operator in +// TurboFan does the right thing. +function NumberIsSafeInteger(x) { return Number.isSafeInteger(+x); } +test(NumberIsSafeInteger); +test(NumberIsSafeInteger); +%OptimizeFunctionOnNextCall(NumberIsSafeInteger); +test(NumberIsSafeInteger); -test(f); -test(f); -%OptimizeFunctionOnNextCall(f); -test(f); +// Check that the ObjectIsSafeInteger simplified operator in +// TurboFan does the right thing as well (i.e. when TurboFan +// is not able to tell statically that the inputs are numbers). +function ObjectIsSafeInteger(x) { return Number.isSafeInteger(x); } +test(ObjectIsSafeInteger); +test(ObjectIsSafeInteger); +%OptimizeFunctionOnNextCall(ObjectIsSafeInteger); +test(ObjectIsSafeInteger); diff --git a/deps/v8/test/mjsunit/compiler/number-max.js b/deps/v8/test/mjsunit/compiler/number-max.js new file mode 100644 index 0000000000..7e5a4a4ad1 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-max.js @@ -0,0 +1,23 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test that NumberMax properly passes the kIdentifyZeros truncation. +(function() { + function foo(x) { + if (Math.max(x * -2, 1) == 1) return 0; + return 1; + } + + assertEquals(0, foo(2)); + assertEquals(1, foo(-1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(2)); + assertEquals(1, foo(-1)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(0, foo(0)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-min.js b/deps/v8/test/mjsunit/compiler/number-min.js new file mode 100644 index 0000000000..72bff78686 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-min.js @@ -0,0 +1,23 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test that NumberMin properly passes the kIdentifyZeros truncation. +(function() { + function foo(x) { + if (Math.min(x * -2, -1) == -2) return 0; + return 1; + } + + assertEquals(0, foo(1)); + assertEquals(1, foo(2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1)); + assertEquals(1, foo(2)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(1, foo(0)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-modulus.js b/deps/v8/test/mjsunit/compiler/number-modulus.js new file mode 100644 index 0000000000..5f695d1ee5 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-modulus.js @@ -0,0 +1,256 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt --noalways-opt + +// Test that NumberModulus with Number feedback works if only in the +// end SimplifiedLowering figures out that the inputs to this operation +// are actually Unsigned32. +(function() { + // We need a separately polluted % with NumberOrOddball feedback. + function bar(x) { return x % 2; } + bar(undefined); // The % feedback is now NumberOrOddball. + + // Now just use the gadget above in a way that only after RETYPE + // in SimplifiedLowering we find out that the `x` is actually in + // Unsigned32 range (based on taking the SignedSmall feedback on + // the + operator). + function foo(x) { + x = (x >>> 0) + 1; + return bar(x) | 0; + } + + assertEquals(0, foo(1)); + assertEquals(1, foo(2)); + assertEquals(0, foo(3)); + assertEquals(1, foo(4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1)); + assertEquals(1, foo(2)); + assertEquals(0, foo(3)); + assertEquals(1, foo(4)); + assertOptimized(foo); +})(); + +// Test that NumberModulus with Number feedback works if only in the +// end SimplifiedLowering figures out that the inputs to this operation +// are actually Signed32. +(function() { + // We need a separately polluted % with NumberOrOddball feedback. + function bar(x) { return x % 2; } + bar(undefined); // The % feedback is now NumberOrOddball. + + // Now just use the gadget above in a way that only after RETYPE + // in SimplifiedLowering we find out that the `x` is actually in + // Signed32 range (based on taking the SignedSmall feedback on + // the + operator). + function foo(x) { + x = (x | 0) + 1; + return bar(x) | 0; + } + + assertEquals(0, foo(1)); + assertEquals(1, foo(2)); + assertEquals(0, foo(3)); + assertEquals(1, foo(4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1)); + assertEquals(1, foo(2)); + assertEquals(0, foo(3)); + assertEquals(1, foo(4)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberModulus with Number feedback works if +// only in the end SimplifiedLowering figures out that the inputs to +// this operation are actually Unsigned32. +(function() { + // We need to use an object literal here to make sure that the + // SpeculativeNumberModulus is not turned into a NumberModulus + // early during JSTypedLowering. + function bar(x) { return {x}.x % 2; } + bar(undefined); // The % feedback is now NumberOrOddball. + + // Now just use the gadget above in a way that only after RETYPE + // in SimplifiedLowering we find out that the `x` is actually in + // Unsigned32 range (based on taking the SignedSmall feedback on + // the + operator). + function foo(x) { + x = (x >>> 0) + 1; + return bar(x) | 0; + } + + assertEquals(0, foo(1)); + assertEquals(1, foo(2)); + assertEquals(0, foo(3)); + assertEquals(1, foo(4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1)); + assertEquals(1, foo(2)); + assertEquals(0, foo(3)); + assertEquals(1, foo(4)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberModulus with Number feedback works if +// only in the end SimplifiedLowering figures out that the inputs to +// this operation are actually Signed32. +(function() { + // We need to use an object literal here to make sure that the + // SpeculativeNumberModulus is not turned into a NumberModulus + // early during JSTypedLowering. + function bar(x) { return {x}.x % 2; } + bar(undefined); // The % feedback is now NumberOrOddball. + + // Now just use the gadget above in a way that only after RETYPE + // in SimplifiedLowering we find out that the `x` is actually in + // Signed32 range (based on taking the SignedSmall feedback on + // the + operator). + function foo(x) { + x = (x | 0) + 1; + return bar(x) | 0; + } + + assertEquals(0, foo(1)); + assertEquals(1, foo(2)); + assertEquals(0, foo(3)); + assertEquals(1, foo(4)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1)); + assertEquals(1, foo(2)); + assertEquals(0, foo(3)); + assertEquals(1, foo(4)); + assertOptimized(foo); +})(); + +// Test that NumberModulus works in the case where TurboFan +// can infer that the output is Signed32 \/ MinusZero, and +// there's a truncation on the result that identifies zeros +// (via the SpeculativeNumberEqual). +(function() { + // We need a separately polluted % with NumberOrOddball feedback. + function bar(x) { return x % 2; } + bar(undefined); // The % feedback is now NumberOrOddball. + + // Now we just use the gadget above on an `x` that is known + // to be in Signed32 range and compare it to 0, which passes + // a truncation that identifies zeros. + function foo(x) { + if (bar(x | 0) == 0) return 0; + return 1; + } + + assertEquals(0, foo(2)); + assertEquals(1, foo(1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(2)); + assertEquals(1, foo(1)); + assertOptimized(foo); + + // Now `foo` should stay optimized even if `x % 2` would + // produce -0, aka when we pass a negative value for `x`. + assertEquals(0, foo(-2)); + assertEquals(1, foo(-1)); + assertOptimized(foo); +})(); + +// Test that CheckedInt32Mod handles the slow-path (when +// the left hand side is negative) correctly. +(function() { + // We need a SpeculativeNumberModulus with SignedSmall feedback. + function foo(x, y) { + return x % y; + } + + assertEquals(0, foo(2, 1)); + assertEquals(0, foo(2, 2)); + assertEquals(-1, foo(-3, 2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(2, 1)); + assertEquals(0, foo(2, 2)); + assertEquals(-1, foo(-3, 2)); + assertOptimized(foo); + + // Now `foo` should deoptimize if the result is -0. + assertEquals(-0, foo(-2, 2)); + assertUnoptimized(foo); +})(); + +// Test that NumberModulus passes kIdentifiesZero to the +// left hand side input when the result doesn't care about +// 0 vs -0, even when the inputs are outside Signed32. +(function() { + function foo(x) { + return (x * -2) % (2 ** 32) === 0; + } + + assertFalse(foo(2)); + assertFalse(foo(1)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(2)); + assertFalse(foo(1)); + + // Now `foo` should stay optimized even if `x * -2` would + // produce -0, aka when we pass a zero value for `x`. + assertTrue(foo(0)); + assertOptimized(foo); +})(); + +// Test that NumberModulus passes kIdentifiesZero to the +// right hand side input, even when the inputs are outside +// the Signed32 range. +(function() { + function foo(x) { + return (2 ** 32) % (x * -2); + } + + assertEquals(0, foo(1)); + assertEquals(0, foo(1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(1)); + + // Now `foo` should stay optimized even if `x * -2` would + // produce -0, aka when we pass a zero value for `x`. + assertEquals(NaN, foo(0)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberModulus passes kIdentifiesZero +// to the right hand side input, even when feedback is consumed. +(function() { + function foo(x, y) { + return (x % (y * -2)) | 0; + } + + assertEquals(0, foo(2, 1)); + assertEquals(-1, foo(-3, 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(2, 1)); + assertEquals(-1, foo(-3, 1)); + assertOptimized(foo); + + // Now `foo` should stay optimized even if `y * -2` would + // produce -0, aka when we pass a zero value for `y`. + assertEquals(0, foo(2, 0)); + assertOptimized(foo); +})(); + +// Test that SpeculativeNumberModulus passes kIdentifiesZero +// to the left hand side input, even when feedback is consumed. +(function() { + function foo(x, y) { + return ((x * -2) % y) | 0; + } + + assertEquals(-2, foo(1, 3)); + assertEquals(-2, foo(1, 3)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(-2, foo(1, 3)); + assertOptimized(foo); + + // Now `foo` should stay optimized even if `x * -2` would + // produce -0, aka when we pass a zero value for `x`. + assertEquals(0, foo(0, 2)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-round.js b/deps/v8/test/mjsunit/compiler/number-round.js new file mode 100644 index 0000000000..9aec7f7a12 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-round.js @@ -0,0 +1,22 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test that NumberRound propagates kIdentifyZeros truncations. +(function() { + function foo(x) { + return Math.abs(Math.round(x * -2)); + } + + assertEquals(2, foo(1)); + assertEquals(4, foo(2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(1)); + assertEquals(4, foo(2)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(0, foo(0)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-subtract.js b/deps/v8/test/mjsunit/compiler/number-subtract.js new file mode 100644 index 0000000000..cb3e1c7e70 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-subtract.js @@ -0,0 +1,34 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// This tests that SpeculativeNumberSubtract can still lower to +// Int32Sub in SimplifiedLowering, which requires some magic +// to make sure that SpeculativeNumberSubtract survives to that +// point, especially the JSTypedLowering needs to be unable +// to tell that the inputs to SpeculativeNumberAdd are not +// Number, Undefined, Null or Boolean. +(function() { + // We need a function that has a - with feedback Number or + // NumberOrOddball, but for whose inputs the JSTypedLowering + // cannot reduce it to NumberSubtract (with SpeculativeToNumber + // conversions). We achieve this utilizing an object literal + // indirection here. + function baz(x) { + return {x}.x - x; + } + baz(null); + baz(undefined); + + // Now we just need to truncate the result. + function foo(x) { + return baz(42) | 0; + } + + assertEquals(0, foo()); + assertEquals(0, foo()); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo()); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-toboolean.js b/deps/v8/test/mjsunit/compiler/number-toboolean.js new file mode 100644 index 0000000000..02b30b3ed6 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-toboolean.js @@ -0,0 +1,45 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test that NumberToBoolean properly passes the kIdentifyZeros truncation +// for Signed32 \/ MinusZero inputs. +(function() { + function foo(x) { + if (x * -2) return 1; + return 0; + } + + assertEquals(1, foo(1)); + assertEquals(1, foo(2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(1)); + assertEquals(1, foo(2)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(0, foo(0)); + assertOptimized(foo); +})(); + + +// Test that NumberToBoolean properly passes the kIdentifyZeros truncation +// for Unsigned32 \/ MinusZero inputs. +(function() { + function foo(x) { + x = x | 0; + if (Math.max(x * -2, 0)) return 1; + return 0; + } + + assertEquals(1, foo(-1)); + assertEquals(1, foo(-2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo(-1)); + assertEquals(1, foo(-2)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(0, foo(0)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/number-trunc.js b/deps/v8/test/mjsunit/compiler/number-trunc.js new file mode 100644 index 0000000000..aa7d02c20f --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/number-trunc.js @@ -0,0 +1,22 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test that NumberTrunc propagates kIdentifyZeros truncations. +(function() { + function foo(x) { + return Math.abs(Math.trunc(x * -2)); + } + + assertEquals(2, foo(1)); + assertEquals(4, foo(2)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(2, foo(1)); + assertEquals(4, foo(2)); + assertOptimized(foo); + // Now `foo` should stay optimized even if `x * -2` would produce `-0`. + assertEquals(0, foo(0)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/redundancy-elimination.js b/deps/v8/test/mjsunit/compiler/redundancy-elimination.js new file mode 100644 index 0000000000..1e5185adb7 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/redundancy-elimination.js @@ -0,0 +1,194 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Test the RedundancyElimination::ReduceSpeculativeNumberOperation() +// TurboFan optimization for the case of SpeculativeNumberAdd with +// Number feedback. +(function() { + function bar(i) { + return ++i; + } + bar(0.1); + + function foo(a, i) { + const x = a[i]; + const y = a[bar(i)]; + return x + y; + } + + assertEquals(3, foo([1, 2], 0)); + assertEquals(3, foo([1, 2], 0)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(3, foo([1, 2], 0)); +})(); + +// Test the RedundancyElimination::ReduceSpeculativeNumberOperation() +// TurboFan optimization for the case of SpeculativeNumberAdd with +// NumberOrOddball feedback. +(function() { + function bar(i) { + return ++i; + } + assertEquals(NaN, bar(undefined)); + + function foo(a, i) { + const x = a[i]; + const y = a[bar(i)]; + return x + y; + } + + assertEquals(3, foo([1, 2], 0)); + assertEquals(3, foo([1, 2], 0)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(3, foo([1, 2], 0)); +})(); + +// Test the RedundancyElimination::ReduceSpeculativeNumberOperation() +// TurboFan optimization for the case of SpeculativeNumberSubtract with +// Number feedback. +(function() { + function bar(i) { + return --i; + } + assertEquals(-0.9, bar(0.1)); + + function foo(a, i) { + const x = a[i]; + const y = a[bar(i)]; + return x + y; + } + + assertEquals(3, foo([1, 2], 1)); + assertEquals(3, foo([1, 2], 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(3, foo([1, 2], 1)); +})(); + +// Test the RedundancyElimination::ReduceSpeculativeNumberOperation() +// TurboFan optimization for the case of SpeculativeNumberSubtract with +// NumberOrOddball feedback. +(function() { + function bar(i) { + return --i; + } + assertEquals(NaN, bar(undefined)); + + function foo(a, i) { + const x = a[i]; + const y = a[bar(i)]; + return x + y; + } + + assertEquals(3, foo([1, 2], 1)); + assertEquals(3, foo([1, 2], 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(3, foo([1, 2], 1)); +})(); + +// Test the RedundancyElimination::ReduceSpeculativeNumberOperation() +// TurboFan optimization for the case of SpeculativeToNumber. +(function() { + function foo(a, i) { + const x = a[i]; + const y = i++; + return x + y; + } + + assertEquals(1, foo([1, 2], 0)); + assertEquals(1, foo([1, 2], 0)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo([1, 2], 0)); +})(); + +// Test the RedundancyElimination::ReduceSpeculativeNumberOperation() +// TurboFan optimization for the case of SpeculativeSafeIntegerAdd. +(function() { + function foo(a, i) { + const x = a[i]; + const y = a[++i]; + return x + y; + } + + assertEquals(3, foo([1, 2], 0)); + assertEquals(3, foo([1, 2], 0)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(3, foo([1, 2], 0)); +})(); + +// Test the RedundancyElimination::ReduceSpeculativeNumberOperation() +// TurboFan optimization for the case of SpeculativeSafeIntegerSubtract. +(function() { + function foo(a, i) { + const x = a[i]; + const y = a[--i]; + return x + y; + } + + assertEquals(3, foo([1, 2], 1)); + assertEquals(3, foo([1, 2], 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(3, foo([1, 2], 1)); +})(); + +// Test the RedundancyElimination::ReduceSpeculativeNumberComparison() +// TurboFan optimization for the case of SpeculativeNumberEqual. +(function() { + function foo(a, i) { + const x = a[i]; + if (i === 0) return x; + return i; + } + + assertEquals(1, foo([1, 2], 0)); + assertEquals(1, foo([1, 2], 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo([1, 2], 0)); + assertEquals(1, foo([1, 2], 1)); + // Even passing -0 should not deoptimize and + // of course still pass the equality test above. + assertEquals(9, foo([9, 2], -0)); + assertOptimized(foo); +})(); + +// Test the RedundancyElimination::ReduceSpeculativeNumberComparison() +// TurboFan optimization for the case of SpeculativeNumberLessThan. +(function() { + function foo(a, i) { + const x = a[i]; + if (i < 1) return x; + return i; + } + + assertEquals(1, foo([1, 2], 0)); + assertEquals(1, foo([1, 2], 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo([1, 2], 0)); + assertEquals(1, foo([1, 2], 1)); + // Even passing -0 should not deoptimize and + // of course still pass the equality test above. + assertEquals(9, foo([9, 2], -0)); + assertOptimized(foo); +})(); + +// Test the RedundancyElimination::ReduceSpeculativeNumberComparison() +// TurboFan optimization for the case of SpeculativeNumberLessThanOrEqual. +(function() { + function foo(a, i) { + const x = a[i]; + if (i <= 0) return x; + return i; + } + + assertEquals(1, foo([1, 2], 0)); + assertEquals(1, foo([1, 2], 1)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(1, foo([1, 2], 0)); + assertEquals(1, foo([1, 2], 1)); + // Even passing -0 should not deoptimize and + // of course still pass the equality test above. + assertEquals(9, foo([9, 2], -0)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/regress-7121.js b/deps/v8/test/mjsunit/compiler/regress-7121.js index 98c1a1ac19..bdf3133bb8 100644 --- a/deps/v8/test/mjsunit/compiler/regress-7121.js +++ b/deps/v8/test/mjsunit/compiler/regress-7121.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --harmony-bigint +// Flags: --allow-natives-syntax function foo() { %_ToLength(42n) } assertThrows(foo, TypeError); diff --git a/deps/v8/test/mjsunit/compiler/regress-884052.js b/deps/v8/test/mjsunit/compiler/regress-884052.js new file mode 100644 index 0000000000..babfcc3cea --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/regress-884052.js @@ -0,0 +1,16 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +function foo() { + var a = new Array(2); + for (var i = 1; i > -1; i = i - 2) { + if (i < a.length) a = new Array(i); + } +} + +foo(); +%OptimizeFunctionOnNextCall(foo); +foo(); diff --git a/deps/v8/test/mjsunit/compiler/regress-890057.js b/deps/v8/test/mjsunit/compiler/regress-890057.js new file mode 100644 index 0000000000..655c4431e9 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/regress-890057.js @@ -0,0 +1,16 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +function f() {} +function g() { + f.prototype = undefined; + f(); + new f(); +} + +// Do not use %OptimizeFunctionOnNextCall here, this particular bug needs +// to trigger truly concurrent compilation. +for (let i = 0; i < 10000; i++) g(); diff --git a/deps/v8/test/mjsunit/compiler/regress-890620.js b/deps/v8/test/mjsunit/compiler/regress-890620.js new file mode 100644 index 0000000000..f5fc7f4f65 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/regress-890620.js @@ -0,0 +1,25 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +var a = 42; + +function g(n) { + while (n > 0) { + a = new Array(n); + n--; + } +} + +g(1); + +function f() { + g(); +} + +f(); +%OptimizeFunctionOnNextCall(f); +f(); +assertEquals(1, a.length); diff --git a/deps/v8/test/mjsunit/compiler/regress-895799.js b/deps/v8/test/mjsunit/compiler/regress-895799.js new file mode 100644 index 0000000000..4305b7427b --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/regress-895799.js @@ -0,0 +1,26 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +class C extends Object { + constructor() { + try { super(); } catch (e) { }; + return 1; + } +} + +class A extends C { + constructor() { + super(); + throw new Error(); + return { get: () => this }; + } +} + +var D = new Proxy(A, { get() { %DeoptimizeFunction(A); } }); + +try { Reflect.construct(A, [], D); } catch(e) {} +%OptimizeFunctionOnNextCall(A); +try { Reflect.construct(A, [], D); } catch(e) {} diff --git a/deps/v8/test/mjsunit/compiler/strict-equal-symbol.js b/deps/v8/test/mjsunit/compiler/strict-equal-symbol.js new file mode 100644 index 0000000000..aee1ecfa60 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/strict-equal-symbol.js @@ -0,0 +1,50 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Known symbols strict equality. +(function() { + const a = Symbol("a"); + const b = Symbol("b"); + + function foo() { return a === b; } + + assertFalse(foo()); + assertFalse(foo()); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo()); +})(); + +// Known symbol on one side strict equality. +(function() { + const a = Symbol("a"); + const b = Symbol("b"); + + function foo(a) { return a === b; } + + assertTrue(foo(b)); + assertFalse(foo(a)); + assertTrue(foo(b)); + assertFalse(foo(a)); + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo(b)); + assertFalse(foo(a)); +})(); + +// Feedback based symbol strict equality. +(function() { + const a = Symbol("a"); + const b = Symbol("b"); + + function foo(a, b) { return a === b; } + + assertTrue(foo(b, b)); + assertFalse(foo(a, b)); + assertTrue(foo(a, a)); + assertFalse(foo(b, a)); + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo(a, a)); + assertFalse(foo(b, a)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/string-add-try-catch.js b/deps/v8/test/mjsunit/compiler/string-add-try-catch.js index d7a3d2583c..5ae5b00d18 100644 --- a/deps/v8/test/mjsunit/compiler/string-add-try-catch.js +++ b/deps/v8/test/mjsunit/compiler/string-add-try-catch.js @@ -4,6 +4,9 @@ // Flags: --allow-natives-syntax +// Test that string concatenation overflow (going over string max length) +// is handled gracefully, i.e. an error is thrown + var a = "a".repeat(%StringMaxLength()); (function() { @@ -37,3 +40,57 @@ var a = "a".repeat(%StringMaxLength()); foo("a"); assertInstanceof(foo(a), RangeError); })(); + +(function() { + function foo(a, b) { + try { + return "0123456789012".concat(a); + } catch (e) { + return e; + } + } + + foo("a"); + foo("a"); + %OptimizeFunctionOnNextCall(foo); + foo("a"); + assertInstanceof(foo(a), RangeError); +})(); + +var obj = { + toString: function() { + throw new Error('toString has thrown'); + } +}; + +(function() { + function foo(a, b) { + try { + return "0123456789012" + obj; + } catch (e) { + return e; + } + } + + foo("a"); + foo("a"); + %OptimizeFunctionOnNextCall(foo); + foo("a"); + assertInstanceof(foo(a), Error); +})(); + +(function() { + function foo(a, b) { + try { + return a + 123; + } catch (e) { + return e; + } + } + + foo("a"); + foo("a"); + %OptimizeFunctionOnNextCall(foo); + foo("a"); + assertInstanceof(foo(a), RangeError); +})(); diff --git a/deps/v8/test/mjsunit/compiler/string-from-code-point.js b/deps/v8/test/mjsunit/compiler/string-from-code-point.js new file mode 100644 index 0000000000..165ea0c234 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/string-from-code-point.js @@ -0,0 +1,32 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt --noalways-opt + +// Test that String.fromCodePoint() properly identifies zeros. +(function() { + function foo(x) { + return String.fromCodePoint(x); + } + + assertEquals("\u0000", foo(0)); + assertEquals("\u0000", foo(-0)); + %OptimizeFunctionOnNextCall(foo); + assertEquals("\u0000", foo(0)); + assertEquals("\u0000", foo(-0)); + assertOptimized(foo); + + // Now passing anything outside the valid code point + // range should invalidate the optimized code. + assertThrows(_ => foo(-1)); + assertUnoptimized(foo); + + // And TurboFan should not inline the builtin anymore + // from now on (aka no deoptimization loop). + %OptimizeFunctionOnNextCall(foo); + assertEquals("\u0000", foo(0)); + assertEquals("\u0000", foo(-0)); + assertThrows(_ => foo(-1)); + assertOptimized(foo); +})(); diff --git a/deps/v8/test/mjsunit/compiler/typed-array-constructor.js b/deps/v8/test/mjsunit/compiler/typed-array-constructor.js index a785eadf37..07d6a7ca4e 100644 --- a/deps/v8/test/mjsunit/compiler/typed-array-constructor.js +++ b/deps/v8/test/mjsunit/compiler/typed-array-constructor.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --harmony-bigint +// Flags: --allow-natives-syntax const limit = %MaxSmi() + 1; diff --git a/deps/v8/test/mjsunit/regress/regress-splice-large-index.js b/deps/v8/test/mjsunit/d8/d8-worker-script.js index 1f4eb9ce59..7c5d595b2b 100644 --- a/deps/v8/test/mjsunit/regress/regress-splice-large-index.js +++ b/deps/v8/test/mjsunit/d8/d8-worker-script.js @@ -1,4 +1,4 @@ -// Copyright 2013 the V8 project authors. All rights reserved. +// Copyright 2015 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: @@ -25,17 +25,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -var a = []; -a[0xfffffffe] = 10; -assertThrows("a.unshift(1);", RangeError); -assertEquals(0xffffffff, a.length); -assertEquals(10, a[0xffffffff]); -assertEquals(0xffffffff, a.length); -assertEquals(undefined, a[0xfffffffe]); +// Verify that the Worker constrcutor by default treats its first argument +// as the filename of a script load and run. -a = [1,2,3]; -a[0xfffffffe] = 10; -assertThrows("a.splice(1,1,7,7,7,7,7);", RangeError); -assertEquals([1,7,7,7,7,7,3], a.slice(0, 7)); -assertEquals(0xffffffff, a.length); -assertEquals(10, a[0xfffffffe + 5 - 1]); +// Resources: test/mjsunit/d8/d8-worker-script.txt + +if (this.Worker) { + var w = new Worker('test/mjsunit/d8/d8-worker-script.txt'); + assertEquals("Starting worker", w.getMessage()); + w.postMessage(""); + assertEquals("DONE", w.getMessage()); + w.terminate(); +} diff --git a/deps/v8/test/mjsunit/d8/d8-worker-script.txt b/deps/v8/test/mjsunit/d8/d8-worker-script.txt new file mode 100644 index 0000000000..9254cea4f4 --- /dev/null +++ b/deps/v8/test/mjsunit/d8/d8-worker-script.txt @@ -0,0 +1,8 @@ +// Worker script used by d8-worker-script.js. +// This file is named `.txt` to prevent it being treated as a test itself. + +onmessage = function(m) { + postMessage('DONE'); +} + +postMessage('Starting worker'); diff --git a/deps/v8/test/mjsunit/d8/d8-worker-sharedarraybuffer.js b/deps/v8/test/mjsunit/d8/d8-worker-sharedarraybuffer.js index 0a15413ea3..f166ca2eb1 100644 --- a/deps/v8/test/mjsunit/d8/d8-worker-sharedarraybuffer.js +++ b/deps/v8/test/mjsunit/d8/d8-worker-sharedarraybuffer.js @@ -45,7 +45,7 @@ if (this.Worker) { Atomics.store(ta, 0, 100); };`; - var w = new Worker(workerScript); + var w = new Worker(workerScript, {type: 'string'}); var sab = new SharedArrayBuffer(16); var ta = new Uint32Array(sab); @@ -84,7 +84,7 @@ if (this.Worker) { var id; var workers = []; for (id = 0; id < 4; ++id) { - workers[id] = new Worker(workerScript); + workers[id] = new Worker(workerScript, {type: 'string'}); workers[id].postMessage({sab: sab, id: id}); } diff --git a/deps/v8/test/mjsunit/d8/d8-worker-spawn-worker.js b/deps/v8/test/mjsunit/d8/d8-worker-spawn-worker.js index a114d8587e..621ec253bc 100644 --- a/deps/v8/test/mjsunit/d8/d8-worker-spawn-worker.js +++ b/deps/v8/test/mjsunit/d8/d8-worker-spawn-worker.js @@ -27,14 +27,14 @@ if (this.Worker) { var workerScript = - `var w = new Worker('postMessage(42)'); + `var w = new Worker('postMessage(42)', {type: 'string'}); onmessage = function(parentMsg) { w.postMessage(parentMsg); var childMsg = w.getMessage(); postMessage(childMsg); };`; - var w = new Worker(workerScript); + var w = new Worker(workerScript, {type: 'string'}); w.postMessage(9); assertEquals(42, w.getMessage()); } diff --git a/deps/v8/test/mjsunit/d8/d8-worker.js b/deps/v8/test/mjsunit/d8/d8-worker.js index a73d7b1706..afc03f5c8b 100644 --- a/deps/v8/test/mjsunit/d8/d8-worker.js +++ b/deps/v8/test/mjsunit/d8/d8-worker.js @@ -97,7 +97,21 @@ if (this.Worker) { return ab; } - var w = new Worker(workerScript); + assertThrows(function() { + // Second arg must be 'options' object + new Worker(workerScript, 123); + }); + + assertThrows(function() { + new Worker('test/mjsunit/d8/d8-worker.js', {type: 'invalid'}); + }); + + assertThrows(function() { + // worker type defaults to 'classic' which tries to load from file + new Worker(workerScript); + }); + + var w = new Worker(workerScript, {type: 'string'}); assertEquals("Starting worker", w.getMessage()); @@ -140,6 +154,12 @@ if (this.Worker) { w.postMessage(ab2, [ab2]); assertEquals(0, ab2.byteLength); // ArrayBuffer should be neutered. + // Attempting to transfer the same ArrayBuffer twice should throw. + assertThrows(function() { + var ab3 = createArrayBuffer(4); + w.postMessage(ab3, [ab3, ab3]); + }); + assertEquals("undefined", typeof foo); // Read a message from the worker. @@ -150,7 +170,7 @@ if (this.Worker) { // Make sure that the main thread doesn't block forever in getMessage() if // the worker dies without posting a message. - var w2 = new Worker(''); + var w2 = new Worker('', {type: 'string'}); var msg = w2.getMessage(); assertEquals(undefined, msg); } diff --git a/deps/v8/test/mjsunit/es6/array-spread-holey.js b/deps/v8/test/mjsunit/es6/array-spread-holey.js new file mode 100644 index 0000000000..7d95e51b29 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/array-spread-holey.js @@ -0,0 +1,52 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Test spreading of holey arrays. Holes should be replaced with undefined. + +var a = [, 2]; + +assertEquals([, 2], [...a]); +assertTrue([...a].hasOwnProperty(0)); +assertTrue([2, ...a].hasOwnProperty(1)); + + +class MyArray1 extends Array { + constructor(a) { + super(...a); + } +} +var myarr1 = new MyArray1(a); +assertEquals(undefined, myarr1[0]); +assertTrue(myarr1.hasOwnProperty(0)); + + +class MyArray2 extends Array { + constructor(a) { + super(2, ...a); + } +} +var myarr2 = new MyArray2(a); +assertEquals(undefined, myarr2[1]); +assertTrue(myarr2.hasOwnProperty(1)); + +function foo0() { return arguments.hasOwnProperty(0); } +assertTrue(foo0(...a)); + +function foo1() { return arguments.hasOwnProperty(1); } +assertTrue(foo1(2, ...a)); + +// This test pollutes the Array prototype. No more tests should be run in the +// same instance after this. +a.__proto__[0] = 1; +var arr2 = [...a]; +assertEquals([1,2], arr2); +assertTrue(arr2.hasOwnProperty(0)); + +myarr1 = new MyArray1(a); +assertEquals(1, myarr1[0]); +assertTrue(myarr1.hasOwnProperty(0)); + +var myarr2 = new MyArray2(a); +assertEquals(1, myarr2[1]); +assertTrue(myarr2.hasOwnProperty(1)); diff --git a/deps/v8/test/mjsunit/es6/proxy-function-tostring.js b/deps/v8/test/mjsunit/es6/proxy-function-tostring.js index d859822df0..e151bf65b1 100644 --- a/deps/v8/test/mjsunit/es6/proxy-function-tostring.js +++ b/deps/v8/test/mjsunit/es6/proxy-function-tostring.js @@ -1,7 +1,6 @@ // Copyright 2018 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// -// Flags: --noharmony-function-tostring -assertThrows(() => new Proxy(function() {}, {}).toString(), TypeError); +assertEquals(new Proxy(function() {}, {}).toString(), + 'function () { [native code] }'); diff --git a/deps/v8/test/mjsunit/es6/string-iterator2.js b/deps/v8/test/mjsunit/es6/string-iterator2.js new file mode 100644 index 0000000000..6bfd51a815 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/string-iterator2.js @@ -0,0 +1,26 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --no-stress-opt + +// Tests for spreading primitive strings. + +assertEquals([...''], []); + +var str = 'ott'; +assertEquals(['o', 't', 't'], [...str]); +assertTrue(%StringIteratorProtector()); + +str[Symbol.iterator] = {}; +// Symbol.iterator can't be set on primitive strings, so it shouldn't invalidate +// the protector. +assertTrue(%StringIteratorProtector()); + +// This changes the String Iterator prototype. No more tests should be run after +// this in the same instance. +var iterator = str[Symbol.iterator](); +iterator.__proto__.next = () => ({value : undefined, done : true}); + +assertFalse(%StringIteratorProtector()); +assertEquals([], [...str]); diff --git a/deps/v8/test/mjsunit/es6/string-iterator3.js b/deps/v8/test/mjsunit/es6/string-iterator3.js new file mode 100644 index 0000000000..1b0e0273e5 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/string-iterator3.js @@ -0,0 +1,20 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --no-stress-opt + +// Tests for primitive strings. + +var str = 'ott'; +assertTrue(%StringIteratorProtector()); +assertEquals(['o', 't', 't'], [...str]); + +// This changes the String prototype. No more tests should be run after this in +// the same instance. +str.__proto__[Symbol.iterator] = + function() { + return {next : () => ({value : undefined, done : true})}; + }; +assertFalse(%StringIteratorProtector()); +assertEquals([], [...str]); diff --git a/deps/v8/test/mjsunit/es6/string-iterator4.js b/deps/v8/test/mjsunit/es6/string-iterator4.js new file mode 100644 index 0000000000..48c6521d3b --- /dev/null +++ b/deps/v8/test/mjsunit/es6/string-iterator4.js @@ -0,0 +1,30 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --no-stress-opt + +// Tests for wrapped strings. + +var str = new String('ott'); +assertTrue(%StringIteratorProtector()); +assertEquals(['o', 't', 't'], [...str]); + +function iterator_fn() { + return {next : () => ({value : undefined, done : true})}; +}; + +str[Symbol.iterator] = iterator_fn; +// This shouldn't invalidate the protector, because it doesn't support String +// objects. +assertTrue(%StringIteratorProtector()); +assertEquals([], [...str]); + + +var str2 = new String('ott'); +assertEquals(['o', 't', 't'], [...str2]); +// This changes the String prototype. No more tests should be run after this in +// the same instance. +str2.__proto__[Symbol.iterator] = iterator_fn; +assertFalse(%StringIteratorProtector()); +assertEquals([], [...str2]); diff --git a/deps/v8/test/mjsunit/es6/string-iterator5.js b/deps/v8/test/mjsunit/es6/string-iterator5.js new file mode 100644 index 0000000000..ec9754a4bd --- /dev/null +++ b/deps/v8/test/mjsunit/es6/string-iterator5.js @@ -0,0 +1,15 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Tests for primitive strings. + +var iterator = 'ott'[Symbol.iterator](); + +// These modifications shouldn't invalidate the String iterator protector. +iterator.__proto__.fonts = {}; +assertTrue(%StringIteratorProtector()); +iterator.__proto__[0] = 0; +assertTrue(%StringIteratorProtector()); diff --git a/deps/v8/test/mjsunit/es6/string-iterator6.js b/deps/v8/test/mjsunit/es6/string-iterator6.js new file mode 100644 index 0000000000..d1cd1f31eb --- /dev/null +++ b/deps/v8/test/mjsunit/es6/string-iterator6.js @@ -0,0 +1,11 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --no-stress-opt + +assertTrue(%StringIteratorProtector()); + +delete 'ott'.__proto__[Symbol.iterator]; + +assertFalse(%StringIteratorProtector()); diff --git a/deps/v8/test/mjsunit/es6/string-iterator7.js b/deps/v8/test/mjsunit/es6/string-iterator7.js new file mode 100644 index 0000000000..387c6e81fc --- /dev/null +++ b/deps/v8/test/mjsunit/es6/string-iterator7.js @@ -0,0 +1,13 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +assertTrue(%StringIteratorProtector()); + +const p = ""[Symbol.iterator]().__proto__; +let x = Object.create(p); +x.next = 42; + +assertTrue(%StringIteratorProtector()); diff --git a/deps/v8/test/mjsunit/es6/string-iterator8.js b/deps/v8/test/mjsunit/es6/string-iterator8.js new file mode 100644 index 0000000000..dbd4b7c46a --- /dev/null +++ b/deps/v8/test/mjsunit/es6/string-iterator8.js @@ -0,0 +1,14 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +assertTrue(%StringIteratorProtector()); + +var proto = String.prototype; + +String.prototype = {}; + +assertEquals(proto, String.prototype); +assertTrue(%StringIteratorProtector()); diff --git a/deps/v8/test/mjsunit/es6/typedarray-construct-by-array-like.js b/deps/v8/test/mjsunit/es6/typedarray-construct-by-array-like.js index 3b57f8f644..0a55fccf5c 100644 --- a/deps/v8/test/mjsunit/es6/typedarray-construct-by-array-like.js +++ b/deps/v8/test/mjsunit/es6/typedarray-construct-by-array-like.js @@ -212,7 +212,7 @@ tests.push(function TestFromTypedArraySpeciesNeutersBuffer(constr) { }); tests.push(function TestLengthIsMaxSmi(constr) { - var myObject = { 0: 5, 1: 6, length: %_MaxSmi() + 1 }; + var myObject = { 0: 5, 1: 6, length: %MaxSmi() + 1 }; assertThrows(function() { new constr(myObject); @@ -258,7 +258,7 @@ tests.push(function TestOffsetIsUsed(constr) { }); tests.push(function TestLengthIsNonSmiNegativeNumber(constr) { - var ta = new constr({length: -%_MaxSmi() - 2}); + var ta = new constr({length: -%MaxSmi() - 2}); assertEquals(0, ta.length); }); diff --git a/deps/v8/test/mjsunit/es6/typedarray-construct-offset-not-smi.js b/deps/v8/test/mjsunit/es6/typedarray-construct-offset-not-smi.js index 0a267bc64b..e6cbcc4201 100644 --- a/deps/v8/test/mjsunit/es6/typedarray-construct-offset-not-smi.js +++ b/deps/v8/test/mjsunit/es6/typedarray-construct-offset-not-smi.js @@ -5,7 +5,7 @@ // Flags: --allow-natives-syntax --mock-arraybuffer-allocator (function TestBufferByteLengthNonSmi() { - var non_smi_byte_length = %_MaxSmi() + 1; + var non_smi_byte_length = %MaxSmi() + 1; var buffer = new ArrayBuffer(non_smi_byte_length); @@ -20,7 +20,7 @@ })(); (function TestByteOffsetNonSmi() { - var non_smi_byte_length = %_MaxSmi() + 11; + var non_smi_byte_length = %MaxSmi() + 11; var buffer = new ArrayBuffer(non_smi_byte_length); diff --git a/deps/v8/test/mjsunit/es6/typedarray-set-bytelength-not-smi.js b/deps/v8/test/mjsunit/es6/typedarray-set-bytelength-not-smi.js index 1f842878dc..e4a8c2b626 100644 --- a/deps/v8/test/mjsunit/es6/typedarray-set-bytelength-not-smi.js +++ b/deps/v8/test/mjsunit/es6/typedarray-set-bytelength-not-smi.js @@ -5,13 +5,13 @@ // Flags: --allow-natives-syntax --mock-arraybuffer-allocator (function TestBufferByteLengthNonSmi() { - const source_buffer_length = %_MaxSmi() + 1; + const source_buffer_length = %MaxSmi() + 1; const source_buffer = new ArrayBuffer(source_buffer_length); const source = new Uint16Array(source_buffer); assertEquals(source_buffer_length, source_buffer.byteLength); assertEquals(source_buffer_length / 2, source.length); - const target_buffer_length = %_MaxSmi() - 1; + const target_buffer_length = %MaxSmi() - 1; const target_buffer = new ArrayBuffer(target_buffer_length); const target = new Uint16Array(target_buffer); assertEquals(target_buffer_length, target_buffer.byteLength); diff --git a/deps/v8/test/mjsunit/es9/object-spread-ic-dontenum-transition.js b/deps/v8/test/mjsunit/es9/object-spread-ic-dontenum-transition.js new file mode 100644 index 0000000000..c403566a38 --- /dev/null +++ b/deps/v8/test/mjsunit/es9/object-spread-ic-dontenum-transition.js @@ -0,0 +1,26 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +(function testMegamorphicWithDontEnumTransition() { + function spread(o) { return { ...o }; } + + // Set up transition tree + let obj = { ...{}, a: 0, b: 1, c: 2, }; + Object.defineProperty(obj, "boom", { enumerable: false, configurable: true, + writable: true }); + + // make CloneObjectIC MEGAMORPHIC + spread(new Proxy({}, {})); + + // Ensure we don't crash, and create the correct object + let result = spread({ a: 0, b: 1, c: 2, boom: 3 }); + + assertEquals({ a: 0, b: 1, c: 2, boom: 3 }, result); + assertEquals({ + enumerable: true, + writable: true, + configurable: true, + value: 3, + }, Object.getOwnPropertyDescriptor(result, "boom")); +})(); diff --git a/deps/v8/test/mjsunit/es9/object-spread-ic-multiple-transitions.js b/deps/v8/test/mjsunit/es9/object-spread-ic-multiple-transitions.js new file mode 100644 index 0000000000..f31a6d90d6 --- /dev/null +++ b/deps/v8/test/mjsunit/es9/object-spread-ic-multiple-transitions.js @@ -0,0 +1,16 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +(function testMegamorphicWithNonSimpleTransitionHandler() { + function spread(o) { return { ...o }; } + + // Set up transition tree + let obj = { ...{}, a: 0, b: 1, boom: 2}; + + // make CloneObjectIC MEGAMORPHIC + spread(new Proxy({}, {})); + + // Ensure we don't crash, and create the correct object + assertEquals({ a: 0, b: 1, c: 2 }, spread({ a: 0, b: 1, c: 2 })); +})(); diff --git a/deps/v8/test/mjsunit/external-backing-store-gc.js b/deps/v8/test/mjsunit/external-backing-store-gc.js new file mode 100644 index 0000000000..005ec15e59 --- /dev/null +++ b/deps/v8/test/mjsunit/external-backing-store-gc.js @@ -0,0 +1,13 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --mock-arraybuffer-allocator --mock-arraybuffer-allocator-limit=1300000000 + +// --mock-arraybuffer-allocator-limit should be above the hard limit external +// for memory. Below that limit anything is opportunistic and may be delayed, +// e.g., by tasks getting stalled and the event loop not being invoked. + +for (var i = 0; i < 1536; i++) { + let garbage = new ArrayBuffer(1024*1024); +} diff --git a/deps/v8/test/mjsunit/for-in-special-cases.js b/deps/v8/test/mjsunit/for-in-special-cases.js index b592ad259e..27129e1aac 100644 --- a/deps/v8/test/mjsunit/for-in-special-cases.js +++ b/deps/v8/test/mjsunit/for-in-special-cases.js @@ -64,21 +64,15 @@ assertEquals(10, j); function Accumulate(x) { - var accumulator = ""; + var accumulator = []; for (var i in x) { - accumulator += i; + accumulator.push(i); } return accumulator; } for (var i = 0; i < 3; ++i) { - var elements = Accumulate("abcd"); - // We do not assume that for-in enumerates elements in order. - assertTrue(-1 != elements.indexOf("0")); - assertTrue(-1 != elements.indexOf("1")); - assertTrue(-1 != elements.indexOf("2")); - assertTrue(-1 != elements.indexOf("3")); - assertEquals(4, elements.length); + assertEquals(Accumulate("abcd"), ['0', '1', '2', '3']); } function for_in_string_prototype() { @@ -99,23 +93,51 @@ function for_in_string_prototype() { // If for-in returns elements in a different order on multiple calls, this // assert will fail. If that happens, consider if that behavior is OK. assertEquals(elements, elements1, "For-in elements not the same both times."); - // We do not assume that for-in enumerates elements in order. - assertTrue(-1 != elements.indexOf("0")); - assertTrue(-1 != elements.indexOf("1")); - assertTrue(-1 != elements.indexOf("2")); - assertTrue(-1 != elements.indexOf("7")); - assertTrue(-1 != elements.indexOf("foo")); - assertTrue(-1 != elements.indexOf("bar")); - assertTrue(-1 != elements.indexOf("gub")); - assertEquals(13, elements.length); - - elements = Accumulate(x); - assertTrue(-1 != elements.indexOf("0")); - assertTrue(-1 != elements.indexOf("1")); - assertTrue(-1 != elements.indexOf("2")); - assertTrue(-1 != elements.indexOf("foo")); - assertEquals(6, elements.length); + assertEquals(["7","bar","gub","0","1","2","foo"], elements) + + assertEquals(['0', '1', '2', 'foo'], Accumulate(x)) } for_in_string_prototype(); for_in_string_prototype(); + + +(function for_in_dictionary_prototype_1() { + let prototype1 = {prop: 0, prop1: 1}; + let derived1 = Object.create(null, { + prop: {enumerable: false, configurable: true, value: 0}, + }); + Object.setPrototypeOf(derived1, prototype1); + + let prototype2 = {prop: 0, prop1: 1}; + let derived2 = Object.create(prototype2, { + prop: {enumerable: false, configurable: true, value: 0}, + }); + + for (let i = 0; i < 3; i++) { + assertEquals(['prop1'], Accumulate(derived1)); + assertEquals(['prop1'], Accumulate(derived2)); + } +})(); + +(function for_in_dictionary_prototype_2() { + let prototype1 = {prop: 0, prop1: 1}; + let derived1 = Object.create(null, { + prop: {enumerable: false, configurable: true, value: 1}, + prop2: {enumerable: true, configurable: true, value: 2}, + prop3: {enumerable: false, configurable: true, value: 3}, + }); + Object.setPrototypeOf(derived1, prototype1); + + let prototype2 = {prop: 0, prop1: 1}; + let derived2 = Object.create(prototype2, { + prop: {enumerable: false, configurable: true, value: 0}, + prop2: {enumerable: true, configurable: true, value: 2}, + prop3: {enumerable: false, configurable: true, value: 3}, + }); + + for (let i = 0; i < 3; i++) { + assertEquals(['prop2', 'prop1'], Accumulate(derived1)); + assertEquals(['prop2', 'prop1'], Accumulate(derived2)); + } +})(); diff --git a/deps/v8/test/mjsunit/harmony/async-await-optimization.js b/deps/v8/test/mjsunit/harmony/async-await-optimization.js new file mode 100644 index 0000000000..b24e541916 --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/async-await-optimization.js @@ -0,0 +1,124 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --harmony-await-optimization + +// test basic interleaving +(function () { + const actual = []; + const expected = [ 'await', 1, 'await', 2 ]; + const iterations = 2; + + async function pushAwait() { + actual.push('await'); + } + + async function callAsync() { + for (let i = 0; i < iterations; i++) { + await pushAwait(); + } + return 0; + } + + function checkAssertions() { + assertArrayEquals(expected, actual, + 'Async/await and promises should be interleaved.'); + } + + assertPromiseResult((async() => { + callAsync(); + + return new Promise(function (resolve) { + actual.push(1); + resolve(); + }).then(function () { + actual.push(2); + }).then(checkAssertions); + })()); +})(); + +// test async generators +(function () { + const actual = []; + const expected = [ 'await', 1, 'await', 2 ]; + const iterations = 2; + + async function pushAwait() { + actual.push('await'); + } + + async function* callAsync() { + for (let i = 0; i < iterations; i++) { + await pushAwait(); + } + return 0; + } + + function checkAssertions() { + assertArrayEquals(expected, actual, + 'Async/await and promises should be interleaved when using async generators.'); + } + + assertPromiseResult((async() => { + callAsync().next(); + + return new Promise(function (resolve) { + actual.push(1); + resolve(); + }).then(function () { + actual.push(2); + }).then(checkAssertions); + })()); +})(); + +// test yielding from async generators +(function () { + const actual = []; + const expected = [ + 'Promise: 6', + 'Promise: 5', + 'Await: 3', + 'Promise: 4', + 'Promise: 3', + 'Await: 2', + 'Promise: 2', + 'Promise: 1', + 'Await: 1', + 'Promise: 0' + ]; + const iterations = 3; + + async function* naturalNumbers(start) { + let current = start; + while (current > 0) { + yield Promise.resolve(current--); + } + } + + async function trigger() { + for await (const num of naturalNumbers(iterations)) { + actual.push('Await: ' + num); + } + } + + async function checkAssertions() { + assertArrayEquals(expected, actual, + 'Async/await and promises should be interleaved when yielding.'); + } + + async function countdown(counter) { + actual.push('Promise: ' + counter); + if (counter > 0) { + return Promise.resolve(counter - 1).then(countdown); + } else { + await checkAssertions(); + } + } + + assertPromiseResult((async() => { + trigger(); + + return countdown(iterations * 2); + })()); +})(); diff --git a/deps/v8/test/mjsunit/harmony/atomics-notify.js b/deps/v8/test/mjsunit/harmony/atomics-notify.js new file mode 100644 index 0000000000..cf18321786 --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/atomics-notify.js @@ -0,0 +1,8 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Flags: --allow-natives-syntax --harmony-sharedarraybuffer + +// This test needs to be killed if we remove Atomics.wake. +assertNotSame(Atomics.wake, Atomics.notify); diff --git a/deps/v8/test/mjsunit/harmony/atomics-value-check.js b/deps/v8/test/mjsunit/harmony/atomics-value-check.js index b953863daf..053bc6dfc5 100644 --- a/deps/v8/test/mjsunit/harmony/atomics-value-check.js +++ b/deps/v8/test/mjsunit/harmony/atomics-value-check.js @@ -12,7 +12,7 @@ var workerScript = `onmessage=function(msg) { postMessage(0); };`; -var worker = new Worker(workerScript); +var worker = new Worker(workerScript, {type: 'string'}); var value_obj = { valueOf: function() {worker.postMessage({sab:sab}, [sta.buffer]); diff --git a/deps/v8/test/mjsunit/harmony/bigint/add.js b/deps/v8/test/mjsunit/harmony/bigint/add.js index 5e986b3726..791db6a3b9 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/add.js +++ b/deps/v8/test/mjsunit/harmony/bigint/add.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: -0xc4043e2c4cc49e4d6870103ce7c2ff2d512bf4b1b67553ba410db514ee0af8888ad6cfn, b: 0x2aae86de73ff479133a657a40d26e8dcf192019c7421836615ec34978bad93n, diff --git a/deps/v8/test/mjsunit/harmony/bigint/and.js b/deps/v8/test/mjsunit/harmony/bigint/and.js index 7a68f8b3dc..a90ec22f51 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/and.js +++ b/deps/v8/test/mjsunit/harmony/bigint/and.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: 0x9252b94f220ded0c18706998886397699c5a25527575dn, b: -0x286817ba2e8fd8n, diff --git a/deps/v8/test/mjsunit/harmony/bigint/as-int-n.js b/deps/v8/test/mjsunit/harmony/bigint/as-int-n.js index 51b5073d24..154a0929e5 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/as-int-n.js +++ b/deps/v8/test/mjsunit/harmony/bigint/as-int-n.js @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --harmony-bigint - // BigInt.asIntN { assertEquals(2, BigInt.asIntN.length); diff --git a/deps/v8/test/mjsunit/harmony/bigint/basics.js b/deps/v8/test/mjsunit/harmony/bigint/basics.js index b6318d5324..0368c69b52 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/basics.js +++ b/deps/v8/test/mjsunit/harmony/bigint/basics.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --harmony-bigint +// Flags: --allow-natives-syntax 'use strict' diff --git a/deps/v8/test/mjsunit/harmony/bigint/comparisons.js b/deps/v8/test/mjsunit/harmony/bigint/comparisons.js index 73eb24d687..abc7a8082a 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/comparisons.js +++ b/deps/v8/test/mjsunit/harmony/bigint/comparisons.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --harmony-bigint +// Flags: --allow-natives-syntax 'use strict' @@ -297,18 +297,6 @@ const six = BigInt(6); assertTrue(Reflect.defineProperty(obj, 'foo', {value: zero})); assertTrue(Reflect.defineProperty(obj, 'foo', {value: another_zero})); assertFalse(Reflect.defineProperty(obj, 'foo', {value: one})); -}{ - assertTrue(%SameValue(zero, zero)); - assertTrue(%SameValue(zero, another_zero)); - - assertFalse(%SameValue(zero, +0)); - assertFalse(%SameValue(zero, -0)); - - assertFalse(%SameValue(+0, zero)); - assertFalse(%SameValue(-0, zero)); - - assertTrue(%SameValue(one, one)); - assertTrue(%SameValue(one, another_one)); } // SameValueZero @@ -351,18 +339,6 @@ const six = BigInt(6); assertTrue(new Map([[one, 42]]).has(one)); assertTrue(new Map([[one, 42]]).has(another_one)); -}{ - assertTrue(%SameValueZero(zero, zero)); - assertTrue(%SameValueZero(zero, another_zero)); - - assertFalse(%SameValueZero(zero, +0)); - assertFalse(%SameValueZero(zero, -0)); - - assertFalse(%SameValueZero(+0, zero)); - assertFalse(%SameValueZero(-0, zero)); - - assertTrue(%SameValueZero(one, one)); - assertTrue(%SameValueZero(one, another_one)); } // Abstract comparison diff --git a/deps/v8/test/mjsunit/harmony/bigint/dataview.js b/deps/v8/test/mjsunit/harmony/bigint/dataview.js index 5ead649909..bad56d2b69 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/dataview.js +++ b/deps/v8/test/mjsunit/harmony/bigint/dataview.js @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --harmony-bigint - var buffer = new ArrayBuffer(64); var dataview = new DataView(buffer, 8, 24); var bytes = new Uint8Array(buffer); diff --git a/deps/v8/test/mjsunit/harmony/bigint/dec.js b/deps/v8/test/mjsunit/harmony/bigint/dec.js index ddb0431cba..36ca2193de 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/dec.js +++ b/deps/v8/test/mjsunit/harmony/bigint/dec.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: 0x26ffcdbd233a53e7ca4612f2b02e1f2c1d885c3177e7n, r: 0x26ffcdbd233a53e7ca4612f2b02e1f2c1d885c3177e6n diff --git a/deps/v8/test/mjsunit/harmony/bigint/div.js b/deps/v8/test/mjsunit/harmony/bigint/div.js index 1eeea1184f..8b167140de 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/div.js +++ b/deps/v8/test/mjsunit/harmony/bigint/div.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: -0x1e0f357314bac34227333c0c2086430dae88cb538f161174888591n, b: 0x390n, diff --git a/deps/v8/test/mjsunit/harmony/bigint/exp.js b/deps/v8/test/mjsunit/harmony/bigint/exp.js index 54d5849373..7fbc2dc402 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/exp.js +++ b/deps/v8/test/mjsunit/harmony/bigint/exp.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --harmony-bigint +// Flags: --allow-natives-syntax assertEquals(1n, (-1n) ** 0n); assertEquals(-1n, (-1n) ** 1n); diff --git a/deps/v8/test/mjsunit/harmony/bigint/inc.js b/deps/v8/test/mjsunit/harmony/bigint/inc.js index 4ead89e1bf..7842600393 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/inc.js +++ b/deps/v8/test/mjsunit/harmony/bigint/inc.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: 0xb3df90n, r: 0xb3df91n diff --git a/deps/v8/test/mjsunit/harmony/bigint/json.js b/deps/v8/test/mjsunit/harmony/bigint/json.js index eb0eefc4bb..cf392234c5 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/json.js +++ b/deps/v8/test/mjsunit/harmony/bigint/json.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --harmony-bigint +// Flags: --allow-natives-syntax 'use strict' diff --git a/deps/v8/test/mjsunit/harmony/bigint/mod.js b/deps/v8/test/mjsunit/harmony/bigint/mod.js index c8cc7fa4fd..01f64ad4ca 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/mod.js +++ b/deps/v8/test/mjsunit/harmony/bigint/mod.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: 0xaed3c714bb42a73d708bcf1dc9a9deebadc913ef42bac6a6178a60n, b: -0xf3d6bd1c059b79n, diff --git a/deps/v8/test/mjsunit/harmony/bigint/mul.js b/deps/v8/test/mjsunit/harmony/bigint/mul.js index c6a9ae6148..77c3a1c9bb 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/mul.js +++ b/deps/v8/test/mjsunit/harmony/bigint/mul.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: 0x2bf1f236c2df29f7c99be052dfe1b69ae158d777fea487af889f6259f472c0n, b: -0xae0090dfn, diff --git a/deps/v8/test/mjsunit/harmony/bigint/neg.js b/deps/v8/test/mjsunit/harmony/bigint/neg.js index 2fedf297a5..15b2fb4ee0 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/neg.js +++ b/deps/v8/test/mjsunit/harmony/bigint/neg.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: 0xcn, r: -0xcn diff --git a/deps/v8/test/mjsunit/harmony/bigint/not.js b/deps/v8/test/mjsunit/harmony/bigint/not.js index 6b4b2eb713..27b6a78ba6 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/not.js +++ b/deps/v8/test/mjsunit/harmony/bigint/not.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: 0x9f0305cd75e4n, r: -0x9f0305cd75e5n diff --git a/deps/v8/test/mjsunit/harmony/bigint/or.js b/deps/v8/test/mjsunit/harmony/bigint/or.js index c378e141cd..3203258c21 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/or.js +++ b/deps/v8/test/mjsunit/harmony/bigint/or.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: 0x77a87n, b: 0xde08e7433fb9584911b8cb4bc7eed802299b4489fc635974d063847da4e8b461df5dn, diff --git a/deps/v8/test/mjsunit/harmony/bigint/regress-tonumbercode.js b/deps/v8/test/mjsunit/harmony/bigint/regress-tonumbercode.js index 4dedf4d27c..3bf0148c95 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/regress-tonumbercode.js +++ b/deps/v8/test/mjsunit/harmony/bigint/regress-tonumbercode.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --harmony-bigint +// Flags: --allow-natives-syntax function f(x, b) { if (b) return Math.trunc(+(x)) diff --git a/deps/v8/test/mjsunit/harmony/bigint/regressions.js b/deps/v8/test/mjsunit/harmony/bigint/regressions.js index c1df45a1b1..8e13622eab 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/regressions.js +++ b/deps/v8/test/mjsunit/harmony/bigint/regressions.js @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --harmony-bigint - var a = 5n; var b = a / -1n; assertEquals(5n, a); diff --git a/deps/v8/test/mjsunit/harmony/bigint/sar.js b/deps/v8/test/mjsunit/harmony/bigint/sar.js index f66115dcb6..66d2f2d268 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/sar.js +++ b/deps/v8/test/mjsunit/harmony/bigint/sar.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: 0x211a34fn, b: 0xa6n, diff --git a/deps/v8/test/mjsunit/harmony/bigint/shl.js b/deps/v8/test/mjsunit/harmony/bigint/shl.js index bedd785b54..0e7b402bc1 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/shl.js +++ b/deps/v8/test/mjsunit/harmony/bigint/shl.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: -0xe813d76adc0a177778c0c232c595e8572b783210f4a7009d7c1787n, b: 0x9en, diff --git a/deps/v8/test/mjsunit/harmony/bigint/sub.js b/deps/v8/test/mjsunit/harmony/bigint/sub.js index a1ff9b4bb3..21613f768a 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/sub.js +++ b/deps/v8/test/mjsunit/harmony/bigint/sub.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: 0xc4fd438551d58edn, b: 0x91b42ee55a50d974an, diff --git a/deps/v8/test/mjsunit/harmony/bigint/tonumber.js b/deps/v8/test/mjsunit/harmony/bigint/tonumber.js index d59e8429b8..a6f7d13b7e 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/tonumber.js +++ b/deps/v8/test/mjsunit/harmony/bigint/tonumber.js @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --harmony-bigint - function Check(bigint, number_string) { var number = Number(bigint); if (number_string.substring(0, 2) === "0x") { diff --git a/deps/v8/test/mjsunit/harmony/bigint/turbo.js b/deps/v8/test/mjsunit/harmony/bigint/turbo.js index 4ce4880f3d..d0f00050c8 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/turbo.js +++ b/deps/v8/test/mjsunit/harmony/bigint/turbo.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --harmony-bigint +// Flags: --allow-natives-syntax 'use strict' diff --git a/deps/v8/test/mjsunit/harmony/bigint/typedarray.js b/deps/v8/test/mjsunit/harmony/bigint/typedarray.js index 29713b8a20..e530441dd4 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/typedarray.js +++ b/deps/v8/test/mjsunit/harmony/bigint/typedarray.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --harmony-bigint --allow-natives-syntax +// Flags: --allow-natives-syntax var intarray = new BigInt64Array(8); var uintarray = new BigUint64Array(8); diff --git a/deps/v8/test/mjsunit/harmony/bigint/xor.js b/deps/v8/test/mjsunit/harmony/bigint/xor.js index a934825bd9..cf32b65603 100644 --- a/deps/v8/test/mjsunit/harmony/bigint/xor.js +++ b/deps/v8/test/mjsunit/harmony/bigint/xor.js @@ -4,8 +4,6 @@ // Generated by tools/bigint-tester.py. -// Flags: --harmony-bigint - var data = [{ a: -0x46505bec40d461c595b5e4be178b7d00n, b: -0x9170e5437d4e3ec7c0971e2c6d3bbbd2929ff108ea4ee64f7a91aa367fn, diff --git a/deps/v8/test/mjsunit/harmony/bigintarray-keyedstore-tobigint.js b/deps/v8/test/mjsunit/harmony/bigintarray-keyedstore-tobigint.js index 29b44472c9..18ba0ff171 100644 --- a/deps/v8/test/mjsunit/harmony/bigintarray-keyedstore-tobigint.js +++ b/deps/v8/test/mjsunit/harmony/bigintarray-keyedstore-tobigint.js @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --harmony-bigint - let TypedArrayConstructors = [ BigUint64Array, BigInt64Array, diff --git a/deps/v8/test/mjsunit/harmony/function-tostring.js b/deps/v8/test/mjsunit/harmony/function-tostring.js index 4a7e93cd3b..2af14f16cf 100644 --- a/deps/v8/test/mjsunit/harmony/function-tostring.js +++ b/deps/v8/test/mjsunit/harmony/function-tostring.js @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --harmony-function-tostring - var prefix = "/*before*/"; var suffix = "/*after*/"; diff --git a/deps/v8/test/mjsunit/harmony/futex.js b/deps/v8/test/mjsunit/harmony/futex.js index 394b4ddaf0..188832cf3c 100644 --- a/deps/v8/test/mjsunit/harmony/futex.js +++ b/deps/v8/test/mjsunit/harmony/futex.js @@ -133,7 +133,7 @@ if (this.Worker) { postMessage(result); };`; - var worker = new Worker(workerScript); + var worker = new Worker(workerScript, {type: 'string'}); worker.postMessage({sab: sab, offset: offset}); // Spin until the worker is waiting on the futex. @@ -143,7 +143,7 @@ if (this.Worker) { assertEquals("ok", worker.getMessage()); worker.terminate(); - var worker2 = new Worker(workerScript); + var worker2 = new Worker(workerScript, {type: 'string'}); var offset = 8; var i32a2 = new Int32Array(sab, offset); worker2.postMessage({sab: sab, offset: offset}); @@ -156,7 +156,7 @@ if (this.Worker) { // Futex should work when index and buffer views are different, but // the real address is the same. - var worker3 = new Worker(workerScript); + var worker3 = new Worker(workerScript, {type: 'string'}); i32a2 = new Int32Array(sab, 4); worker3.postMessage({sab: sab, offset: 8}); @@ -205,7 +205,7 @@ if (this.Worker) { var id; var workers = []; for (id = 0; id < 4; id++) { - workers[id] = new Worker(workerScript); + workers[id] = new Worker(workerScript, {type: 'string'}); workers[id].postMessage({sab: sab, id: id}); } diff --git a/deps/v8/test/mjsunit/harmony/global.js b/deps/v8/test/mjsunit/harmony/global.js index 733b95312b..3d43864c47 100644 --- a/deps/v8/test/mjsunit/harmony/global.js +++ b/deps/v8/test/mjsunit/harmony/global.js @@ -13,7 +13,7 @@ assertEquals(globalThis.globalThis.globalThis.globalThis, this); { const realm = Realm.create(); assertEquals(Realm.global(realm), Realm.eval(realm, 'globalThis')); - assertTrue(Realm.global(realm) !== globalThis); + assertNotEquals(Realm.global(realm), globalThis); } { diff --git a/deps/v8/test/mjsunit/harmony/modules-import-13.js b/deps/v8/test/mjsunit/harmony/modules-import-13.js index 40016246f0..1cec1cce61 100644 --- a/deps/v8/test/mjsunit/harmony/modules-import-13.js +++ b/deps/v8/test/mjsunit/harmony/modules-import-13.js @@ -3,6 +3,7 @@ // found in the LICENSE file. // Flags: --allow-natives-syntax --harmony-dynamic-import +// Resources: test/mjsunit/harmony/modules-skip-1.js ran = false; async function test1() { diff --git a/deps/v8/test/mjsunit/harmony/regexp-property-emoji-flag-sequence-generated.js b/deps/v8/test/mjsunit/harmony/regexp-property-emoji-flag-sequence-generated.js new file mode 100644 index 0000000000..e033c722c7 --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/regexp-property-emoji-flag-sequence-generated.js @@ -0,0 +1,266 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --harmony-regexp-sequence + +const re = /\p{Emoji_Flag_Sequence}/u; + +assertTrue(re.test('\u{1F1E6}\u{1F1E8}')); +assertTrue(re.test('\u{1F1FF}\u{1F1FC}')); +assertTrue(re.test('\u{1F1E6}\u{1F1EA}')); +assertTrue(re.test('\u{1F1E6}\u{1F1EB}')); +assertTrue(re.test('\u{1F1E6}\u{1F1EC}')); +assertTrue(re.test('\u{1F1E6}\u{1F1EE}')); +assertTrue(re.test('\u{1F1E6}\u{1F1F1}')); +assertTrue(re.test('\u{1F1E6}\u{1F1F2}')); +assertTrue(re.test('\u{1F1E6}\u{1F1F4}')); +assertTrue(re.test('\u{1F1E6}\u{1F1F6}')); +assertTrue(re.test('\u{1F1E6}\u{1F1F7}')); +assertTrue(re.test('\u{1F1E6}\u{1F1F8}')); +assertTrue(re.test('\u{1F1E6}\u{1F1F9}')); +assertTrue(re.test('\u{1F1E6}\u{1F1FA}')); +assertTrue(re.test('\u{1F1E6}\u{1F1FC}')); +assertTrue(re.test('\u{1F1E6}\u{1F1FD}')); +assertTrue(re.test('\u{1F1E6}\u{1F1FF}')); +assertTrue(re.test('\u{1F1E7}\u{1F1E6}')); +assertTrue(re.test('\u{1F1E7}\u{1F1E7}')); +assertTrue(re.test('\u{1F1E7}\u{1F1E9}')); +assertTrue(re.test('\u{1F1E7}\u{1F1EA}')); +assertTrue(re.test('\u{1F1E7}\u{1F1EB}')); +assertTrue(re.test('\u{1F1E7}\u{1F1EC}')); +assertTrue(re.test('\u{1F1E7}\u{1F1ED}')); +assertTrue(re.test('\u{1F1E7}\u{1F1EE}')); +assertTrue(re.test('\u{1F1E7}\u{1F1EF}')); +assertTrue(re.test('\u{1F1E7}\u{1F1F1}')); +assertTrue(re.test('\u{1F1E7}\u{1F1F2}')); +assertTrue(re.test('\u{1F1E7}\u{1F1F3}')); +assertTrue(re.test('\u{1F1E7}\u{1F1F4}')); +assertTrue(re.test('\u{1F1E7}\u{1F1F6}')); +assertTrue(re.test('\u{1F1E7}\u{1F1F7}')); +assertTrue(re.test('\u{1F1E7}\u{1F1F8}')); +assertTrue(re.test('\u{1F1E7}\u{1F1F9}')); +assertTrue(re.test('\u{1F1E7}\u{1F1FB}')); +assertTrue(re.test('\u{1F1E7}\u{1F1FC}')); +assertTrue(re.test('\u{1F1E7}\u{1F1FE}')); +assertTrue(re.test('\u{1F1E7}\u{1F1FF}')); +assertTrue(re.test('\u{1F1E8}\u{1F1E6}')); +assertTrue(re.test('\u{1F1E8}\u{1F1E8}')); +assertTrue(re.test('\u{1F1E8}\u{1F1E9}')); +assertTrue(re.test('\u{1F1E8}\u{1F1EB}')); +assertTrue(re.test('\u{1F1E8}\u{1F1EC}')); +assertTrue(re.test('\u{1F1E8}\u{1F1ED}')); +assertTrue(re.test('\u{1F1E8}\u{1F1EE}')); +assertTrue(re.test('\u{1F1E8}\u{1F1F0}')); +assertTrue(re.test('\u{1F1E8}\u{1F1F1}')); +assertTrue(re.test('\u{1F1E8}\u{1F1F2}')); +assertTrue(re.test('\u{1F1E8}\u{1F1F3}')); +assertTrue(re.test('\u{1F1E8}\u{1F1F4}')); +assertTrue(re.test('\u{1F1E8}\u{1F1F5}')); +assertTrue(re.test('\u{1F1E8}\u{1F1F7}')); +assertTrue(re.test('\u{1F1E8}\u{1F1FA}')); +assertTrue(re.test('\u{1F1E8}\u{1F1FB}')); +assertTrue(re.test('\u{1F1E8}\u{1F1FC}')); +assertTrue(re.test('\u{1F1E8}\u{1F1FD}')); +assertTrue(re.test('\u{1F1E8}\u{1F1FE}')); +assertTrue(re.test('\u{1F1E8}\u{1F1FF}')); +assertTrue(re.test('\u{1F1E9}\u{1F1EA}')); +assertTrue(re.test('\u{1F1E9}\u{1F1EC}')); +assertTrue(re.test('\u{1F1E9}\u{1F1EF}')); +assertTrue(re.test('\u{1F1E9}\u{1F1F0}')); +assertTrue(re.test('\u{1F1E9}\u{1F1F2}')); +assertTrue(re.test('\u{1F1E9}\u{1F1F4}')); +assertTrue(re.test('\u{1F1E9}\u{1F1FF}')); +assertTrue(re.test('\u{1F1EA}\u{1F1E6}')); +assertTrue(re.test('\u{1F1EA}\u{1F1E8}')); +assertTrue(re.test('\u{1F1EA}\u{1F1EA}')); +assertTrue(re.test('\u{1F1EA}\u{1F1EC}')); +assertTrue(re.test('\u{1F1EA}\u{1F1ED}')); +assertTrue(re.test('\u{1F1EA}\u{1F1F7}')); +assertTrue(re.test('\u{1F1EA}\u{1F1F8}')); +assertTrue(re.test('\u{1F1EA}\u{1F1F9}')); +assertTrue(re.test('\u{1F1EA}\u{1F1FA}')); +assertTrue(re.test('\u{1F1EB}\u{1F1EE}')); +assertTrue(re.test('\u{1F1EB}\u{1F1EF}')); +assertTrue(re.test('\u{1F1EB}\u{1F1F0}')); +assertTrue(re.test('\u{1F1EB}\u{1F1F2}')); +assertTrue(re.test('\u{1F1EB}\u{1F1F4}')); +assertTrue(re.test('\u{1F1EB}\u{1F1F7}')); +assertTrue(re.test('\u{1F1EC}\u{1F1E6}')); +assertTrue(re.test('\u{1F1EC}\u{1F1E7}')); +assertTrue(re.test('\u{1F1EC}\u{1F1E9}')); +assertTrue(re.test('\u{1F1EC}\u{1F1EA}')); +assertTrue(re.test('\u{1F1EC}\u{1F1EB}')); +assertTrue(re.test('\u{1F1EC}\u{1F1EC}')); +assertTrue(re.test('\u{1F1EC}\u{1F1ED}')); +assertTrue(re.test('\u{1F1EC}\u{1F1EE}')); +assertTrue(re.test('\u{1F1EC}\u{1F1F1}')); +assertTrue(re.test('\u{1F1EC}\u{1F1F2}')); +assertTrue(re.test('\u{1F1EC}\u{1F1F3}')); +assertTrue(re.test('\u{1F1EC}\u{1F1F5}')); +assertTrue(re.test('\u{1F1EC}\u{1F1F6}')); +assertTrue(re.test('\u{1F1EC}\u{1F1F7}')); +assertTrue(re.test('\u{1F1EC}\u{1F1F8}')); +assertTrue(re.test('\u{1F1EC}\u{1F1F9}')); +assertTrue(re.test('\u{1F1EC}\u{1F1FA}')); +assertTrue(re.test('\u{1F1EC}\u{1F1FC}')); +assertTrue(re.test('\u{1F1EC}\u{1F1FE}')); +assertTrue(re.test('\u{1F1ED}\u{1F1F0}')); +assertTrue(re.test('\u{1F1ED}\u{1F1F2}')); +assertTrue(re.test('\u{1F1ED}\u{1F1F3}')); +assertTrue(re.test('\u{1F1ED}\u{1F1F7}')); +assertTrue(re.test('\u{1F1ED}\u{1F1F9}')); +assertTrue(re.test('\u{1F1ED}\u{1F1FA}')); +assertTrue(re.test('\u{1F1EE}\u{1F1E8}')); +assertTrue(re.test('\u{1F1EE}\u{1F1E9}')); +assertTrue(re.test('\u{1F1EE}\u{1F1EA}')); +assertTrue(re.test('\u{1F1EE}\u{1F1F1}')); +assertTrue(re.test('\u{1F1EE}\u{1F1F2}')); +assertTrue(re.test('\u{1F1EE}\u{1F1F3}')); +assertTrue(re.test('\u{1F1EE}\u{1F1F4}')); +assertTrue(re.test('\u{1F1EE}\u{1F1F6}')); +assertTrue(re.test('\u{1F1EE}\u{1F1F7}')); +assertTrue(re.test('\u{1F1EE}\u{1F1F8}')); +assertTrue(re.test('\u{1F1EE}\u{1F1F9}')); +assertTrue(re.test('\u{1F1EF}\u{1F1EA}')); +assertTrue(re.test('\u{1F1EF}\u{1F1F2}')); +assertTrue(re.test('\u{1F1EF}\u{1F1F4}')); +assertTrue(re.test('\u{1F1EF}\u{1F1F5}')); +assertTrue(re.test('\u{1F1F0}\u{1F1EA}')); +assertTrue(re.test('\u{1F1F0}\u{1F1EC}')); +assertTrue(re.test('\u{1F1F0}\u{1F1ED}')); +assertTrue(re.test('\u{1F1F0}\u{1F1EE}')); +assertTrue(re.test('\u{1F1F0}\u{1F1F2}')); +assertTrue(re.test('\u{1F1F0}\u{1F1F3}')); +assertTrue(re.test('\u{1F1F0}\u{1F1F5}')); +assertTrue(re.test('\u{1F1F0}\u{1F1F7}')); +assertTrue(re.test('\u{1F1F0}\u{1F1FC}')); +assertTrue(re.test('\u{1F1E6}\u{1F1E9}')); +assertTrue(re.test('\u{1F1F0}\u{1F1FF}')); +assertTrue(re.test('\u{1F1F1}\u{1F1E6}')); +assertTrue(re.test('\u{1F1F1}\u{1F1E7}')); +assertTrue(re.test('\u{1F1F1}\u{1F1E8}')); +assertTrue(re.test('\u{1F1F1}\u{1F1EE}')); +assertTrue(re.test('\u{1F1F1}\u{1F1F0}')); +assertTrue(re.test('\u{1F1F1}\u{1F1F7}')); +assertTrue(re.test('\u{1F1F1}\u{1F1F8}')); +assertTrue(re.test('\u{1F1F1}\u{1F1F9}')); +assertTrue(re.test('\u{1F1F1}\u{1F1FA}')); +assertTrue(re.test('\u{1F1F1}\u{1F1FB}')); +assertTrue(re.test('\u{1F1F1}\u{1F1FE}')); +assertTrue(re.test('\u{1F1F2}\u{1F1E6}')); +assertTrue(re.test('\u{1F1F2}\u{1F1E8}')); +assertTrue(re.test('\u{1F1F2}\u{1F1E9}')); +assertTrue(re.test('\u{1F1F2}\u{1F1EA}')); +assertTrue(re.test('\u{1F1F2}\u{1F1EB}')); +assertTrue(re.test('\u{1F1F2}\u{1F1EC}')); +assertTrue(re.test('\u{1F1F2}\u{1F1ED}')); +assertTrue(re.test('\u{1F1F2}\u{1F1F0}')); +assertTrue(re.test('\u{1F1F2}\u{1F1F1}')); +assertTrue(re.test('\u{1F1F2}\u{1F1F2}')); +assertTrue(re.test('\u{1F1F2}\u{1F1F3}')); +assertTrue(re.test('\u{1F1F2}\u{1F1F4}')); +assertTrue(re.test('\u{1F1F2}\u{1F1F5}')); +assertTrue(re.test('\u{1F1F2}\u{1F1F6}')); +assertTrue(re.test('\u{1F1F2}\u{1F1F7}')); +assertTrue(re.test('\u{1F1F2}\u{1F1F8}')); +assertTrue(re.test('\u{1F1F2}\u{1F1F9}')); +assertTrue(re.test('\u{1F1F2}\u{1F1FA}')); +assertTrue(re.test('\u{1F1F2}\u{1F1FB}')); +assertTrue(re.test('\u{1F1F2}\u{1F1FC}')); +assertTrue(re.test('\u{1F1F2}\u{1F1FD}')); +assertTrue(re.test('\u{1F1F2}\u{1F1FE}')); +assertTrue(re.test('\u{1F1F2}\u{1F1FF}')); +assertTrue(re.test('\u{1F1F3}\u{1F1E6}')); +assertTrue(re.test('\u{1F1F3}\u{1F1E8}')); +assertTrue(re.test('\u{1F1F3}\u{1F1EA}')); +assertTrue(re.test('\u{1F1F3}\u{1F1EB}')); +assertTrue(re.test('\u{1F1F3}\u{1F1EC}')); +assertTrue(re.test('\u{1F1F3}\u{1F1EE}')); +assertTrue(re.test('\u{1F1F3}\u{1F1F1}')); +assertTrue(re.test('\u{1F1F3}\u{1F1F4}')); +assertTrue(re.test('\u{1F1F3}\u{1F1F5}')); +assertTrue(re.test('\u{1F1F3}\u{1F1F7}')); +assertTrue(re.test('\u{1F1F3}\u{1F1FA}')); +assertTrue(re.test('\u{1F1F3}\u{1F1FF}')); +assertTrue(re.test('\u{1F1F4}\u{1F1F2}')); +assertTrue(re.test('\u{1F1F5}\u{1F1E6}')); +assertTrue(re.test('\u{1F1F5}\u{1F1EA}')); +assertTrue(re.test('\u{1F1F5}\u{1F1EB}')); +assertTrue(re.test('\u{1F1F5}\u{1F1EC}')); +assertTrue(re.test('\u{1F1F5}\u{1F1ED}')); +assertTrue(re.test('\u{1F1F5}\u{1F1F0}')); +assertTrue(re.test('\u{1F1F5}\u{1F1F1}')); +assertTrue(re.test('\u{1F1F5}\u{1F1F2}')); +assertTrue(re.test('\u{1F1F5}\u{1F1F3}')); +assertTrue(re.test('\u{1F1F5}\u{1F1F7}')); +assertTrue(re.test('\u{1F1F5}\u{1F1F8}')); +assertTrue(re.test('\u{1F1F5}\u{1F1F9}')); +assertTrue(re.test('\u{1F1F5}\u{1F1FC}')); +assertTrue(re.test('\u{1F1F5}\u{1F1FE}')); +assertTrue(re.test('\u{1F1F6}\u{1F1E6}')); +assertTrue(re.test('\u{1F1F7}\u{1F1EA}')); +assertTrue(re.test('\u{1F1F7}\u{1F1F4}')); +assertTrue(re.test('\u{1F1F7}\u{1F1F8}')); +assertTrue(re.test('\u{1F1F7}\u{1F1FA}')); +assertTrue(re.test('\u{1F1F7}\u{1F1FC}')); +assertTrue(re.test('\u{1F1F8}\u{1F1E6}')); +assertTrue(re.test('\u{1F1F8}\u{1F1E7}')); +assertTrue(re.test('\u{1F1F8}\u{1F1E8}')); +assertTrue(re.test('\u{1F1F8}\u{1F1E9}')); +assertTrue(re.test('\u{1F1F8}\u{1F1EA}')); +assertTrue(re.test('\u{1F1F8}\u{1F1EC}')); +assertTrue(re.test('\u{1F1F8}\u{1F1ED}')); +assertTrue(re.test('\u{1F1F8}\u{1F1EE}')); +assertTrue(re.test('\u{1F1F8}\u{1F1EF}')); +assertTrue(re.test('\u{1F1F8}\u{1F1F0}')); +assertTrue(re.test('\u{1F1F8}\u{1F1F1}')); +assertTrue(re.test('\u{1F1F8}\u{1F1F2}')); +assertTrue(re.test('\u{1F1F8}\u{1F1F3}')); +assertTrue(re.test('\u{1F1F8}\u{1F1F4}')); +assertTrue(re.test('\u{1F1F8}\u{1F1F7}')); +assertTrue(re.test('\u{1F1F8}\u{1F1F8}')); +assertTrue(re.test('\u{1F1F8}\u{1F1F9}')); +assertTrue(re.test('\u{1F1F8}\u{1F1FB}')); +assertTrue(re.test('\u{1F1F8}\u{1F1FD}')); +assertTrue(re.test('\u{1F1F8}\u{1F1FE}')); +assertTrue(re.test('\u{1F1F8}\u{1F1FF}')); +assertTrue(re.test('\u{1F1F9}\u{1F1E6}')); +assertTrue(re.test('\u{1F1F9}\u{1F1E8}')); +assertTrue(re.test('\u{1F1F9}\u{1F1E9}')); +assertTrue(re.test('\u{1F1F9}\u{1F1EB}')); +assertTrue(re.test('\u{1F1F9}\u{1F1EC}')); +assertTrue(re.test('\u{1F1F9}\u{1F1ED}')); +assertTrue(re.test('\u{1F1F9}\u{1F1EF}')); +assertTrue(re.test('\u{1F1F9}\u{1F1F0}')); +assertTrue(re.test('\u{1F1F9}\u{1F1F1}')); +assertTrue(re.test('\u{1F1F9}\u{1F1F2}')); +assertTrue(re.test('\u{1F1F9}\u{1F1F3}')); +assertTrue(re.test('\u{1F1F9}\u{1F1F4}')); +assertTrue(re.test('\u{1F1F9}\u{1F1F7}')); +assertTrue(re.test('\u{1F1F9}\u{1F1F9}')); +assertTrue(re.test('\u{1F1F9}\u{1F1FB}')); +assertTrue(re.test('\u{1F1F9}\u{1F1FC}')); +assertTrue(re.test('\u{1F1F9}\u{1F1FF}')); +assertTrue(re.test('\u{1F1FA}\u{1F1E6}')); +assertTrue(re.test('\u{1F1FA}\u{1F1EC}')); +assertTrue(re.test('\u{1F1FA}\u{1F1F2}')); +assertTrue(re.test('\u{1F1FA}\u{1F1F3}')); +assertTrue(re.test('\u{1F1FA}\u{1F1F8}')); +assertTrue(re.test('\u{1F1FA}\u{1F1FE}')); +assertTrue(re.test('\u{1F1FA}\u{1F1FF}')); +assertTrue(re.test('\u{1F1FB}\u{1F1E6}')); +assertTrue(re.test('\u{1F1FB}\u{1F1E8}')); +assertTrue(re.test('\u{1F1FB}\u{1F1EA}')); +assertTrue(re.test('\u{1F1FB}\u{1F1EC}')); +assertTrue(re.test('\u{1F1FB}\u{1F1EE}')); +assertTrue(re.test('\u{1F1FB}\u{1F1F3}')); +assertTrue(re.test('\u{1F1FB}\u{1F1FA}')); +assertTrue(re.test('\u{1F1FC}\u{1F1EB}')); +assertTrue(re.test('\u{1F1FC}\u{1F1F8}')); +assertTrue(re.test('\u{1F1FD}\u{1F1F0}')); +assertTrue(re.test('\u{1F1FE}\u{1F1EA}')); +assertTrue(re.test('\u{1F1FE}\u{1F1F9}')); +assertTrue(re.test('\u{1F1FF}\u{1F1E6}')); +assertTrue(re.test('\u{1F1FF}\u{1F1F2}')); +assertTrue(re.test('\u{1F1F0}\u{1F1FE}')); diff --git a/deps/v8/test/mjsunit/harmony/regexp-property-emoji-keycap-sequence-generated.js b/deps/v8/test/mjsunit/harmony/regexp-property-emoji-keycap-sequence-generated.js new file mode 100644 index 0000000000..8366a395ec --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/regexp-property-emoji-keycap-sequence-generated.js @@ -0,0 +1,20 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --harmony-regexp-sequence + +const re = /\p{Emoji_Keycap_Sequence}/u; + +assertTrue(re.test('#\uFE0F\u20E3')); +assertTrue(re.test('9\uFE0F\u20E3')); +assertTrue(re.test('0\uFE0F\u20E3')); +assertTrue(re.test('1\uFE0F\u20E3')); +assertTrue(re.test('2\uFE0F\u20E3')); +assertTrue(re.test('3\uFE0F\u20E3')); +assertTrue(re.test('*\uFE0F\u20E3')); +assertTrue(re.test('5\uFE0F\u20E3')); +assertTrue(re.test('6\uFE0F\u20E3')); +assertTrue(re.test('7\uFE0F\u20E3')); +assertTrue(re.test('8\uFE0F\u20E3')); +assertTrue(re.test('4\uFE0F\u20E3')); diff --git a/deps/v8/test/mjsunit/harmony/regexp-property-emoji-modifier-sequence-generated.js b/deps/v8/test/mjsunit/harmony/regexp-property-emoji-modifier-sequence-generated.js new file mode 100644 index 0000000000..0e11d6c462 --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/regexp-property-emoji-modifier-sequence-generated.js @@ -0,0 +1,538 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --harmony-regexp-sequence + +const re = /\p{Emoji_Modifier_Sequence}/u; + +assertTrue(re.test('\u261D\u{1F3FB}')); +assertTrue(re.test('\u{1F9DD}\u{1F3FF}')); +assertTrue(re.test('\u261D\u{1F3FD}')); +assertTrue(re.test('\u261D\u{1F3FE}')); +assertTrue(re.test('\u261D\u{1F3FF}')); +assertTrue(re.test('\u26F9\u{1F3FB}')); +assertTrue(re.test('\u26F9\u{1F3FC}')); +assertTrue(re.test('\u26F9\u{1F3FD}')); +assertTrue(re.test('\u26F9\u{1F3FE}')); +assertTrue(re.test('\u26F9\u{1F3FF}')); +assertTrue(re.test('\u270A\u{1F3FB}')); +assertTrue(re.test('\u270A\u{1F3FC}')); +assertTrue(re.test('\u270A\u{1F3FD}')); +assertTrue(re.test('\u270A\u{1F3FE}')); +assertTrue(re.test('\u270A\u{1F3FF}')); +assertTrue(re.test('\u270B\u{1F3FB}')); +assertTrue(re.test('\u270B\u{1F3FC}')); +assertTrue(re.test('\u270B\u{1F3FD}')); +assertTrue(re.test('\u270B\u{1F3FE}')); +assertTrue(re.test('\u270B\u{1F3FF}')); +assertTrue(re.test('\u270C\u{1F3FB}')); +assertTrue(re.test('\u270C\u{1F3FC}')); +assertTrue(re.test('\u270C\u{1F3FD}')); +assertTrue(re.test('\u270C\u{1F3FE}')); +assertTrue(re.test('\u270C\u{1F3FF}')); +assertTrue(re.test('\u270D\u{1F3FB}')); +assertTrue(re.test('\u270D\u{1F3FC}')); +assertTrue(re.test('\u270D\u{1F3FD}')); +assertTrue(re.test('\u270D\u{1F3FE}')); +assertTrue(re.test('\u270D\u{1F3FF}')); +assertTrue(re.test('\u{1F385}\u{1F3FB}')); +assertTrue(re.test('\u{1F385}\u{1F3FC}')); +assertTrue(re.test('\u{1F385}\u{1F3FD}')); +assertTrue(re.test('\u{1F385}\u{1F3FE}')); +assertTrue(re.test('\u{1F385}\u{1F3FF}')); +assertTrue(re.test('\u{1F3C2}\u{1F3FB}')); +assertTrue(re.test('\u{1F3C2}\u{1F3FC}')); +assertTrue(re.test('\u{1F3C2}\u{1F3FD}')); +assertTrue(re.test('\u{1F3C2}\u{1F3FE}')); +assertTrue(re.test('\u{1F3C2}\u{1F3FF}')); +assertTrue(re.test('\u{1F3C3}\u{1F3FB}')); +assertTrue(re.test('\u{1F3C3}\u{1F3FC}')); +assertTrue(re.test('\u{1F3C3}\u{1F3FD}')); +assertTrue(re.test('\u{1F3C3}\u{1F3FE}')); +assertTrue(re.test('\u{1F3C3}\u{1F3FF}')); +assertTrue(re.test('\u{1F3C4}\u{1F3FB}')); +assertTrue(re.test('\u{1F3C4}\u{1F3FC}')); +assertTrue(re.test('\u{1F3C4}\u{1F3FD}')); +assertTrue(re.test('\u{1F3C4}\u{1F3FE}')); +assertTrue(re.test('\u{1F3C4}\u{1F3FF}')); +assertTrue(re.test('\u{1F3C7}\u{1F3FB}')); +assertTrue(re.test('\u{1F3C7}\u{1F3FC}')); +assertTrue(re.test('\u{1F3C7}\u{1F3FD}')); +assertTrue(re.test('\u{1F3C7}\u{1F3FE}')); +assertTrue(re.test('\u{1F3C7}\u{1F3FF}')); +assertTrue(re.test('\u{1F3CA}\u{1F3FB}')); +assertTrue(re.test('\u{1F3CA}\u{1F3FC}')); +assertTrue(re.test('\u{1F3CA}\u{1F3FD}')); +assertTrue(re.test('\u{1F3CA}\u{1F3FE}')); +assertTrue(re.test('\u{1F3CA}\u{1F3FF}')); +assertTrue(re.test('\u{1F3CB}\u{1F3FB}')); +assertTrue(re.test('\u{1F3CB}\u{1F3FC}')); +assertTrue(re.test('\u{1F3CB}\u{1F3FD}')); +assertTrue(re.test('\u{1F3CB}\u{1F3FE}')); +assertTrue(re.test('\u{1F3CB}\u{1F3FF}')); +assertTrue(re.test('\u{1F3CC}\u{1F3FB}')); +assertTrue(re.test('\u{1F3CC}\u{1F3FC}')); +assertTrue(re.test('\u{1F3CC}\u{1F3FD}')); +assertTrue(re.test('\u{1F3CC}\u{1F3FE}')); +assertTrue(re.test('\u{1F3CC}\u{1F3FF}')); +assertTrue(re.test('\u{1F442}\u{1F3FB}')); +assertTrue(re.test('\u{1F442}\u{1F3FC}')); +assertTrue(re.test('\u{1F442}\u{1F3FD}')); +assertTrue(re.test('\u{1F442}\u{1F3FE}')); +assertTrue(re.test('\u{1F442}\u{1F3FF}')); +assertTrue(re.test('\u{1F443}\u{1F3FB}')); +assertTrue(re.test('\u{1F443}\u{1F3FC}')); +assertTrue(re.test('\u{1F443}\u{1F3FD}')); +assertTrue(re.test('\u{1F443}\u{1F3FE}')); +assertTrue(re.test('\u{1F443}\u{1F3FF}')); +assertTrue(re.test('\u{1F446}\u{1F3FB}')); +assertTrue(re.test('\u{1F446}\u{1F3FC}')); +assertTrue(re.test('\u{1F446}\u{1F3FD}')); +assertTrue(re.test('\u{1F446}\u{1F3FE}')); +assertTrue(re.test('\u{1F446}\u{1F3FF}')); +assertTrue(re.test('\u{1F447}\u{1F3FB}')); +assertTrue(re.test('\u{1F447}\u{1F3FC}')); +assertTrue(re.test('\u{1F447}\u{1F3FD}')); +assertTrue(re.test('\u{1F447}\u{1F3FE}')); +assertTrue(re.test('\u{1F447}\u{1F3FF}')); +assertTrue(re.test('\u{1F448}\u{1F3FB}')); +assertTrue(re.test('\u{1F448}\u{1F3FC}')); +assertTrue(re.test('\u{1F448}\u{1F3FD}')); +assertTrue(re.test('\u{1F448}\u{1F3FE}')); +assertTrue(re.test('\u{1F448}\u{1F3FF}')); +assertTrue(re.test('\u{1F449}\u{1F3FB}')); +assertTrue(re.test('\u{1F449}\u{1F3FC}')); +assertTrue(re.test('\u{1F449}\u{1F3FD}')); +assertTrue(re.test('\u{1F449}\u{1F3FE}')); +assertTrue(re.test('\u{1F449}\u{1F3FF}')); +assertTrue(re.test('\u{1F44A}\u{1F3FB}')); +assertTrue(re.test('\u{1F44A}\u{1F3FC}')); +assertTrue(re.test('\u{1F44A}\u{1F3FD}')); +assertTrue(re.test('\u{1F44A}\u{1F3FE}')); +assertTrue(re.test('\u{1F44A}\u{1F3FF}')); +assertTrue(re.test('\u{1F44B}\u{1F3FB}')); +assertTrue(re.test('\u{1F44B}\u{1F3FC}')); +assertTrue(re.test('\u{1F44B}\u{1F3FD}')); +assertTrue(re.test('\u{1F44B}\u{1F3FE}')); +assertTrue(re.test('\u{1F44B}\u{1F3FF}')); +assertTrue(re.test('\u{1F44C}\u{1F3FB}')); +assertTrue(re.test('\u{1F44C}\u{1F3FC}')); +assertTrue(re.test('\u{1F44C}\u{1F3FD}')); +assertTrue(re.test('\u{1F44C}\u{1F3FE}')); +assertTrue(re.test('\u{1F44C}\u{1F3FF}')); +assertTrue(re.test('\u{1F44D}\u{1F3FB}')); +assertTrue(re.test('\u{1F44D}\u{1F3FC}')); +assertTrue(re.test('\u{1F44D}\u{1F3FD}')); +assertTrue(re.test('\u{1F44D}\u{1F3FE}')); +assertTrue(re.test('\u{1F44D}\u{1F3FF}')); +assertTrue(re.test('\u{1F44E}\u{1F3FB}')); +assertTrue(re.test('\u{1F44E}\u{1F3FC}')); +assertTrue(re.test('\u{1F44E}\u{1F3FD}')); +assertTrue(re.test('\u{1F44E}\u{1F3FE}')); +assertTrue(re.test('\u{1F44E}\u{1F3FF}')); +assertTrue(re.test('\u{1F44F}\u{1F3FB}')); +assertTrue(re.test('\u{1F44F}\u{1F3FC}')); +assertTrue(re.test('\u{1F44F}\u{1F3FD}')); +assertTrue(re.test('\u{1F44F}\u{1F3FE}')); +assertTrue(re.test('\u{1F44F}\u{1F3FF}')); +assertTrue(re.test('\u{1F450}\u{1F3FB}')); +assertTrue(re.test('\u{1F450}\u{1F3FC}')); +assertTrue(re.test('\u{1F450}\u{1F3FD}')); +assertTrue(re.test('\u{1F450}\u{1F3FE}')); +assertTrue(re.test('\u{1F450}\u{1F3FF}')); +assertTrue(re.test('\u{1F466}\u{1F3FB}')); +assertTrue(re.test('\u{1F466}\u{1F3FC}')); +assertTrue(re.test('\u{1F466}\u{1F3FD}')); +assertTrue(re.test('\u{1F466}\u{1F3FE}')); +assertTrue(re.test('\u{1F466}\u{1F3FF}')); +assertTrue(re.test('\u{1F467}\u{1F3FB}')); +assertTrue(re.test('\u{1F467}\u{1F3FC}')); +assertTrue(re.test('\u{1F467}\u{1F3FD}')); +assertTrue(re.test('\u{1F467}\u{1F3FE}')); +assertTrue(re.test('\u{1F467}\u{1F3FF}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}')); +assertTrue(re.test('\u{1F46E}\u{1F3FB}')); +assertTrue(re.test('\u{1F46E}\u{1F3FC}')); +assertTrue(re.test('\u{1F46E}\u{1F3FD}')); +assertTrue(re.test('\u{1F46E}\u{1F3FE}')); +assertTrue(re.test('\u{1F46E}\u{1F3FF}')); +assertTrue(re.test('\u{1F470}\u{1F3FB}')); +assertTrue(re.test('\u{1F470}\u{1F3FC}')); +assertTrue(re.test('\u{1F470}\u{1F3FD}')); +assertTrue(re.test('\u{1F470}\u{1F3FE}')); +assertTrue(re.test('\u{1F470}\u{1F3FF}')); +assertTrue(re.test('\u{1F471}\u{1F3FB}')); +assertTrue(re.test('\u{1F471}\u{1F3FC}')); +assertTrue(re.test('\u{1F471}\u{1F3FD}')); +assertTrue(re.test('\u{1F471}\u{1F3FE}')); +assertTrue(re.test('\u{1F471}\u{1F3FF}')); +assertTrue(re.test('\u{1F472}\u{1F3FB}')); +assertTrue(re.test('\u{1F472}\u{1F3FC}')); +assertTrue(re.test('\u{1F472}\u{1F3FD}')); +assertTrue(re.test('\u{1F472}\u{1F3FE}')); +assertTrue(re.test('\u{1F472}\u{1F3FF}')); +assertTrue(re.test('\u{1F473}\u{1F3FB}')); +assertTrue(re.test('\u{1F473}\u{1F3FC}')); +assertTrue(re.test('\u{1F473}\u{1F3FD}')); +assertTrue(re.test('\u{1F473}\u{1F3FE}')); +assertTrue(re.test('\u{1F473}\u{1F3FF}')); +assertTrue(re.test('\u{1F474}\u{1F3FB}')); +assertTrue(re.test('\u{1F474}\u{1F3FC}')); +assertTrue(re.test('\u{1F474}\u{1F3FD}')); +assertTrue(re.test('\u{1F474}\u{1F3FE}')); +assertTrue(re.test('\u{1F474}\u{1F3FF}')); +assertTrue(re.test('\u{1F475}\u{1F3FB}')); +assertTrue(re.test('\u{1F475}\u{1F3FC}')); +assertTrue(re.test('\u{1F475}\u{1F3FD}')); +assertTrue(re.test('\u{1F475}\u{1F3FE}')); +assertTrue(re.test('\u{1F475}\u{1F3FF}')); +assertTrue(re.test('\u{1F476}\u{1F3FB}')); +assertTrue(re.test('\u{1F476}\u{1F3FC}')); +assertTrue(re.test('\u{1F476}\u{1F3FD}')); +assertTrue(re.test('\u{1F476}\u{1F3FE}')); +assertTrue(re.test('\u{1F476}\u{1F3FF}')); +assertTrue(re.test('\u{1F477}\u{1F3FB}')); +assertTrue(re.test('\u{1F477}\u{1F3FC}')); +assertTrue(re.test('\u{1F477}\u{1F3FD}')); +assertTrue(re.test('\u{1F477}\u{1F3FE}')); +assertTrue(re.test('\u{1F477}\u{1F3FF}')); +assertTrue(re.test('\u{1F478}\u{1F3FB}')); +assertTrue(re.test('\u{1F478}\u{1F3FC}')); +assertTrue(re.test('\u{1F478}\u{1F3FD}')); +assertTrue(re.test('\u{1F478}\u{1F3FE}')); +assertTrue(re.test('\u{1F478}\u{1F3FF}')); +assertTrue(re.test('\u{1F47C}\u{1F3FB}')); +assertTrue(re.test('\u{1F47C}\u{1F3FC}')); +assertTrue(re.test('\u{1F47C}\u{1F3FD}')); +assertTrue(re.test('\u{1F47C}\u{1F3FE}')); +assertTrue(re.test('\u{1F47C}\u{1F3FF}')); +assertTrue(re.test('\u{1F481}\u{1F3FB}')); +assertTrue(re.test('\u{1F481}\u{1F3FC}')); +assertTrue(re.test('\u{1F481}\u{1F3FD}')); +assertTrue(re.test('\u{1F481}\u{1F3FE}')); +assertTrue(re.test('\u{1F481}\u{1F3FF}')); +assertTrue(re.test('\u{1F482}\u{1F3FB}')); +assertTrue(re.test('\u{1F482}\u{1F3FC}')); +assertTrue(re.test('\u{1F482}\u{1F3FD}')); +assertTrue(re.test('\u{1F482}\u{1F3FE}')); +assertTrue(re.test('\u{1F482}\u{1F3FF}')); +assertTrue(re.test('\u{1F483}\u{1F3FB}')); +assertTrue(re.test('\u{1F483}\u{1F3FC}')); +assertTrue(re.test('\u{1F483}\u{1F3FD}')); +assertTrue(re.test('\u{1F483}\u{1F3FE}')); +assertTrue(re.test('\u{1F483}\u{1F3FF}')); +assertTrue(re.test('\u{1F485}\u{1F3FB}')); +assertTrue(re.test('\u{1F485}\u{1F3FC}')); +assertTrue(re.test('\u{1F485}\u{1F3FD}')); +assertTrue(re.test('\u{1F485}\u{1F3FE}')); +assertTrue(re.test('\u{1F485}\u{1F3FF}')); +assertTrue(re.test('\u{1F486}\u{1F3FB}')); +assertTrue(re.test('\u{1F486}\u{1F3FC}')); +assertTrue(re.test('\u{1F486}\u{1F3FD}')); +assertTrue(re.test('\u{1F486}\u{1F3FE}')); +assertTrue(re.test('\u{1F486}\u{1F3FF}')); +assertTrue(re.test('\u{1F487}\u{1F3FB}')); +assertTrue(re.test('\u{1F487}\u{1F3FC}')); +assertTrue(re.test('\u{1F487}\u{1F3FD}')); +assertTrue(re.test('\u{1F487}\u{1F3FE}')); +assertTrue(re.test('\u{1F487}\u{1F3FF}')); +assertTrue(re.test('\u{1F4AA}\u{1F3FB}')); +assertTrue(re.test('\u{1F4AA}\u{1F3FC}')); +assertTrue(re.test('\u{1F4AA}\u{1F3FD}')); +assertTrue(re.test('\u{1F4AA}\u{1F3FE}')); +assertTrue(re.test('\u{1F4AA}\u{1F3FF}')); +assertTrue(re.test('\u{1F574}\u{1F3FB}')); +assertTrue(re.test('\u{1F574}\u{1F3FC}')); +assertTrue(re.test('\u{1F574}\u{1F3FD}')); +assertTrue(re.test('\u{1F574}\u{1F3FE}')); +assertTrue(re.test('\u{1F574}\u{1F3FF}')); +assertTrue(re.test('\u{1F575}\u{1F3FB}')); +assertTrue(re.test('\u{1F575}\u{1F3FC}')); +assertTrue(re.test('\u{1F575}\u{1F3FD}')); +assertTrue(re.test('\u{1F575}\u{1F3FE}')); +assertTrue(re.test('\u{1F575}\u{1F3FF}')); +assertTrue(re.test('\u{1F57A}\u{1F3FB}')); +assertTrue(re.test('\u{1F57A}\u{1F3FC}')); +assertTrue(re.test('\u{1F57A}\u{1F3FD}')); +assertTrue(re.test('\u{1F57A}\u{1F3FE}')); +assertTrue(re.test('\u{1F57A}\u{1F3FF}')); +assertTrue(re.test('\u{1F590}\u{1F3FB}')); +assertTrue(re.test('\u{1F590}\u{1F3FC}')); +assertTrue(re.test('\u{1F590}\u{1F3FD}')); +assertTrue(re.test('\u{1F590}\u{1F3FE}')); +assertTrue(re.test('\u{1F590}\u{1F3FF}')); +assertTrue(re.test('\u261D\u{1F3FC}')); +assertTrue(re.test('\u{1F595}\u{1F3FC}')); +assertTrue(re.test('\u{1F595}\u{1F3FD}')); +assertTrue(re.test('\u{1F595}\u{1F3FE}')); +assertTrue(re.test('\u{1F595}\u{1F3FF}')); +assertTrue(re.test('\u{1F596}\u{1F3FB}')); +assertTrue(re.test('\u{1F596}\u{1F3FC}')); +assertTrue(re.test('\u{1F596}\u{1F3FD}')); +assertTrue(re.test('\u{1F596}\u{1F3FE}')); +assertTrue(re.test('\u{1F596}\u{1F3FF}')); +assertTrue(re.test('\u{1F645}\u{1F3FB}')); +assertTrue(re.test('\u{1F645}\u{1F3FC}')); +assertTrue(re.test('\u{1F645}\u{1F3FD}')); +assertTrue(re.test('\u{1F645}\u{1F3FE}')); +assertTrue(re.test('\u{1F645}\u{1F3FF}')); +assertTrue(re.test('\u{1F646}\u{1F3FB}')); +assertTrue(re.test('\u{1F646}\u{1F3FC}')); +assertTrue(re.test('\u{1F646}\u{1F3FD}')); +assertTrue(re.test('\u{1F646}\u{1F3FE}')); +assertTrue(re.test('\u{1F646}\u{1F3FF}')); +assertTrue(re.test('\u{1F647}\u{1F3FB}')); +assertTrue(re.test('\u{1F647}\u{1F3FC}')); +assertTrue(re.test('\u{1F647}\u{1F3FD}')); +assertTrue(re.test('\u{1F647}\u{1F3FE}')); +assertTrue(re.test('\u{1F647}\u{1F3FF}')); +assertTrue(re.test('\u{1F64B}\u{1F3FB}')); +assertTrue(re.test('\u{1F64B}\u{1F3FC}')); +assertTrue(re.test('\u{1F64B}\u{1F3FD}')); +assertTrue(re.test('\u{1F64B}\u{1F3FE}')); +assertTrue(re.test('\u{1F64B}\u{1F3FF}')); +assertTrue(re.test('\u{1F64C}\u{1F3FB}')); +assertTrue(re.test('\u{1F64C}\u{1F3FC}')); +assertTrue(re.test('\u{1F64C}\u{1F3FD}')); +assertTrue(re.test('\u{1F64C}\u{1F3FE}')); +assertTrue(re.test('\u{1F64C}\u{1F3FF}')); +assertTrue(re.test('\u{1F64D}\u{1F3FB}')); +assertTrue(re.test('\u{1F64D}\u{1F3FC}')); +assertTrue(re.test('\u{1F64D}\u{1F3FD}')); +assertTrue(re.test('\u{1F64D}\u{1F3FE}')); +assertTrue(re.test('\u{1F64D}\u{1F3FF}')); +assertTrue(re.test('\u{1F64E}\u{1F3FB}')); +assertTrue(re.test('\u{1F64E}\u{1F3FC}')); +assertTrue(re.test('\u{1F64E}\u{1F3FD}')); +assertTrue(re.test('\u{1F64E}\u{1F3FE}')); +assertTrue(re.test('\u{1F64E}\u{1F3FF}')); +assertTrue(re.test('\u{1F64F}\u{1F3FB}')); +assertTrue(re.test('\u{1F64F}\u{1F3FC}')); +assertTrue(re.test('\u{1F64F}\u{1F3FD}')); +assertTrue(re.test('\u{1F64F}\u{1F3FE}')); +assertTrue(re.test('\u{1F64F}\u{1F3FF}')); +assertTrue(re.test('\u{1F6A3}\u{1F3FB}')); +assertTrue(re.test('\u{1F6A3}\u{1F3FC}')); +assertTrue(re.test('\u{1F6A3}\u{1F3FD}')); +assertTrue(re.test('\u{1F6A3}\u{1F3FE}')); +assertTrue(re.test('\u{1F6A3}\u{1F3FF}')); +assertTrue(re.test('\u{1F6B4}\u{1F3FB}')); +assertTrue(re.test('\u{1F6B4}\u{1F3FC}')); +assertTrue(re.test('\u{1F6B4}\u{1F3FD}')); +assertTrue(re.test('\u{1F6B4}\u{1F3FE}')); +assertTrue(re.test('\u{1F6B4}\u{1F3FF}')); +assertTrue(re.test('\u{1F6B5}\u{1F3FB}')); +assertTrue(re.test('\u{1F6B5}\u{1F3FC}')); +assertTrue(re.test('\u{1F6B5}\u{1F3FD}')); +assertTrue(re.test('\u{1F6B5}\u{1F3FE}')); +assertTrue(re.test('\u{1F6B5}\u{1F3FF}')); +assertTrue(re.test('\u{1F6B6}\u{1F3FB}')); +assertTrue(re.test('\u{1F6B6}\u{1F3FC}')); +assertTrue(re.test('\u{1F6B6}\u{1F3FD}')); +assertTrue(re.test('\u{1F6B6}\u{1F3FE}')); +assertTrue(re.test('\u{1F6B6}\u{1F3FF}')); +assertTrue(re.test('\u{1F6C0}\u{1F3FB}')); +assertTrue(re.test('\u{1F6C0}\u{1F3FC}')); +assertTrue(re.test('\u{1F6C0}\u{1F3FD}')); +assertTrue(re.test('\u{1F6C0}\u{1F3FE}')); +assertTrue(re.test('\u{1F6C0}\u{1F3FF}')); +assertTrue(re.test('\u{1F6CC}\u{1F3FB}')); +assertTrue(re.test('\u{1F6CC}\u{1F3FC}')); +assertTrue(re.test('\u{1F6CC}\u{1F3FD}')); +assertTrue(re.test('\u{1F6CC}\u{1F3FE}')); +assertTrue(re.test('\u{1F6CC}\u{1F3FF}')); +assertTrue(re.test('\u{1F918}\u{1F3FB}')); +assertTrue(re.test('\u{1F918}\u{1F3FC}')); +assertTrue(re.test('\u{1F918}\u{1F3FD}')); +assertTrue(re.test('\u{1F918}\u{1F3FE}')); +assertTrue(re.test('\u{1F918}\u{1F3FF}')); +assertTrue(re.test('\u{1F919}\u{1F3FB}')); +assertTrue(re.test('\u{1F919}\u{1F3FC}')); +assertTrue(re.test('\u{1F919}\u{1F3FD}')); +assertTrue(re.test('\u{1F919}\u{1F3FE}')); +assertTrue(re.test('\u{1F919}\u{1F3FF}')); +assertTrue(re.test('\u{1F91A}\u{1F3FB}')); +assertTrue(re.test('\u{1F91A}\u{1F3FC}')); +assertTrue(re.test('\u{1F91A}\u{1F3FD}')); +assertTrue(re.test('\u{1F91A}\u{1F3FE}')); +assertTrue(re.test('\u{1F91A}\u{1F3FF}')); +assertTrue(re.test('\u{1F91B}\u{1F3FB}')); +assertTrue(re.test('\u{1F91B}\u{1F3FC}')); +assertTrue(re.test('\u{1F91B}\u{1F3FD}')); +assertTrue(re.test('\u{1F91B}\u{1F3FE}')); +assertTrue(re.test('\u{1F91B}\u{1F3FF}')); +assertTrue(re.test('\u{1F91C}\u{1F3FB}')); +assertTrue(re.test('\u{1F91C}\u{1F3FC}')); +assertTrue(re.test('\u{1F91C}\u{1F3FD}')); +assertTrue(re.test('\u{1F91C}\u{1F3FE}')); +assertTrue(re.test('\u{1F91C}\u{1F3FF}')); +assertTrue(re.test('\u{1F91E}\u{1F3FB}')); +assertTrue(re.test('\u{1F91E}\u{1F3FC}')); +assertTrue(re.test('\u{1F91E}\u{1F3FD}')); +assertTrue(re.test('\u{1F91E}\u{1F3FE}')); +assertTrue(re.test('\u{1F91E}\u{1F3FF}')); +assertTrue(re.test('\u{1F91F}\u{1F3FB}')); +assertTrue(re.test('\u{1F91F}\u{1F3FC}')); +assertTrue(re.test('\u{1F91F}\u{1F3FD}')); +assertTrue(re.test('\u{1F91F}\u{1F3FE}')); +assertTrue(re.test('\u{1F91F}\u{1F3FF}')); +assertTrue(re.test('\u{1F926}\u{1F3FB}')); +assertTrue(re.test('\u{1F926}\u{1F3FC}')); +assertTrue(re.test('\u{1F926}\u{1F3FD}')); +assertTrue(re.test('\u{1F926}\u{1F3FE}')); +assertTrue(re.test('\u{1F926}\u{1F3FF}')); +assertTrue(re.test('\u{1F930}\u{1F3FB}')); +assertTrue(re.test('\u{1F930}\u{1F3FC}')); +assertTrue(re.test('\u{1F930}\u{1F3FD}')); +assertTrue(re.test('\u{1F930}\u{1F3FE}')); +assertTrue(re.test('\u{1F930}\u{1F3FF}')); +assertTrue(re.test('\u{1F931}\u{1F3FB}')); +assertTrue(re.test('\u{1F931}\u{1F3FC}')); +assertTrue(re.test('\u{1F931}\u{1F3FD}')); +assertTrue(re.test('\u{1F931}\u{1F3FE}')); +assertTrue(re.test('\u{1F931}\u{1F3FF}')); +assertTrue(re.test('\u{1F932}\u{1F3FB}')); +assertTrue(re.test('\u{1F932}\u{1F3FC}')); +assertTrue(re.test('\u{1F932}\u{1F3FD}')); +assertTrue(re.test('\u{1F932}\u{1F3FE}')); +assertTrue(re.test('\u{1F932}\u{1F3FF}')); +assertTrue(re.test('\u{1F933}\u{1F3FB}')); +assertTrue(re.test('\u{1F933}\u{1F3FC}')); +assertTrue(re.test('\u{1F933}\u{1F3FD}')); +assertTrue(re.test('\u{1F933}\u{1F3FE}')); +assertTrue(re.test('\u{1F933}\u{1F3FF}')); +assertTrue(re.test('\u{1F934}\u{1F3FB}')); +assertTrue(re.test('\u{1F934}\u{1F3FC}')); +assertTrue(re.test('\u{1F934}\u{1F3FD}')); +assertTrue(re.test('\u{1F934}\u{1F3FE}')); +assertTrue(re.test('\u{1F934}\u{1F3FF}')); +assertTrue(re.test('\u{1F935}\u{1F3FB}')); +assertTrue(re.test('\u{1F935}\u{1F3FC}')); +assertTrue(re.test('\u{1F935}\u{1F3FD}')); +assertTrue(re.test('\u{1F935}\u{1F3FE}')); +assertTrue(re.test('\u{1F935}\u{1F3FF}')); +assertTrue(re.test('\u{1F936}\u{1F3FB}')); +assertTrue(re.test('\u{1F936}\u{1F3FC}')); +assertTrue(re.test('\u{1F936}\u{1F3FD}')); +assertTrue(re.test('\u{1F936}\u{1F3FE}')); +assertTrue(re.test('\u{1F936}\u{1F3FF}')); +assertTrue(re.test('\u{1F937}\u{1F3FB}')); +assertTrue(re.test('\u{1F937}\u{1F3FC}')); +assertTrue(re.test('\u{1F937}\u{1F3FD}')); +assertTrue(re.test('\u{1F937}\u{1F3FE}')); +assertTrue(re.test('\u{1F937}\u{1F3FF}')); +assertTrue(re.test('\u{1F938}\u{1F3FB}')); +assertTrue(re.test('\u{1F938}\u{1F3FC}')); +assertTrue(re.test('\u{1F938}\u{1F3FD}')); +assertTrue(re.test('\u{1F938}\u{1F3FE}')); +assertTrue(re.test('\u{1F938}\u{1F3FF}')); +assertTrue(re.test('\u{1F939}\u{1F3FB}')); +assertTrue(re.test('\u{1F939}\u{1F3FC}')); +assertTrue(re.test('\u{1F939}\u{1F3FD}')); +assertTrue(re.test('\u{1F939}\u{1F3FE}')); +assertTrue(re.test('\u{1F939}\u{1F3FF}')); +assertTrue(re.test('\u{1F93D}\u{1F3FB}')); +assertTrue(re.test('\u{1F93D}\u{1F3FC}')); +assertTrue(re.test('\u{1F93D}\u{1F3FD}')); +assertTrue(re.test('\u{1F93D}\u{1F3FE}')); +assertTrue(re.test('\u{1F93D}\u{1F3FF}')); +assertTrue(re.test('\u{1F93E}\u{1F3FB}')); +assertTrue(re.test('\u{1F93E}\u{1F3FC}')); +assertTrue(re.test('\u{1F93E}\u{1F3FD}')); +assertTrue(re.test('\u{1F93E}\u{1F3FE}')); +assertTrue(re.test('\u{1F93E}\u{1F3FF}')); +assertTrue(re.test('\u{1F9B5}\u{1F3FB}')); +assertTrue(re.test('\u{1F9B5}\u{1F3FC}')); +assertTrue(re.test('\u{1F9B5}\u{1F3FD}')); +assertTrue(re.test('\u{1F9B5}\u{1F3FE}')); +assertTrue(re.test('\u{1F9B5}\u{1F3FF}')); +assertTrue(re.test('\u{1F9B6}\u{1F3FB}')); +assertTrue(re.test('\u{1F9B6}\u{1F3FC}')); +assertTrue(re.test('\u{1F9B6}\u{1F3FD}')); +assertTrue(re.test('\u{1F9B6}\u{1F3FE}')); +assertTrue(re.test('\u{1F9B6}\u{1F3FF}')); +assertTrue(re.test('\u{1F9B8}\u{1F3FB}')); +assertTrue(re.test('\u{1F9B8}\u{1F3FC}')); +assertTrue(re.test('\u{1F9B8}\u{1F3FD}')); +assertTrue(re.test('\u{1F9B8}\u{1F3FE}')); +assertTrue(re.test('\u{1F9B8}\u{1F3FF}')); +assertTrue(re.test('\u{1F9B9}\u{1F3FB}')); +assertTrue(re.test('\u{1F9B9}\u{1F3FC}')); +assertTrue(re.test('\u{1F9B9}\u{1F3FD}')); +assertTrue(re.test('\u{1F9B9}\u{1F3FE}')); +assertTrue(re.test('\u{1F9B9}\u{1F3FF}')); +assertTrue(re.test('\u{1F9D1}\u{1F3FB}')); +assertTrue(re.test('\u{1F9D1}\u{1F3FC}')); +assertTrue(re.test('\u{1F9D1}\u{1F3FD}')); +assertTrue(re.test('\u{1F9D1}\u{1F3FE}')); +assertTrue(re.test('\u{1F9D1}\u{1F3FF}')); +assertTrue(re.test('\u{1F9D2}\u{1F3FB}')); +assertTrue(re.test('\u{1F9D2}\u{1F3FC}')); +assertTrue(re.test('\u{1F9D2}\u{1F3FD}')); +assertTrue(re.test('\u{1F9D2}\u{1F3FE}')); +assertTrue(re.test('\u{1F9D2}\u{1F3FF}')); +assertTrue(re.test('\u{1F9D3}\u{1F3FB}')); +assertTrue(re.test('\u{1F9D3}\u{1F3FC}')); +assertTrue(re.test('\u{1F9D3}\u{1F3FD}')); +assertTrue(re.test('\u{1F9D3}\u{1F3FE}')); +assertTrue(re.test('\u{1F9D3}\u{1F3FF}')); +assertTrue(re.test('\u{1F9D4}\u{1F3FB}')); +assertTrue(re.test('\u{1F9D4}\u{1F3FC}')); +assertTrue(re.test('\u{1F9D4}\u{1F3FD}')); +assertTrue(re.test('\u{1F9D4}\u{1F3FE}')); +assertTrue(re.test('\u{1F9D4}\u{1F3FF}')); +assertTrue(re.test('\u{1F9D5}\u{1F3FB}')); +assertTrue(re.test('\u{1F9D5}\u{1F3FC}')); +assertTrue(re.test('\u{1F9D5}\u{1F3FD}')); +assertTrue(re.test('\u{1F9D5}\u{1F3FE}')); +assertTrue(re.test('\u{1F9D5}\u{1F3FF}')); +assertTrue(re.test('\u{1F9D6}\u{1F3FB}')); +assertTrue(re.test('\u{1F9D6}\u{1F3FC}')); +assertTrue(re.test('\u{1F9D6}\u{1F3FD}')); +assertTrue(re.test('\u{1F9D6}\u{1F3FE}')); +assertTrue(re.test('\u{1F9D6}\u{1F3FF}')); +assertTrue(re.test('\u{1F9D7}\u{1F3FB}')); +assertTrue(re.test('\u{1F9D7}\u{1F3FC}')); +assertTrue(re.test('\u{1F9D7}\u{1F3FD}')); +assertTrue(re.test('\u{1F9D7}\u{1F3FE}')); +assertTrue(re.test('\u{1F9D7}\u{1F3FF}')); +assertTrue(re.test('\u{1F9D8}\u{1F3FB}')); +assertTrue(re.test('\u{1F9D8}\u{1F3FC}')); +assertTrue(re.test('\u{1F9D8}\u{1F3FD}')); +assertTrue(re.test('\u{1F9D8}\u{1F3FE}')); +assertTrue(re.test('\u{1F9D8}\u{1F3FF}')); +assertTrue(re.test('\u{1F9D9}\u{1F3FB}')); +assertTrue(re.test('\u{1F9D9}\u{1F3FC}')); +assertTrue(re.test('\u{1F9D9}\u{1F3FD}')); +assertTrue(re.test('\u{1F9D9}\u{1F3FE}')); +assertTrue(re.test('\u{1F9D9}\u{1F3FF}')); +assertTrue(re.test('\u{1F9DA}\u{1F3FB}')); +assertTrue(re.test('\u{1F9DA}\u{1F3FC}')); +assertTrue(re.test('\u{1F9DA}\u{1F3FD}')); +assertTrue(re.test('\u{1F9DA}\u{1F3FE}')); +assertTrue(re.test('\u{1F9DA}\u{1F3FF}')); +assertTrue(re.test('\u{1F9DB}\u{1F3FB}')); +assertTrue(re.test('\u{1F9DB}\u{1F3FC}')); +assertTrue(re.test('\u{1F9DB}\u{1F3FD}')); +assertTrue(re.test('\u{1F9DB}\u{1F3FE}')); +assertTrue(re.test('\u{1F9DB}\u{1F3FF}')); +assertTrue(re.test('\u{1F9DC}\u{1F3FB}')); +assertTrue(re.test('\u{1F9DC}\u{1F3FC}')); +assertTrue(re.test('\u{1F9DC}\u{1F3FD}')); +assertTrue(re.test('\u{1F9DC}\u{1F3FE}')); +assertTrue(re.test('\u{1F9DC}\u{1F3FF}')); +assertTrue(re.test('\u{1F9DD}\u{1F3FB}')); +assertTrue(re.test('\u{1F9DD}\u{1F3FC}')); +assertTrue(re.test('\u{1F9DD}\u{1F3FD}')); +assertTrue(re.test('\u{1F9DD}\u{1F3FE}')); +assertTrue(re.test('\u{1F595}\u{1F3FB}')); diff --git a/deps/v8/test/mjsunit/harmony/regexp-property-emoji-tag-sequence-generated.js b/deps/v8/test/mjsunit/harmony/regexp-property-emoji-tag-sequence-generated.js new file mode 100644 index 0000000000..129e1c7777 --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/regexp-property-emoji-tag-sequence-generated.js @@ -0,0 +1,11 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --harmony-regexp-sequence + +const re = /\p{Emoji_Tag_Sequence}/u; + +assertTrue(re.test('\u{1F3F4}\u{E0067}\u{E0062}\u{E0065}\u{E006E}\u{E0067}\u{E007F}')); +assertTrue(re.test('\u{1F3F4}\u{E0067}\u{E0062}\u{E0073}\u{E0063}\u{E0074}\u{E007F}')); +assertTrue(re.test('\u{1F3F4}\u{E0067}\u{E0062}\u{E0077}\u{E006C}\u{E0073}\u{E007F}')); diff --git a/deps/v8/test/mjsunit/harmony/regexp-property-emoji-zwj-sequence-generated.js b/deps/v8/test/mjsunit/harmony/regexp-property-emoji-zwj-sequence-generated.js new file mode 100644 index 0000000000..619bf46175 --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/regexp-property-emoji-zwj-sequence-generated.js @@ -0,0 +1,782 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --harmony-regexp-sequence + +const re = /\p{Emoji_ZWJ_Sequence}/u; + +assertTrue(re.test('\u{1F468}\u200D\u2764\uFE0F\u200D\u{1F468}')); +assertTrue(re.test('\u{1F441}\uFE0F\u200D\u{1F5E8}\uFE0F')); +assertTrue(re.test('\u{1F468}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F466}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F467}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F467}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F467}\u200D\u{1F467}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F468}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F468}\u200D\u{1F466}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F468}\u200D\u{1F467}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F468}\u200D\u{1F467}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F468}\u200D\u{1F467}\u200D\u{1F467}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F469}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F469}\u200D\u{1F466}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F469}\u200D\u{1F467}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}')); +assertTrue(re.test('\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F468}')); +assertTrue(re.test('\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F469}')); +assertTrue(re.test('\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}')); +assertTrue(re.test('\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F466}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F467}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F467}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F467}\u200D\u{1F467}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F469}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F469}\u200D\u{1F466}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F469}\u200D\u{1F467}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F466}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}')); +assertTrue(re.test('\u{1F468}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F468}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F468}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F468}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F468}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F468}\u{1F3FB}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F468}\u{1F3FC}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F468}\u{1F3FD}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F468}\u{1F3FE}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F468}\u{1F3FF}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F469}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F469}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F469}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F469}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F469}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F469}\u{1F3FB}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F469}\u{1F3FC}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F469}\u{1F3FD}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F469}\u{1F3FE}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u2695\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u2696\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u2708\uFE0F')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F33E}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F373}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F393}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F3A4}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F3A8}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F3EB}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F3ED}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F4BB}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F4BC}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F527}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F52C}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F680}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F692}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F9B0}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F9B1}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F9B2}')); +assertTrue(re.test('\u{1F469}\u{1F3FF}\u200D\u{1F9B3}')); +assertTrue(re.test('\u{1F46E}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F46E}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F46E}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F46E}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F46E}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F46E}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F46E}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F46E}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F46E}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F46E}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F46E}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F46E}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F471}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F471}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F471}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F471}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F471}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F471}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F471}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F471}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F471}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F471}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F471}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F471}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F473}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F473}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F473}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F473}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F473}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F473}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F473}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F473}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F473}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F473}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F473}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F473}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F477}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F477}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F477}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F477}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F477}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F477}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F477}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F477}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F477}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F477}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F477}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F477}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F482}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F482}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F482}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F482}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F482}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F482}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F482}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F482}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F482}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F482}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F482}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F482}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F575}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F575}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F575}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F575}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F575}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F575}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F575}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F575}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F575}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F575}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F575}\uFE0F\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F575}\uFE0F\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D9}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DA}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DB}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F468}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}')); +assertTrue(re.test('\u{1F9DC}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DD}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9DF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9DF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u26F9\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u26F9\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u26F9\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u26F9\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u26F9\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u26F9\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u26F9\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u26F9\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u26F9\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u26F9\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u26F9\uFE0F\u200D\u2640\uFE0F')); +assertTrue(re.test('\u26F9\uFE0F\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C3}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3C4}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CA}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CB}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CB}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CB}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CB}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CB}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CB}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CB}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CB}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CB}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CB}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CB}\uFE0F\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CB}\uFE0F\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CC}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CC}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CC}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CC}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CC}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CC}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CC}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CC}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CC}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CC}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3CC}\uFE0F\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F3CC}\uFE0F\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F46F}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F46F}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F486}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F486}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F486}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F486}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F486}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F486}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F486}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F486}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F486}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F486}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F486}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F486}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F487}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F487}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F487}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F487}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F487}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F487}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F487}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F487}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F487}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F487}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F487}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F487}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6A3}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B4}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B5}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F6B6}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F938}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F938}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F938}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F938}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F938}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F938}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F938}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F938}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F938}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F938}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F938}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F938}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F939}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F939}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F939}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F939}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F939}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F939}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F939}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F939}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F939}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F939}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F939}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F939}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93C}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93C}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93D}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93D}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93D}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93D}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93D}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93D}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93D}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93D}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93D}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93D}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93D}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93D}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93E}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93E}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93E}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93E}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93E}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93E}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93E}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93E}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93E}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93E}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F93E}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F93E}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D6}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D7}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9D8}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F481}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F481}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F481}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F481}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F481}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F481}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F481}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F481}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F481}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F481}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F481}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F481}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F645}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F645}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F645}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F645}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F645}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F645}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F645}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F645}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F645}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F645}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F645}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F645}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F646}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F646}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F646}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F646}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F646}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F646}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F646}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F646}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F646}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F646}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F646}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F646}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F647}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F647}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F647}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F647}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F647}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F647}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F647}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F647}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F647}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F647}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F647}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F647}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64B}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64B}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64B}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64B}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64B}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64B}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64B}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64B}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64B}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64B}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64B}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64B}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64D}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64D}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64D}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64D}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64D}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64D}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64D}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64D}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64D}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64D}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64D}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64D}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64E}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64E}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64E}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64E}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64E}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64E}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64E}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64E}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64E}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64E}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F64E}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F64E}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F926}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F926}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F926}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F926}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F926}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F926}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F926}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F926}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F926}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F926}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F926}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F926}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F937}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F937}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F937}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F937}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F937}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F937}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F937}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F937}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F937}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F937}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F937}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F937}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B8}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u{1F3FB}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u{1F3FB}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u{1F3FC}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u{1F3FC}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u{1F3FD}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u{1F3FD}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u{1F3FE}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u{1F3FE}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u{1F3FF}\u200D\u2640\uFE0F')); +assertTrue(re.test('\u{1F9B9}\u{1F3FF}\u200D\u2642\uFE0F')); +assertTrue(re.test('\u{1F3F3}\uFE0F\u200D\u{1F308}')); +assertTrue(re.test('\u{1F3F4}\u200D\u2620\uFE0F')); +assertTrue(re.test('\u{1F9DC}\u{1F3FE}\u200D\u2640\uFE0F')); diff --git a/deps/v8/test/mjsunit/harmony/regexp-property-invalid.js b/deps/v8/test/mjsunit/harmony/regexp-property-invalid.js index 83c7b2e209..7fef5dfd0c 100644 --- a/deps/v8/test/mjsunit/harmony/regexp-property-invalid.js +++ b/deps/v8/test/mjsunit/harmony/regexp-property-invalid.js @@ -34,3 +34,5 @@ assertThrows("/\\p{In}/u"); assertThrows("/\\pI/u"); assertThrows("/\\p{I}/u"); assertThrows("/\\p{CJK}/u"); + +assertThrows("/\\p{}/u"); diff --git a/deps/v8/test/mjsunit/harmony/regexp-property-sequence.js b/deps/v8/test/mjsunit/harmony/regexp-property-sequence.js new file mode 100644 index 0000000000..4d43298016 --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/regexp-property-sequence.js @@ -0,0 +1,88 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --harmony-regexp-sequence + +// Normal usage. +assertDoesNotThrow("/\\p{Emoji_Flag_Sequence}/u"); +assertTrue(/\p{Emoji_Flag_Sequence}/u.test("\u{1F1E9}\u{1F1EA}")); + +assertDoesNotThrow("/\\p{Emoji_Keycap_Sequence}/u"); +assertTrue(/\p{Emoji_Keycap_Sequence}/u.test("\u0023\uFE0F\u20E3")); + +assertDoesNotThrow("/\\p{Emoji_Keycap_Sequence}/u"); +assertFalse(/\p{Emoji_Keycap_Sequence}/u.test("\u0022\uFE0F\u20E3")); + +assertDoesNotThrow("/\\p{Emoji_Modifier_Sequence}/u"); +assertTrue(/\p{Emoji_Modifier_Sequence}/u.test("\u26F9\u{1F3FF}")); + +assertDoesNotThrow("/\\p{Emoji_ZWJ_Sequence}/u"); +assertTrue(/\p{Emoji_ZWJ_Sequence}/u.test("\u{1F468}\u{200D}\u{1F467}")); + +// Without unicode flag. +assertDoesNotThrow("/\\p{Emoji_Flag_Sequence}/"); +assertFalse(/\p{Emoji_Flag_Sequence}/.test("\u{1F1E9}\u{1F1EA}")); +assertTrue(/\p{Emoji_Flag_Sequence}/.test("\\p{Emoji_Flag_Sequence}")); + +// Negated and/or inside a character class. +assertThrows("/\\P{Emoji_Flag_Sequence}/u"); +assertThrows("/\\P{Emoji_Keycap_Sequence}/u"); +assertThrows("/\\P{Emoji_Modifier_Sequence}/u"); +assertThrows("/\\P{Emoji_Tag_Sequence}/u"); +assertThrows("/\\P{Emoji_ZWJ_Sequence}/u"); + +assertThrows("/[\\p{Emoji_Flag_Sequence}]/u"); +assertThrows("/[\\p{Emoji_Keycap_Sequence}]/u"); +assertThrows("/[\\p{Emoji_Modifier_Sequence}]/u"); +assertThrows("/[\\p{Emoji_Tag_Sequence}]/u"); +assertThrows("/[\\p{Emoji_ZWJ_Sequence}]/u"); + +assertThrows("/[\\P{Emoji_Flag_Sequence}]/u"); +assertThrows("/[\\P{Emoji_Keycap_Sequence}]/u"); +assertThrows("/[\\P{Emoji_Modifier_Sequence}]/u"); +assertThrows("/[\\P{Emoji_Tag_Sequence}]/u"); +assertThrows("/[\\P{Emoji_ZWJ_Sequence}]/u"); + +assertThrows("/[\\w\\p{Emoji_Flag_Sequence}]/u"); +assertThrows("/[\\w\\p{Emoji_Keycap_Sequence}]/u"); +assertThrows("/[\\w\\p{Emoji_Modifier_Sequence}]/u"); +assertThrows("/[\\w\\p{Emoji_Tag_Sequence}]/u"); +assertThrows("/[\\w\\p{Emoji_ZWJ_Sequence}]/u"); + +assertThrows("/[\\w\\P{Emoji_Flag_Sequence}]/u"); +assertThrows("/[\\w\\P{Emoji_Keycap_Sequence}]/u"); +assertThrows("/[\\w\\P{Emoji_Modifier_Sequence}]/u"); +assertThrows("/[\\w\\P{Emoji_Tag_Sequence}]/u"); +assertThrows("/[\\w\\P{Emoji_ZWJ_Sequence}]/u"); + +// Two regional indicators, but not a country. +assertFalse(/\p{Emoji_Flag_Sequence}/u.test("\u{1F1E6}\u{1F1E6}")); + +// ZWJ sequence as in two ZWJ elements joined by a ZWJ, but not in the list. +assertFalse(/\p{Emoji_ZWJ_Sequence}/u.test("\u{1F467}\u{200D}\u{1F468}")); + +// More complex regexp +assertEquals( + ["country flag: \u{1F1E6}\u{1F1F9}"], + /Country Flag: \p{Emoji_Flag_Sequence}/iu.exec( + "this is an example of a country flag: \u{1F1E6}\u{1F1F9} is Austria")); +assertEquals( + ["country flag: \u{1F1E6}\u{1F1F9}", "\u{1F1E6}\u{1F1F9}"], + /Country Flag: (\p{Emoji_Flag_Sequence})/iu.exec( + "this is an example of a country flag: \u{1F1E6}\u{1F1F9} is Austria")); +assertEquals( + ["country flag: \u{1F1E6}\u{1F1F9}"], + /Country Flag: ..(?<=\p{Emoji_Flag_Sequence})/iu.exec( + "this is an example of a country flag: \u{1F1E6}\u{1F1F9} is Austria")); +assertEquals( + ["flag: \u{1F1E6}\u{1F1F9}", "\u{1F1E6}\u{1F1F9}"], + /Flag: ..(?<=(\p{Emoji_Flag_Sequence})|\p{Emoji_Keycap_Sequence})/iu.exec( + "this is an example of a country flag: \u{1F1E6}\u{1F1F9} is Austria")); + +// Partial sequences. +assertFalse(/\p{Emoji_Flag_Sequence}/u.test("\u{1F1E6}_")); +assertFalse(/\p{Emoji_Keycap_Sequence}/u.test("2\uFE0F_")); +assertFalse(/\p{Emoji_Modifier_Sequence}/u.test("\u261D_")); +assertFalse(/\p{Emoji_Tag_Sequence}/u.test("\u{1F3F4}\u{E0067}\u{E0062}\u{E0065}\u{E006E}\u{E0067}_")); +assertFalse(/\p{Emoji_ZWJ_Sequence}/u.test("\u{1F468}\u200D\u2764\uFE0F\u200D_")); diff --git a/deps/v8/test/mjsunit/harmony/to-number.js b/deps/v8/test/mjsunit/harmony/to-number.js index 6dc4db59a2..a48a7d83f8 100644 --- a/deps/v8/test/mjsunit/harmony/to-number.js +++ b/deps/v8/test/mjsunit/harmony/to-number.js @@ -5,47 +5,34 @@ // Flags: --allow-natives-syntax assertEquals(1, %ToNumber(1)); -assertEquals(1, %_ToNumber(1)); assertEquals(.5, %ToNumber(.5)); -assertEquals(.5, %_ToNumber(.5)); assertEquals(0, %ToNumber(null)); -assertEquals(0, %_ToNumber(null)); assertEquals(1, %ToNumber(true)); -assertEquals(1, %_ToNumber(true)); assertEquals(0, %ToNumber(false)); -assertEquals(0, %_ToNumber(false)); assertEquals(NaN, %ToNumber(undefined)); -assertEquals(NaN, %_ToNumber(undefined)); assertEquals(-1, %ToNumber("-1")); -assertEquals(-1, %_ToNumber("-1")); assertEquals(123, %ToNumber("123")); -assertEquals(123, %_ToNumber("123")); assertEquals(NaN, %ToNumber("random text")); -assertEquals(NaN, %_ToNumber("random text")); assertThrows(function() { %ToNumber(Symbol.toPrimitive) }, TypeError); -assertThrows(function() { %_ToNumber(Symbol.toPrimitive) }, TypeError); var a = { toString: function() { return 54321 }}; assertEquals(54321, %ToNumber(a)); -assertEquals(54321, %_ToNumber(a)); var b = { valueOf: function() { return 42 }}; assertEquals(42, %ToNumber(b)); -assertEquals(42, %_ToNumber(b)); var c = { toString: function() { return "x"}, valueOf: function() { return 123 } }; assertEquals(123, %ToNumber(c)); -assertEquals(123, %_ToNumber(c)); var d = { [Symbol.toPrimitive]: function(hint) { @@ -54,8 +41,6 @@ var d = { } }; assertEquals(987654321, %ToNumber(d)); -assertEquals(987654321, %_ToNumber(d)); var e = new Date(0); assertEquals(0, %ToNumber(e)); -assertEquals(0, %_ToNumber(e)); diff --git a/deps/v8/test/mjsunit/harmony/to-primitive.js b/deps/v8/test/mjsunit/harmony/to-primitive.js deleted file mode 100644 index 8decb04657..0000000000 --- a/deps/v8/test/mjsunit/harmony/to-primitive.js +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright 2015 the V8 project authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -// Flags: --allow-natives-syntax - -assertEquals(1, %ToPrimitive(1)); -assertEquals(1, %ToPrimitive_Number(1)); - -assertEquals(.5, %ToPrimitive(.5)); -assertEquals(.5, %ToPrimitive_Number(.5)); - -assertEquals(null, %ToPrimitive(null)); -assertEquals(null, %ToPrimitive_Number(null)); - -assertEquals(true, %ToPrimitive(true)); -assertEquals(true, %ToPrimitive_Number(true)); - -assertEquals(false, %ToPrimitive(false)); -assertEquals(false, %ToPrimitive_Number(false)); - -assertEquals(undefined, %ToPrimitive(undefined)); -assertEquals(undefined, %ToPrimitive_Number(undefined)); - -assertEquals("random text", %ToPrimitive("random text")); -assertEquals("random text", %ToPrimitive_Number("random text")); - -assertEquals(Symbol.toPrimitive, %ToPrimitive(Symbol.toPrimitive)); -assertEquals(Symbol.toPrimitive, %ToPrimitive_Number(Symbol.toPrimitive)); - -var a = { toString: function() { return "xyz" }}; -assertEquals("xyz", %ToPrimitive(a)); -assertEquals("xyz", %ToPrimitive_Number(a)); - -var b = { valueOf: function() { return 42 }}; -assertEquals(42, %ToPrimitive(b)); -assertEquals(42, %ToPrimitive_Number(b)); - -var c = { - toString: function() { return "x"}, - valueOf: function() { return 123 } -}; -assertEquals(123, %ToPrimitive(c)); -assertEquals(123, %ToPrimitive_Number(c)); - -var d = { - [Symbol.toPrimitive]: function(hint) { return hint } -}; -assertEquals("default", %ToPrimitive(d)); -assertEquals("number", %ToPrimitive_Number(d)); - -var e = new Date(0); -assertEquals(e.toString(), %ToPrimitive(e)); -assertEquals(0, %ToPrimitive_Number(e)); diff --git a/deps/v8/test/mjsunit/harmony/well-formed-json-stringify-checked.js b/deps/v8/test/mjsunit/harmony/well-formed-json-stringify-checked.js new file mode 100644 index 0000000000..d1179d3855 --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/well-formed-json-stringify-checked.js @@ -0,0 +1,2575 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --harmony-json-stringify + +// Test JSON.stringify for cases that hit +// JsonStringifier::SerializeString_. + +// All code points from U+0000 to U+00FF. +assertEquals('"___\\u0000"', JSON.stringify('___\0')); +assertEquals('"___\\u0001"', JSON.stringify('___\x01')); +assertEquals('"___\\u0002"', JSON.stringify('___\x02')); +assertEquals('"___\\u0003"', JSON.stringify('___\x03')); +assertEquals('"___\\u0004"', JSON.stringify('___\x04')); +assertEquals('"___\\u0005"', JSON.stringify('___\x05')); +assertEquals('"___\\u0006"', JSON.stringify('___\x06')); +assertEquals('"___\\u0007"', JSON.stringify('___\x07')); +assertEquals('"___\\b"', JSON.stringify('___\b')); +assertEquals('"___\\t"', JSON.stringify('___\t')); +assertEquals('"___\\n"', JSON.stringify('___\n')); +assertEquals('"___\\u000b"', JSON.stringify('___\x0B')); +assertEquals('"___\\f"', JSON.stringify('___\f')); +assertEquals('"___\\r"', JSON.stringify('___\r')); +assertEquals('"___\\u000e"', JSON.stringify('___\x0E')); +assertEquals('"___\\u000f"', JSON.stringify('___\x0F')); +assertEquals('"___\\u0010"', JSON.stringify('___\x10')); +assertEquals('"___\\u0011"', JSON.stringify('___\x11')); +assertEquals('"___\\u0012"', JSON.stringify('___\x12')); +assertEquals('"___\\u0013"', JSON.stringify('___\x13')); +assertEquals('"___\\u0014"', JSON.stringify('___\x14')); +assertEquals('"___\\u0015"', JSON.stringify('___\x15')); +assertEquals('"___\\u0016"', JSON.stringify('___\x16')); +assertEquals('"___\\u0017"', JSON.stringify('___\x17')); +assertEquals('"___\\u0018"', JSON.stringify('___\x18')); +assertEquals('"___\\u0019"', JSON.stringify('___\x19')); +assertEquals('"___\\u001a"', JSON.stringify('___\x1A')); +assertEquals('"___\\u001b"', JSON.stringify('___\x1B')); +assertEquals('"___\\u001c"', JSON.stringify('___\x1C')); +assertEquals('"___\\u001d"', JSON.stringify('___\x1D')); +assertEquals('"___\\u001e"', JSON.stringify('___\x1E')); +assertEquals('"___\\u001f"', JSON.stringify('___\x1F')); +assertEquals('"___ "', JSON.stringify('___ ')); +assertEquals('"___!"', JSON.stringify('___!')); +assertEquals('"___\\""', JSON.stringify('___"')); +assertEquals('"___#"', JSON.stringify('___#')); +assertEquals('"___$"', JSON.stringify('___$')); +assertEquals('"___%"', JSON.stringify('___%')); +assertEquals('"___&"', JSON.stringify('___&')); +assertEquals('"___\'"', JSON.stringify('___\'')); +assertEquals('"___("', JSON.stringify('___(')); +assertEquals('"___)"', JSON.stringify('___)')); +assertEquals('"___*"', JSON.stringify('___*')); +assertEquals('"___+"', JSON.stringify('___+')); +assertEquals('"___,"', JSON.stringify('___,')); +assertEquals('"___-"', JSON.stringify('___-')); +assertEquals('"___."', JSON.stringify('___.')); +assertEquals('"___/"', JSON.stringify('___/')); +assertEquals('"___0"', JSON.stringify('___0')); +assertEquals('"___1"', JSON.stringify('___1')); +assertEquals('"___2"', JSON.stringify('___2')); +assertEquals('"___3"', JSON.stringify('___3')); +assertEquals('"___4"', JSON.stringify('___4')); +assertEquals('"___5"', JSON.stringify('___5')); +assertEquals('"___6"', JSON.stringify('___6')); +assertEquals('"___7"', JSON.stringify('___7')); +assertEquals('"___8"', JSON.stringify('___8')); +assertEquals('"___9"', JSON.stringify('___9')); +assertEquals('"___:"', JSON.stringify('___:')); +assertEquals('"___;"', JSON.stringify('___;')); +assertEquals('"___<"', JSON.stringify('___<')); +assertEquals('"___="', JSON.stringify('___=')); +assertEquals('"___>"', JSON.stringify('___>')); +assertEquals('"___?"', JSON.stringify('___?')); +assertEquals('"___@"', JSON.stringify('___@')); +assertEquals('"___A"', JSON.stringify('___A')); +assertEquals('"___B"', JSON.stringify('___B')); +assertEquals('"___C"', JSON.stringify('___C')); +assertEquals('"___D"', JSON.stringify('___D')); +assertEquals('"___E"', JSON.stringify('___E')); +assertEquals('"___F"', JSON.stringify('___F')); +assertEquals('"___G"', JSON.stringify('___G')); +assertEquals('"___H"', JSON.stringify('___H')); +assertEquals('"___I"', JSON.stringify('___I')); +assertEquals('"___J"', JSON.stringify('___J')); +assertEquals('"___K"', JSON.stringify('___K')); +assertEquals('"___L"', JSON.stringify('___L')); +assertEquals('"___M"', JSON.stringify('___M')); +assertEquals('"___N"', JSON.stringify('___N')); +assertEquals('"___O"', JSON.stringify('___O')); +assertEquals('"___P"', JSON.stringify('___P')); +assertEquals('"___Q"', JSON.stringify('___Q')); +assertEquals('"___R"', JSON.stringify('___R')); +assertEquals('"___S"', JSON.stringify('___S')); +assertEquals('"___T"', JSON.stringify('___T')); +assertEquals('"___U"', JSON.stringify('___U')); +assertEquals('"___V"', JSON.stringify('___V')); +assertEquals('"___W"', JSON.stringify('___W')); +assertEquals('"___X"', JSON.stringify('___X')); +assertEquals('"___Y"', JSON.stringify('___Y')); +assertEquals('"___Z"', JSON.stringify('___Z')); +assertEquals('"___["', JSON.stringify('___[')); +assertEquals('"___\\\\"', JSON.stringify('___\\')); +assertEquals('"___]"', JSON.stringify('___]')); +assertEquals('"___^"', JSON.stringify('___^')); +assertEquals('"____"', JSON.stringify('____')); +assertEquals('"___`"', JSON.stringify('___`')); +assertEquals('"___a"', JSON.stringify('___a')); +assertEquals('"___b"', JSON.stringify('___b')); +assertEquals('"___c"', JSON.stringify('___c')); +assertEquals('"___d"', JSON.stringify('___d')); +assertEquals('"___e"', JSON.stringify('___e')); +assertEquals('"___f"', JSON.stringify('___f')); +assertEquals('"___g"', JSON.stringify('___g')); +assertEquals('"___h"', JSON.stringify('___h')); +assertEquals('"___i"', JSON.stringify('___i')); +assertEquals('"___j"', JSON.stringify('___j')); +assertEquals('"___k"', JSON.stringify('___k')); +assertEquals('"___l"', JSON.stringify('___l')); +assertEquals('"___m"', JSON.stringify('___m')); +assertEquals('"___n"', JSON.stringify('___n')); +assertEquals('"___o"', JSON.stringify('___o')); +assertEquals('"___p"', JSON.stringify('___p')); +assertEquals('"___q"', JSON.stringify('___q')); +assertEquals('"___r"', JSON.stringify('___r')); +assertEquals('"___s"', JSON.stringify('___s')); +assertEquals('"___t"', JSON.stringify('___t')); +assertEquals('"___u"', JSON.stringify('___u')); +assertEquals('"___v"', JSON.stringify('___v')); +assertEquals('"___w"', JSON.stringify('___w')); +assertEquals('"___x"', JSON.stringify('___x')); +assertEquals('"___y"', JSON.stringify('___y')); +assertEquals('"___z"', JSON.stringify('___z')); +assertEquals('"___{"', JSON.stringify('___{')); +assertEquals('"___|"', JSON.stringify('___|')); +assertEquals('"___}"', JSON.stringify('___}')); +assertEquals('"___~"', JSON.stringify('___~')); +assertEquals('"___\x7F"', JSON.stringify('___\x7F')); +assertEquals('"___\x80"', JSON.stringify('___\x80')); +assertEquals('"___\x81"', JSON.stringify('___\x81')); +assertEquals('"___\x82"', JSON.stringify('___\x82')); +assertEquals('"___\x83"', JSON.stringify('___\x83')); +assertEquals('"___\x84"', JSON.stringify('___\x84')); +assertEquals('"___\x85"', JSON.stringify('___\x85')); +assertEquals('"___\x86"', JSON.stringify('___\x86')); +assertEquals('"___\x87"', JSON.stringify('___\x87')); +assertEquals('"___\x88"', JSON.stringify('___\x88')); +assertEquals('"___\x89"', JSON.stringify('___\x89')); +assertEquals('"___\x8A"', JSON.stringify('___\x8A')); +assertEquals('"___\x8B"', JSON.stringify('___\x8B')); +assertEquals('"___\x8C"', JSON.stringify('___\x8C')); +assertEquals('"___\x8D"', JSON.stringify('___\x8D')); +assertEquals('"___\x8E"', JSON.stringify('___\x8E')); +assertEquals('"___\x8F"', JSON.stringify('___\x8F')); +assertEquals('"___\x90"', JSON.stringify('___\x90')); +assertEquals('"___\x91"', JSON.stringify('___\x91')); +assertEquals('"___\x92"', JSON.stringify('___\x92')); +assertEquals('"___\x93"', JSON.stringify('___\x93')); +assertEquals('"___\x94"', JSON.stringify('___\x94')); +assertEquals('"___\x95"', JSON.stringify('___\x95')); +assertEquals('"___\x96"', JSON.stringify('___\x96')); +assertEquals('"___\x97"', JSON.stringify('___\x97')); +assertEquals('"___\x98"', JSON.stringify('___\x98')); +assertEquals('"___\x99"', JSON.stringify('___\x99')); +assertEquals('"___\x9A"', JSON.stringify('___\x9A')); +assertEquals('"___\x9B"', JSON.stringify('___\x9B')); +assertEquals('"___\x9C"', JSON.stringify('___\x9C')); +assertEquals('"___\x9D"', JSON.stringify('___\x9D')); +assertEquals('"___\x9E"', JSON.stringify('___\x9E')); +assertEquals('"___\x9F"', JSON.stringify('___\x9F')); +assertEquals('"___\xA0"', JSON.stringify('___\xA0')); +assertEquals('"___\xA1"', JSON.stringify('___\xA1')); +assertEquals('"___\xA2"', JSON.stringify('___\xA2')); +assertEquals('"___\xA3"', JSON.stringify('___\xA3')); +assertEquals('"___\xA4"', JSON.stringify('___\xA4')); +assertEquals('"___\xA5"', JSON.stringify('___\xA5')); +assertEquals('"___\xA6"', JSON.stringify('___\xA6')); +assertEquals('"___\xA7"', JSON.stringify('___\xA7')); +assertEquals('"___\xA8"', JSON.stringify('___\xA8')); +assertEquals('"___\xA9"', JSON.stringify('___\xA9')); +assertEquals('"___\xAA"', JSON.stringify('___\xAA')); +assertEquals('"___\xAB"', JSON.stringify('___\xAB')); +assertEquals('"___\xAC"', JSON.stringify('___\xAC')); +assertEquals('"___\xAD"', JSON.stringify('___\xAD')); +assertEquals('"___\xAE"', JSON.stringify('___\xAE')); +assertEquals('"___\xAF"', JSON.stringify('___\xAF')); +assertEquals('"___\xB0"', JSON.stringify('___\xB0')); +assertEquals('"___\xB1"', JSON.stringify('___\xB1')); +assertEquals('"___\xB2"', JSON.stringify('___\xB2')); +assertEquals('"___\xB3"', JSON.stringify('___\xB3')); +assertEquals('"___\xB4"', JSON.stringify('___\xB4')); +assertEquals('"___\xB5"', JSON.stringify('___\xB5')); +assertEquals('"___\xB6"', JSON.stringify('___\xB6')); +assertEquals('"___\xB7"', JSON.stringify('___\xB7')); +assertEquals('"___\xB8"', JSON.stringify('___\xB8')); +assertEquals('"___\xB9"', JSON.stringify('___\xB9')); +assertEquals('"___\xBA"', JSON.stringify('___\xBA')); +assertEquals('"___\xBB"', JSON.stringify('___\xBB')); +assertEquals('"___\xBC"', JSON.stringify('___\xBC')); +assertEquals('"___\xBD"', JSON.stringify('___\xBD')); +assertEquals('"___\xBE"', JSON.stringify('___\xBE')); +assertEquals('"___\xBF"', JSON.stringify('___\xBF')); +assertEquals('"___\xC0"', JSON.stringify('___\xC0')); +assertEquals('"___\xC1"', JSON.stringify('___\xC1')); +assertEquals('"___\xC2"', JSON.stringify('___\xC2')); +assertEquals('"___\xC3"', JSON.stringify('___\xC3')); +assertEquals('"___\xC4"', JSON.stringify('___\xC4')); +assertEquals('"___\xC5"', JSON.stringify('___\xC5')); +assertEquals('"___\xC6"', JSON.stringify('___\xC6')); +assertEquals('"___\xC7"', JSON.stringify('___\xC7')); +assertEquals('"___\xC8"', JSON.stringify('___\xC8')); +assertEquals('"___\xC9"', JSON.stringify('___\xC9')); +assertEquals('"___\xCA"', JSON.stringify('___\xCA')); +assertEquals('"___\xCB"', JSON.stringify('___\xCB')); +assertEquals('"___\xCC"', JSON.stringify('___\xCC')); +assertEquals('"___\xCD"', JSON.stringify('___\xCD')); +assertEquals('"___\xCE"', JSON.stringify('___\xCE')); +assertEquals('"___\xCF"', JSON.stringify('___\xCF')); +assertEquals('"___\xD0"', JSON.stringify('___\xD0')); +assertEquals('"___\xD1"', JSON.stringify('___\xD1')); +assertEquals('"___\xD2"', JSON.stringify('___\xD2')); +assertEquals('"___\xD3"', JSON.stringify('___\xD3')); +assertEquals('"___\xD4"', JSON.stringify('___\xD4')); +assertEquals('"___\xD5"', JSON.stringify('___\xD5')); +assertEquals('"___\xD6"', JSON.stringify('___\xD6')); +assertEquals('"___\xD7"', JSON.stringify('___\xD7')); +assertEquals('"___\xD8"', JSON.stringify('___\xD8')); +assertEquals('"___\xD9"', JSON.stringify('___\xD9')); +assertEquals('"___\xDA"', JSON.stringify('___\xDA')); +assertEquals('"___\xDB"', JSON.stringify('___\xDB')); +assertEquals('"___\xDC"', JSON.stringify('___\xDC')); +assertEquals('"___\xDD"', JSON.stringify('___\xDD')); +assertEquals('"___\xDE"', JSON.stringify('___\xDE')); +assertEquals('"___\xDF"', JSON.stringify('___\xDF')); +assertEquals('"___\xE0"', JSON.stringify('___\xE0')); +assertEquals('"___\xE1"', JSON.stringify('___\xE1')); +assertEquals('"___\xE2"', JSON.stringify('___\xE2')); +assertEquals('"___\xE3"', JSON.stringify('___\xE3')); +assertEquals('"___\xE4"', JSON.stringify('___\xE4')); +assertEquals('"___\xE5"', JSON.stringify('___\xE5')); +assertEquals('"___\xE6"', JSON.stringify('___\xE6')); +assertEquals('"___\xE7"', JSON.stringify('___\xE7')); +assertEquals('"___\xE8"', JSON.stringify('___\xE8')); +assertEquals('"___\xE9"', JSON.stringify('___\xE9')); +assertEquals('"___\xEA"', JSON.stringify('___\xEA')); +assertEquals('"___\xEB"', JSON.stringify('___\xEB')); +assertEquals('"___\xEC"', JSON.stringify('___\xEC')); +assertEquals('"___\xED"', JSON.stringify('___\xED')); +assertEquals('"___\xEE"', JSON.stringify('___\xEE')); +assertEquals('"___\xEF"', JSON.stringify('___\xEF')); +assertEquals('"___\xF0"', JSON.stringify('___\xF0')); +assertEquals('"___\xF1"', JSON.stringify('___\xF1')); +assertEquals('"___\xF2"', JSON.stringify('___\xF2')); +assertEquals('"___\xF3"', JSON.stringify('___\xF3')); +assertEquals('"___\xF4"', JSON.stringify('___\xF4')); +assertEquals('"___\xF5"', JSON.stringify('___\xF5')); +assertEquals('"___\xF6"', JSON.stringify('___\xF6')); +assertEquals('"___\xF7"', JSON.stringify('___\xF7')); +assertEquals('"___\xF8"', JSON.stringify('___\xF8')); +assertEquals('"___\xF9"', JSON.stringify('___\xF9')); +assertEquals('"___\xFA"', JSON.stringify('___\xFA')); +assertEquals('"___\xFB"', JSON.stringify('___\xFB')); +assertEquals('"___\xFC"', JSON.stringify('___\xFC')); +assertEquals('"___\xFD"', JSON.stringify('___\xFD')); +assertEquals('"___\xFE"', JSON.stringify('___\xFE')); +assertEquals('"___\xFF"', JSON.stringify('___\xFF')); + +// A random selection of code points from U+0100 to U+D7FF. +assertEquals('"___\u0100"', JSON.stringify('___\u0100')); +assertEquals('"___\u0120"', JSON.stringify('___\u0120')); +assertEquals('"___\u07D3"', JSON.stringify('___\u07D3')); +assertEquals('"___\u0B8B"', JSON.stringify('___\u0B8B')); +assertEquals('"___\u0C4C"', JSON.stringify('___\u0C4C')); +assertEquals('"___\u178D"', JSON.stringify('___\u178D')); +assertEquals('"___\u18B8"', JSON.stringify('___\u18B8')); +assertEquals('"___\u193E"', JSON.stringify('___\u193E')); +assertEquals('"___\u198A"', JSON.stringify('___\u198A')); +assertEquals('"___\u1AF5"', JSON.stringify('___\u1AF5')); +assertEquals('"___\u1D38"', JSON.stringify('___\u1D38')); +assertEquals('"___\u1E37"', JSON.stringify('___\u1E37')); +assertEquals('"___\u1FC2"', JSON.stringify('___\u1FC2')); +assertEquals('"___\u22C7"', JSON.stringify('___\u22C7')); +assertEquals('"___\u2619"', JSON.stringify('___\u2619')); +assertEquals('"___\u272A"', JSON.stringify('___\u272A')); +assertEquals('"___\u2B7F"', JSON.stringify('___\u2B7F')); +assertEquals('"___\u2DFF"', JSON.stringify('___\u2DFF')); +assertEquals('"___\u341B"', JSON.stringify('___\u341B')); +assertEquals('"___\u3A3C"', JSON.stringify('___\u3A3C')); +assertEquals('"___\u3E53"', JSON.stringify('___\u3E53')); +assertEquals('"___\u3EC2"', JSON.stringify('___\u3EC2')); +assertEquals('"___\u3F76"', JSON.stringify('___\u3F76')); +assertEquals('"___\u3F85"', JSON.stringify('___\u3F85')); +assertEquals('"___\u43C7"', JSON.stringify('___\u43C7')); +assertEquals('"___\u4A19"', JSON.stringify('___\u4A19')); +assertEquals('"___\u4A1C"', JSON.stringify('___\u4A1C')); +assertEquals('"___\u4F80"', JSON.stringify('___\u4F80')); +assertEquals('"___\u5A30"', JSON.stringify('___\u5A30')); +assertEquals('"___\u5B55"', JSON.stringify('___\u5B55')); +assertEquals('"___\u5C74"', JSON.stringify('___\u5C74')); +assertEquals('"___\u6006"', JSON.stringify('___\u6006')); +assertEquals('"___\u63CC"', JSON.stringify('___\u63CC')); +assertEquals('"___\u6608"', JSON.stringify('___\u6608')); +assertEquals('"___\u6ABF"', JSON.stringify('___\u6ABF')); +assertEquals('"___\u6AE9"', JSON.stringify('___\u6AE9')); +assertEquals('"___\u6C91"', JSON.stringify('___\u6C91')); +assertEquals('"___\u714B"', JSON.stringify('___\u714B')); +assertEquals('"___\u728A"', JSON.stringify('___\u728A')); +assertEquals('"___\u7485"', JSON.stringify('___\u7485')); +assertEquals('"___\u77C8"', JSON.stringify('___\u77C8')); +assertEquals('"___\u7BE9"', JSON.stringify('___\u7BE9')); +assertEquals('"___\u7CEF"', JSON.stringify('___\u7CEF')); +assertEquals('"___\u7DD5"', JSON.stringify('___\u7DD5')); +assertEquals('"___\u8DF1"', JSON.stringify('___\u8DF1')); +assertEquals('"___\u94A9"', JSON.stringify('___\u94A9')); +assertEquals('"___\u94F2"', JSON.stringify('___\u94F2')); +assertEquals('"___\u9A7A"', JSON.stringify('___\u9A7A')); +assertEquals('"___\u9AA6"', JSON.stringify('___\u9AA6')); +assertEquals('"___\uA2B0"', JSON.stringify('___\uA2B0')); +assertEquals('"___\uB711"', JSON.stringify('___\uB711')); +assertEquals('"___\uBC01"', JSON.stringify('___\uBC01')); +assertEquals('"___\uBCB6"', JSON.stringify('___\uBCB6')); +assertEquals('"___\uBD70"', JSON.stringify('___\uBD70')); +assertEquals('"___\uC3CD"', JSON.stringify('___\uC3CD')); +assertEquals('"___\uC451"', JSON.stringify('___\uC451')); +assertEquals('"___\uC677"', JSON.stringify('___\uC677')); +assertEquals('"___\uC89B"', JSON.stringify('___\uC89B')); +assertEquals('"___\uCBEF"', JSON.stringify('___\uCBEF')); +assertEquals('"___\uCEF8"', JSON.stringify('___\uCEF8')); +assertEquals('"___\uD089"', JSON.stringify('___\uD089')); +assertEquals('"___\uD24D"', JSON.stringify('___\uD24D')); +assertEquals('"___\uD3A7"', JSON.stringify('___\uD3A7')); +assertEquals('"___\uD7FF"', JSON.stringify('___\uD7FF')); + +// All lone surrogates, i.e. code points from U+D800 to U+DFFF. +assertEquals('"___\\ud800"', JSON.stringify('___\uD800')); +assertEquals('"___\\ud801"', JSON.stringify('___\uD801')); +assertEquals('"___\\ud802"', JSON.stringify('___\uD802')); +assertEquals('"___\\ud803"', JSON.stringify('___\uD803')); +assertEquals('"___\\ud804"', JSON.stringify('___\uD804')); +assertEquals('"___\\ud805"', JSON.stringify('___\uD805')); +assertEquals('"___\\ud806"', JSON.stringify('___\uD806')); +assertEquals('"___\\ud807"', JSON.stringify('___\uD807')); +assertEquals('"___\\ud808"', JSON.stringify('___\uD808')); +assertEquals('"___\\ud809"', JSON.stringify('___\uD809')); +assertEquals('"___\\ud80a"', JSON.stringify('___\uD80A')); +assertEquals('"___\\ud80b"', JSON.stringify('___\uD80B')); +assertEquals('"___\\ud80c"', JSON.stringify('___\uD80C')); +assertEquals('"___\\ud80d"', JSON.stringify('___\uD80D')); +assertEquals('"___\\ud80e"', JSON.stringify('___\uD80E')); +assertEquals('"___\\ud80f"', JSON.stringify('___\uD80F')); +assertEquals('"___\\ud810"', JSON.stringify('___\uD810')); +assertEquals('"___\\ud811"', JSON.stringify('___\uD811')); +assertEquals('"___\\ud812"', JSON.stringify('___\uD812')); +assertEquals('"___\\ud813"', JSON.stringify('___\uD813')); +assertEquals('"___\\ud814"', JSON.stringify('___\uD814')); +assertEquals('"___\\ud815"', JSON.stringify('___\uD815')); +assertEquals('"___\\ud816"', JSON.stringify('___\uD816')); +assertEquals('"___\\ud817"', JSON.stringify('___\uD817')); +assertEquals('"___\\ud818"', JSON.stringify('___\uD818')); +assertEquals('"___\\ud819"', JSON.stringify('___\uD819')); +assertEquals('"___\\ud81a"', JSON.stringify('___\uD81A')); +assertEquals('"___\\ud81b"', JSON.stringify('___\uD81B')); +assertEquals('"___\\ud81c"', JSON.stringify('___\uD81C')); +assertEquals('"___\\ud81d"', JSON.stringify('___\uD81D')); +assertEquals('"___\\ud81e"', JSON.stringify('___\uD81E')); +assertEquals('"___\\ud81f"', JSON.stringify('___\uD81F')); +assertEquals('"___\\ud820"', JSON.stringify('___\uD820')); +assertEquals('"___\\ud821"', JSON.stringify('___\uD821')); +assertEquals('"___\\ud822"', JSON.stringify('___\uD822')); +assertEquals('"___\\ud823"', JSON.stringify('___\uD823')); +assertEquals('"___\\ud824"', JSON.stringify('___\uD824')); +assertEquals('"___\\ud825"', JSON.stringify('___\uD825')); +assertEquals('"___\\ud826"', JSON.stringify('___\uD826')); +assertEquals('"___\\ud827"', JSON.stringify('___\uD827')); +assertEquals('"___\\ud828"', JSON.stringify('___\uD828')); +assertEquals('"___\\ud829"', JSON.stringify('___\uD829')); +assertEquals('"___\\ud82a"', JSON.stringify('___\uD82A')); +assertEquals('"___\\ud82b"', JSON.stringify('___\uD82B')); +assertEquals('"___\\ud82c"', JSON.stringify('___\uD82C')); +assertEquals('"___\\ud82d"', JSON.stringify('___\uD82D')); +assertEquals('"___\\ud82e"', JSON.stringify('___\uD82E')); +assertEquals('"___\\ud82f"', JSON.stringify('___\uD82F')); +assertEquals('"___\\ud830"', JSON.stringify('___\uD830')); +assertEquals('"___\\ud831"', JSON.stringify('___\uD831')); +assertEquals('"___\\ud832"', JSON.stringify('___\uD832')); +assertEquals('"___\\ud833"', JSON.stringify('___\uD833')); +assertEquals('"___\\ud834"', JSON.stringify('___\uD834')); +assertEquals('"___\\ud835"', JSON.stringify('___\uD835')); +assertEquals('"___\\ud836"', JSON.stringify('___\uD836')); +assertEquals('"___\\ud837"', JSON.stringify('___\uD837')); +assertEquals('"___\\ud838"', JSON.stringify('___\uD838')); +assertEquals('"___\\ud839"', JSON.stringify('___\uD839')); +assertEquals('"___\\ud83a"', JSON.stringify('___\uD83A')); +assertEquals('"___\\ud83b"', JSON.stringify('___\uD83B')); +assertEquals('"___\\ud83c"', JSON.stringify('___\uD83C')); +assertEquals('"___\\ud83d"', JSON.stringify('___\uD83D')); +assertEquals('"___\\ud83e"', JSON.stringify('___\uD83E')); +assertEquals('"___\\ud83f"', JSON.stringify('___\uD83F')); +assertEquals('"___\\ud840"', JSON.stringify('___\uD840')); +assertEquals('"___\\ud841"', JSON.stringify('___\uD841')); +assertEquals('"___\\ud842"', JSON.stringify('___\uD842')); +assertEquals('"___\\ud843"', JSON.stringify('___\uD843')); +assertEquals('"___\\ud844"', JSON.stringify('___\uD844')); +assertEquals('"___\\ud845"', JSON.stringify('___\uD845')); +assertEquals('"___\\ud846"', JSON.stringify('___\uD846')); +assertEquals('"___\\ud847"', JSON.stringify('___\uD847')); +assertEquals('"___\\ud848"', JSON.stringify('___\uD848')); +assertEquals('"___\\ud849"', JSON.stringify('___\uD849')); +assertEquals('"___\\ud84a"', JSON.stringify('___\uD84A')); +assertEquals('"___\\ud84b"', JSON.stringify('___\uD84B')); +assertEquals('"___\\ud84c"', JSON.stringify('___\uD84C')); +assertEquals('"___\\ud84d"', JSON.stringify('___\uD84D')); +assertEquals('"___\\ud84e"', JSON.stringify('___\uD84E')); +assertEquals('"___\\ud84f"', JSON.stringify('___\uD84F')); +assertEquals('"___\\ud850"', JSON.stringify('___\uD850')); +assertEquals('"___\\ud851"', JSON.stringify('___\uD851')); +assertEquals('"___\\ud852"', JSON.stringify('___\uD852')); +assertEquals('"___\\ud853"', JSON.stringify('___\uD853')); +assertEquals('"___\\ud854"', JSON.stringify('___\uD854')); +assertEquals('"___\\ud855"', JSON.stringify('___\uD855')); +assertEquals('"___\\ud856"', JSON.stringify('___\uD856')); +assertEquals('"___\\ud857"', JSON.stringify('___\uD857')); +assertEquals('"___\\ud858"', JSON.stringify('___\uD858')); +assertEquals('"___\\ud859"', JSON.stringify('___\uD859')); +assertEquals('"___\\ud85a"', JSON.stringify('___\uD85A')); +assertEquals('"___\\ud85b"', JSON.stringify('___\uD85B')); +assertEquals('"___\\ud85c"', JSON.stringify('___\uD85C')); +assertEquals('"___\\ud85d"', JSON.stringify('___\uD85D')); +assertEquals('"___\\ud85e"', JSON.stringify('___\uD85E')); +assertEquals('"___\\ud85f"', JSON.stringify('___\uD85F')); +assertEquals('"___\\ud860"', JSON.stringify('___\uD860')); +assertEquals('"___\\ud861"', JSON.stringify('___\uD861')); +assertEquals('"___\\ud862"', JSON.stringify('___\uD862')); +assertEquals('"___\\ud863"', JSON.stringify('___\uD863')); +assertEquals('"___\\ud864"', JSON.stringify('___\uD864')); +assertEquals('"___\\ud865"', JSON.stringify('___\uD865')); +assertEquals('"___\\ud866"', JSON.stringify('___\uD866')); +assertEquals('"___\\ud867"', JSON.stringify('___\uD867')); +assertEquals('"___\\ud868"', JSON.stringify('___\uD868')); +assertEquals('"___\\ud869"', JSON.stringify('___\uD869')); +assertEquals('"___\\ud86a"', JSON.stringify('___\uD86A')); +assertEquals('"___\\ud86b"', JSON.stringify('___\uD86B')); +assertEquals('"___\\ud86c"', JSON.stringify('___\uD86C')); +assertEquals('"___\\ud86d"', JSON.stringify('___\uD86D')); +assertEquals('"___\\ud86e"', JSON.stringify('___\uD86E')); +assertEquals('"___\\ud86f"', JSON.stringify('___\uD86F')); +assertEquals('"___\\ud870"', JSON.stringify('___\uD870')); +assertEquals('"___\\ud871"', JSON.stringify('___\uD871')); +assertEquals('"___\\ud872"', JSON.stringify('___\uD872')); +assertEquals('"___\\ud873"', JSON.stringify('___\uD873')); +assertEquals('"___\\ud874"', JSON.stringify('___\uD874')); +assertEquals('"___\\ud875"', JSON.stringify('___\uD875')); +assertEquals('"___\\ud876"', JSON.stringify('___\uD876')); +assertEquals('"___\\ud877"', JSON.stringify('___\uD877')); +assertEquals('"___\\ud878"', JSON.stringify('___\uD878')); +assertEquals('"___\\ud879"', JSON.stringify('___\uD879')); +assertEquals('"___\\ud87a"', JSON.stringify('___\uD87A')); +assertEquals('"___\\ud87b"', JSON.stringify('___\uD87B')); +assertEquals('"___\\ud87c"', JSON.stringify('___\uD87C')); +assertEquals('"___\\ud87d"', JSON.stringify('___\uD87D')); +assertEquals('"___\\ud87e"', JSON.stringify('___\uD87E')); +assertEquals('"___\\ud87f"', JSON.stringify('___\uD87F')); +assertEquals('"___\\ud880"', JSON.stringify('___\uD880')); +assertEquals('"___\\ud881"', JSON.stringify('___\uD881')); +assertEquals('"___\\ud882"', JSON.stringify('___\uD882')); +assertEquals('"___\\ud883"', JSON.stringify('___\uD883')); +assertEquals('"___\\ud884"', JSON.stringify('___\uD884')); +assertEquals('"___\\ud885"', JSON.stringify('___\uD885')); +assertEquals('"___\\ud886"', JSON.stringify('___\uD886')); +assertEquals('"___\\ud887"', JSON.stringify('___\uD887')); +assertEquals('"___\\ud888"', JSON.stringify('___\uD888')); +assertEquals('"___\\ud889"', JSON.stringify('___\uD889')); +assertEquals('"___\\ud88a"', JSON.stringify('___\uD88A')); +assertEquals('"___\\ud88b"', JSON.stringify('___\uD88B')); +assertEquals('"___\\ud88c"', JSON.stringify('___\uD88C')); +assertEquals('"___\\ud88d"', JSON.stringify('___\uD88D')); +assertEquals('"___\\ud88e"', JSON.stringify('___\uD88E')); +assertEquals('"___\\ud88f"', JSON.stringify('___\uD88F')); +assertEquals('"___\\ud890"', JSON.stringify('___\uD890')); +assertEquals('"___\\ud891"', JSON.stringify('___\uD891')); +assertEquals('"___\\ud892"', JSON.stringify('___\uD892')); +assertEquals('"___\\ud893"', JSON.stringify('___\uD893')); +assertEquals('"___\\ud894"', JSON.stringify('___\uD894')); +assertEquals('"___\\ud895"', JSON.stringify('___\uD895')); +assertEquals('"___\\ud896"', JSON.stringify('___\uD896')); +assertEquals('"___\\ud897"', JSON.stringify('___\uD897')); +assertEquals('"___\\ud898"', JSON.stringify('___\uD898')); +assertEquals('"___\\ud899"', JSON.stringify('___\uD899')); +assertEquals('"___\\ud89a"', JSON.stringify('___\uD89A')); +assertEquals('"___\\ud89b"', JSON.stringify('___\uD89B')); +assertEquals('"___\\ud89c"', JSON.stringify('___\uD89C')); +assertEquals('"___\\ud89d"', JSON.stringify('___\uD89D')); +assertEquals('"___\\ud89e"', JSON.stringify('___\uD89E')); +assertEquals('"___\\ud89f"', JSON.stringify('___\uD89F')); +assertEquals('"___\\ud8a0"', JSON.stringify('___\uD8A0')); +assertEquals('"___\\ud8a1"', JSON.stringify('___\uD8A1')); +assertEquals('"___\\ud8a2"', JSON.stringify('___\uD8A2')); +assertEquals('"___\\ud8a3"', JSON.stringify('___\uD8A3')); +assertEquals('"___\\ud8a4"', JSON.stringify('___\uD8A4')); +assertEquals('"___\\ud8a5"', JSON.stringify('___\uD8A5')); +assertEquals('"___\\ud8a6"', JSON.stringify('___\uD8A6')); +assertEquals('"___\\ud8a7"', JSON.stringify('___\uD8A7')); +assertEquals('"___\\ud8a8"', JSON.stringify('___\uD8A8')); +assertEquals('"___\\ud8a9"', JSON.stringify('___\uD8A9')); +assertEquals('"___\\ud8aa"', JSON.stringify('___\uD8AA')); +assertEquals('"___\\ud8ab"', JSON.stringify('___\uD8AB')); +assertEquals('"___\\ud8ac"', JSON.stringify('___\uD8AC')); +assertEquals('"___\\ud8ad"', JSON.stringify('___\uD8AD')); +assertEquals('"___\\ud8ae"', JSON.stringify('___\uD8AE')); +assertEquals('"___\\ud8af"', JSON.stringify('___\uD8AF')); +assertEquals('"___\\ud8b0"', JSON.stringify('___\uD8B0')); +assertEquals('"___\\ud8b1"', JSON.stringify('___\uD8B1')); +assertEquals('"___\\ud8b2"', JSON.stringify('___\uD8B2')); +assertEquals('"___\\ud8b3"', JSON.stringify('___\uD8B3')); +assertEquals('"___\\ud8b4"', JSON.stringify('___\uD8B4')); +assertEquals('"___\\ud8b5"', JSON.stringify('___\uD8B5')); +assertEquals('"___\\ud8b6"', JSON.stringify('___\uD8B6')); +assertEquals('"___\\ud8b7"', JSON.stringify('___\uD8B7')); +assertEquals('"___\\ud8b8"', JSON.stringify('___\uD8B8')); +assertEquals('"___\\ud8b9"', JSON.stringify('___\uD8B9')); +assertEquals('"___\\ud8ba"', JSON.stringify('___\uD8BA')); +assertEquals('"___\\ud8bb"', JSON.stringify('___\uD8BB')); +assertEquals('"___\\ud8bc"', JSON.stringify('___\uD8BC')); +assertEquals('"___\\ud8bd"', JSON.stringify('___\uD8BD')); +assertEquals('"___\\ud8be"', JSON.stringify('___\uD8BE')); +assertEquals('"___\\ud8bf"', JSON.stringify('___\uD8BF')); +assertEquals('"___\\ud8c0"', JSON.stringify('___\uD8C0')); +assertEquals('"___\\ud8c1"', JSON.stringify('___\uD8C1')); +assertEquals('"___\\ud8c2"', JSON.stringify('___\uD8C2')); +assertEquals('"___\\ud8c3"', JSON.stringify('___\uD8C3')); +assertEquals('"___\\ud8c4"', JSON.stringify('___\uD8C4')); +assertEquals('"___\\ud8c5"', JSON.stringify('___\uD8C5')); +assertEquals('"___\\ud8c6"', JSON.stringify('___\uD8C6')); +assertEquals('"___\\ud8c7"', JSON.stringify('___\uD8C7')); +assertEquals('"___\\ud8c8"', JSON.stringify('___\uD8C8')); +assertEquals('"___\\ud8c9"', JSON.stringify('___\uD8C9')); +assertEquals('"___\\ud8ca"', JSON.stringify('___\uD8CA')); +assertEquals('"___\\ud8cb"', JSON.stringify('___\uD8CB')); +assertEquals('"___\\ud8cc"', JSON.stringify('___\uD8CC')); +assertEquals('"___\\ud8cd"', JSON.stringify('___\uD8CD')); +assertEquals('"___\\ud8ce"', JSON.stringify('___\uD8CE')); +assertEquals('"___\\ud8cf"', JSON.stringify('___\uD8CF')); +assertEquals('"___\\ud8d0"', JSON.stringify('___\uD8D0')); +assertEquals('"___\\ud8d1"', JSON.stringify('___\uD8D1')); +assertEquals('"___\\ud8d2"', JSON.stringify('___\uD8D2')); +assertEquals('"___\\ud8d3"', JSON.stringify('___\uD8D3')); +assertEquals('"___\\ud8d4"', JSON.stringify('___\uD8D4')); +assertEquals('"___\\ud8d5"', JSON.stringify('___\uD8D5')); +assertEquals('"___\\ud8d6"', JSON.stringify('___\uD8D6')); +assertEquals('"___\\ud8d7"', JSON.stringify('___\uD8D7')); +assertEquals('"___\\ud8d8"', JSON.stringify('___\uD8D8')); +assertEquals('"___\\ud8d9"', JSON.stringify('___\uD8D9')); +assertEquals('"___\\ud8da"', JSON.stringify('___\uD8DA')); +assertEquals('"___\\ud8db"', JSON.stringify('___\uD8DB')); +assertEquals('"___\\ud8dc"', JSON.stringify('___\uD8DC')); +assertEquals('"___\\ud8dd"', JSON.stringify('___\uD8DD')); +assertEquals('"___\\ud8de"', JSON.stringify('___\uD8DE')); +assertEquals('"___\\ud8df"', JSON.stringify('___\uD8DF')); +assertEquals('"___\\ud8e0"', JSON.stringify('___\uD8E0')); +assertEquals('"___\\ud8e1"', JSON.stringify('___\uD8E1')); +assertEquals('"___\\ud8e2"', JSON.stringify('___\uD8E2')); +assertEquals('"___\\ud8e3"', JSON.stringify('___\uD8E3')); +assertEquals('"___\\ud8e4"', JSON.stringify('___\uD8E4')); +assertEquals('"___\\ud8e5"', JSON.stringify('___\uD8E5')); +assertEquals('"___\\ud8e6"', JSON.stringify('___\uD8E6')); +assertEquals('"___\\ud8e7"', JSON.stringify('___\uD8E7')); +assertEquals('"___\\ud8e8"', JSON.stringify('___\uD8E8')); +assertEquals('"___\\ud8e9"', JSON.stringify('___\uD8E9')); +assertEquals('"___\\ud8ea"', JSON.stringify('___\uD8EA')); +assertEquals('"___\\ud8eb"', JSON.stringify('___\uD8EB')); +assertEquals('"___\\ud8ec"', JSON.stringify('___\uD8EC')); +assertEquals('"___\\ud8ed"', JSON.stringify('___\uD8ED')); +assertEquals('"___\\ud8ee"', JSON.stringify('___\uD8EE')); +assertEquals('"___\\ud8ef"', JSON.stringify('___\uD8EF')); +assertEquals('"___\\ud8f0"', JSON.stringify('___\uD8F0')); +assertEquals('"___\\ud8f1"', JSON.stringify('___\uD8F1')); +assertEquals('"___\\ud8f2"', JSON.stringify('___\uD8F2')); +assertEquals('"___\\ud8f3"', JSON.stringify('___\uD8F3')); +assertEquals('"___\\ud8f4"', JSON.stringify('___\uD8F4')); +assertEquals('"___\\ud8f5"', JSON.stringify('___\uD8F5')); +assertEquals('"___\\ud8f6"', JSON.stringify('___\uD8F6')); +assertEquals('"___\\ud8f7"', JSON.stringify('___\uD8F7')); +assertEquals('"___\\ud8f8"', JSON.stringify('___\uD8F8')); +assertEquals('"___\\ud8f9"', JSON.stringify('___\uD8F9')); +assertEquals('"___\\ud8fa"', JSON.stringify('___\uD8FA')); +assertEquals('"___\\ud8fb"', JSON.stringify('___\uD8FB')); +assertEquals('"___\\ud8fc"', JSON.stringify('___\uD8FC')); +assertEquals('"___\\ud8fd"', JSON.stringify('___\uD8FD')); +assertEquals('"___\\ud8fe"', JSON.stringify('___\uD8FE')); +assertEquals('"___\\ud8ff"', JSON.stringify('___\uD8FF')); +assertEquals('"___\\ud900"', JSON.stringify('___\uD900')); +assertEquals('"___\\ud901"', JSON.stringify('___\uD901')); +assertEquals('"___\\ud902"', JSON.stringify('___\uD902')); +assertEquals('"___\\ud903"', JSON.stringify('___\uD903')); +assertEquals('"___\\ud904"', JSON.stringify('___\uD904')); +assertEquals('"___\\ud905"', JSON.stringify('___\uD905')); +assertEquals('"___\\ud906"', JSON.stringify('___\uD906')); +assertEquals('"___\\ud907"', JSON.stringify('___\uD907')); +assertEquals('"___\\ud908"', JSON.stringify('___\uD908')); +assertEquals('"___\\ud909"', JSON.stringify('___\uD909')); +assertEquals('"___\\ud90a"', JSON.stringify('___\uD90A')); +assertEquals('"___\\ud90b"', JSON.stringify('___\uD90B')); +assertEquals('"___\\ud90c"', JSON.stringify('___\uD90C')); +assertEquals('"___\\ud90d"', JSON.stringify('___\uD90D')); +assertEquals('"___\\ud90e"', JSON.stringify('___\uD90E')); +assertEquals('"___\\ud90f"', JSON.stringify('___\uD90F')); +assertEquals('"___\\ud910"', JSON.stringify('___\uD910')); +assertEquals('"___\\ud911"', JSON.stringify('___\uD911')); +assertEquals('"___\\ud912"', JSON.stringify('___\uD912')); +assertEquals('"___\\ud913"', JSON.stringify('___\uD913')); +assertEquals('"___\\ud914"', JSON.stringify('___\uD914')); +assertEquals('"___\\ud915"', JSON.stringify('___\uD915')); +assertEquals('"___\\ud916"', JSON.stringify('___\uD916')); +assertEquals('"___\\ud917"', JSON.stringify('___\uD917')); +assertEquals('"___\\ud918"', JSON.stringify('___\uD918')); +assertEquals('"___\\ud919"', JSON.stringify('___\uD919')); +assertEquals('"___\\ud91a"', JSON.stringify('___\uD91A')); +assertEquals('"___\\ud91b"', JSON.stringify('___\uD91B')); +assertEquals('"___\\ud91c"', JSON.stringify('___\uD91C')); +assertEquals('"___\\ud91d"', JSON.stringify('___\uD91D')); +assertEquals('"___\\ud91e"', JSON.stringify('___\uD91E')); +assertEquals('"___\\ud91f"', JSON.stringify('___\uD91F')); +assertEquals('"___\\ud920"', JSON.stringify('___\uD920')); +assertEquals('"___\\ud921"', JSON.stringify('___\uD921')); +assertEquals('"___\\ud922"', JSON.stringify('___\uD922')); +assertEquals('"___\\ud923"', JSON.stringify('___\uD923')); +assertEquals('"___\\ud924"', JSON.stringify('___\uD924')); +assertEquals('"___\\ud925"', JSON.stringify('___\uD925')); +assertEquals('"___\\ud926"', JSON.stringify('___\uD926')); +assertEquals('"___\\ud927"', JSON.stringify('___\uD927')); +assertEquals('"___\\ud928"', JSON.stringify('___\uD928')); +assertEquals('"___\\ud929"', JSON.stringify('___\uD929')); +assertEquals('"___\\ud92a"', JSON.stringify('___\uD92A')); +assertEquals('"___\\ud92b"', JSON.stringify('___\uD92B')); +assertEquals('"___\\ud92c"', JSON.stringify('___\uD92C')); +assertEquals('"___\\ud92d"', JSON.stringify('___\uD92D')); +assertEquals('"___\\ud92e"', JSON.stringify('___\uD92E')); +assertEquals('"___\\ud92f"', JSON.stringify('___\uD92F')); +assertEquals('"___\\ud930"', JSON.stringify('___\uD930')); +assertEquals('"___\\ud931"', JSON.stringify('___\uD931')); +assertEquals('"___\\ud932"', JSON.stringify('___\uD932')); +assertEquals('"___\\ud933"', JSON.stringify('___\uD933')); +assertEquals('"___\\ud934"', JSON.stringify('___\uD934')); +assertEquals('"___\\ud935"', JSON.stringify('___\uD935')); +assertEquals('"___\\ud936"', JSON.stringify('___\uD936')); +assertEquals('"___\\ud937"', JSON.stringify('___\uD937')); +assertEquals('"___\\ud938"', JSON.stringify('___\uD938')); +assertEquals('"___\\ud939"', JSON.stringify('___\uD939')); +assertEquals('"___\\ud93a"', JSON.stringify('___\uD93A')); +assertEquals('"___\\ud93b"', JSON.stringify('___\uD93B')); +assertEquals('"___\\ud93c"', JSON.stringify('___\uD93C')); +assertEquals('"___\\ud93d"', JSON.stringify('___\uD93D')); +assertEquals('"___\\ud93e"', JSON.stringify('___\uD93E')); +assertEquals('"___\\ud93f"', JSON.stringify('___\uD93F')); +assertEquals('"___\\ud940"', JSON.stringify('___\uD940')); +assertEquals('"___\\ud941"', JSON.stringify('___\uD941')); +assertEquals('"___\\ud942"', JSON.stringify('___\uD942')); +assertEquals('"___\\ud943"', JSON.stringify('___\uD943')); +assertEquals('"___\\ud944"', JSON.stringify('___\uD944')); +assertEquals('"___\\ud945"', JSON.stringify('___\uD945')); +assertEquals('"___\\ud946"', JSON.stringify('___\uD946')); +assertEquals('"___\\ud947"', JSON.stringify('___\uD947')); +assertEquals('"___\\ud948"', JSON.stringify('___\uD948')); +assertEquals('"___\\ud949"', JSON.stringify('___\uD949')); +assertEquals('"___\\ud94a"', JSON.stringify('___\uD94A')); +assertEquals('"___\\ud94b"', JSON.stringify('___\uD94B')); +assertEquals('"___\\ud94c"', JSON.stringify('___\uD94C')); +assertEquals('"___\\ud94d"', JSON.stringify('___\uD94D')); +assertEquals('"___\\ud94e"', JSON.stringify('___\uD94E')); +assertEquals('"___\\ud94f"', JSON.stringify('___\uD94F')); +assertEquals('"___\\ud950"', JSON.stringify('___\uD950')); +assertEquals('"___\\ud951"', JSON.stringify('___\uD951')); +assertEquals('"___\\ud952"', JSON.stringify('___\uD952')); +assertEquals('"___\\ud953"', JSON.stringify('___\uD953')); +assertEquals('"___\\ud954"', JSON.stringify('___\uD954')); +assertEquals('"___\\ud955"', JSON.stringify('___\uD955')); +assertEquals('"___\\ud956"', JSON.stringify('___\uD956')); +assertEquals('"___\\ud957"', JSON.stringify('___\uD957')); +assertEquals('"___\\ud958"', JSON.stringify('___\uD958')); +assertEquals('"___\\ud959"', JSON.stringify('___\uD959')); +assertEquals('"___\\ud95a"', JSON.stringify('___\uD95A')); +assertEquals('"___\\ud95b"', JSON.stringify('___\uD95B')); +assertEquals('"___\\ud95c"', JSON.stringify('___\uD95C')); +assertEquals('"___\\ud95d"', JSON.stringify('___\uD95D')); +assertEquals('"___\\ud95e"', JSON.stringify('___\uD95E')); +assertEquals('"___\\ud95f"', JSON.stringify('___\uD95F')); +assertEquals('"___\\ud960"', JSON.stringify('___\uD960')); +assertEquals('"___\\ud961"', JSON.stringify('___\uD961')); +assertEquals('"___\\ud962"', JSON.stringify('___\uD962')); +assertEquals('"___\\ud963"', JSON.stringify('___\uD963')); +assertEquals('"___\\ud964"', JSON.stringify('___\uD964')); +assertEquals('"___\\ud965"', JSON.stringify('___\uD965')); +assertEquals('"___\\ud966"', JSON.stringify('___\uD966')); +assertEquals('"___\\ud967"', JSON.stringify('___\uD967')); +assertEquals('"___\\ud968"', JSON.stringify('___\uD968')); +assertEquals('"___\\ud969"', JSON.stringify('___\uD969')); +assertEquals('"___\\ud96a"', JSON.stringify('___\uD96A')); +assertEquals('"___\\ud96b"', JSON.stringify('___\uD96B')); +assertEquals('"___\\ud96c"', JSON.stringify('___\uD96C')); +assertEquals('"___\\ud96d"', JSON.stringify('___\uD96D')); +assertEquals('"___\\ud96e"', JSON.stringify('___\uD96E')); +assertEquals('"___\\ud96f"', JSON.stringify('___\uD96F')); +assertEquals('"___\\ud970"', JSON.stringify('___\uD970')); +assertEquals('"___\\ud971"', JSON.stringify('___\uD971')); +assertEquals('"___\\ud972"', JSON.stringify('___\uD972')); +assertEquals('"___\\ud973"', JSON.stringify('___\uD973')); +assertEquals('"___\\ud974"', JSON.stringify('___\uD974')); +assertEquals('"___\\ud975"', JSON.stringify('___\uD975')); +assertEquals('"___\\ud976"', JSON.stringify('___\uD976')); +assertEquals('"___\\ud977"', JSON.stringify('___\uD977')); +assertEquals('"___\\ud978"', JSON.stringify('___\uD978')); +assertEquals('"___\\ud979"', JSON.stringify('___\uD979')); +assertEquals('"___\\ud97a"', JSON.stringify('___\uD97A')); +assertEquals('"___\\ud97b"', JSON.stringify('___\uD97B')); +assertEquals('"___\\ud97c"', JSON.stringify('___\uD97C')); +assertEquals('"___\\ud97d"', JSON.stringify('___\uD97D')); +assertEquals('"___\\ud97e"', JSON.stringify('___\uD97E')); +assertEquals('"___\\ud97f"', JSON.stringify('___\uD97F')); +assertEquals('"___\\ud980"', JSON.stringify('___\uD980')); +assertEquals('"___\\ud981"', JSON.stringify('___\uD981')); +assertEquals('"___\\ud982"', JSON.stringify('___\uD982')); +assertEquals('"___\\ud983"', JSON.stringify('___\uD983')); +assertEquals('"___\\ud984"', JSON.stringify('___\uD984')); +assertEquals('"___\\ud985"', JSON.stringify('___\uD985')); +assertEquals('"___\\ud986"', JSON.stringify('___\uD986')); +assertEquals('"___\\ud987"', JSON.stringify('___\uD987')); +assertEquals('"___\\ud988"', JSON.stringify('___\uD988')); +assertEquals('"___\\ud989"', JSON.stringify('___\uD989')); +assertEquals('"___\\ud98a"', JSON.stringify('___\uD98A')); +assertEquals('"___\\ud98b"', JSON.stringify('___\uD98B')); +assertEquals('"___\\ud98c"', JSON.stringify('___\uD98C')); +assertEquals('"___\\ud98d"', JSON.stringify('___\uD98D')); +assertEquals('"___\\ud98e"', JSON.stringify('___\uD98E')); +assertEquals('"___\\ud98f"', JSON.stringify('___\uD98F')); +assertEquals('"___\\ud990"', JSON.stringify('___\uD990')); +assertEquals('"___\\ud991"', JSON.stringify('___\uD991')); +assertEquals('"___\\ud992"', JSON.stringify('___\uD992')); +assertEquals('"___\\ud993"', JSON.stringify('___\uD993')); +assertEquals('"___\\ud994"', JSON.stringify('___\uD994')); +assertEquals('"___\\ud995"', JSON.stringify('___\uD995')); +assertEquals('"___\\ud996"', JSON.stringify('___\uD996')); +assertEquals('"___\\ud997"', JSON.stringify('___\uD997')); +assertEquals('"___\\ud998"', JSON.stringify('___\uD998')); +assertEquals('"___\\ud999"', JSON.stringify('___\uD999')); +assertEquals('"___\\ud99a"', JSON.stringify('___\uD99A')); +assertEquals('"___\\ud99b"', JSON.stringify('___\uD99B')); +assertEquals('"___\\ud99c"', JSON.stringify('___\uD99C')); +assertEquals('"___\\ud99d"', JSON.stringify('___\uD99D')); +assertEquals('"___\\ud99e"', JSON.stringify('___\uD99E')); +assertEquals('"___\\ud99f"', JSON.stringify('___\uD99F')); +assertEquals('"___\\ud9a0"', JSON.stringify('___\uD9A0')); +assertEquals('"___\\ud9a1"', JSON.stringify('___\uD9A1')); +assertEquals('"___\\ud9a2"', JSON.stringify('___\uD9A2')); +assertEquals('"___\\ud9a3"', JSON.stringify('___\uD9A3')); +assertEquals('"___\\ud9a4"', JSON.stringify('___\uD9A4')); +assertEquals('"___\\ud9a5"', JSON.stringify('___\uD9A5')); +assertEquals('"___\\ud9a6"', JSON.stringify('___\uD9A6')); +assertEquals('"___\\ud9a7"', JSON.stringify('___\uD9A7')); +assertEquals('"___\\ud9a8"', JSON.stringify('___\uD9A8')); +assertEquals('"___\\ud9a9"', JSON.stringify('___\uD9A9')); +assertEquals('"___\\ud9aa"', JSON.stringify('___\uD9AA')); +assertEquals('"___\\ud9ab"', JSON.stringify('___\uD9AB')); +assertEquals('"___\\ud9ac"', JSON.stringify('___\uD9AC')); +assertEquals('"___\\ud9ad"', JSON.stringify('___\uD9AD')); +assertEquals('"___\\ud9ae"', JSON.stringify('___\uD9AE')); +assertEquals('"___\\ud9af"', JSON.stringify('___\uD9AF')); +assertEquals('"___\\ud9b0"', JSON.stringify('___\uD9B0')); +assertEquals('"___\\ud9b1"', JSON.stringify('___\uD9B1')); +assertEquals('"___\\ud9b2"', JSON.stringify('___\uD9B2')); +assertEquals('"___\\ud9b3"', JSON.stringify('___\uD9B3')); +assertEquals('"___\\ud9b4"', JSON.stringify('___\uD9B4')); +assertEquals('"___\\ud9b5"', JSON.stringify('___\uD9B5')); +assertEquals('"___\\ud9b6"', JSON.stringify('___\uD9B6')); +assertEquals('"___\\ud9b7"', JSON.stringify('___\uD9B7')); +assertEquals('"___\\ud9b8"', JSON.stringify('___\uD9B8')); +assertEquals('"___\\ud9b9"', JSON.stringify('___\uD9B9')); +assertEquals('"___\\ud9ba"', JSON.stringify('___\uD9BA')); +assertEquals('"___\\ud9bb"', JSON.stringify('___\uD9BB')); +assertEquals('"___\\ud9bc"', JSON.stringify('___\uD9BC')); +assertEquals('"___\\ud9bd"', JSON.stringify('___\uD9BD')); +assertEquals('"___\\ud9be"', JSON.stringify('___\uD9BE')); +assertEquals('"___\\ud9bf"', JSON.stringify('___\uD9BF')); +assertEquals('"___\\ud9c0"', JSON.stringify('___\uD9C0')); +assertEquals('"___\\ud9c1"', JSON.stringify('___\uD9C1')); +assertEquals('"___\\ud9c2"', JSON.stringify('___\uD9C2')); +assertEquals('"___\\ud9c3"', JSON.stringify('___\uD9C3')); +assertEquals('"___\\ud9c4"', JSON.stringify('___\uD9C4')); +assertEquals('"___\\ud9c5"', JSON.stringify('___\uD9C5')); +assertEquals('"___\\ud9c6"', JSON.stringify('___\uD9C6')); +assertEquals('"___\\ud9c7"', JSON.stringify('___\uD9C7')); +assertEquals('"___\\ud9c8"', JSON.stringify('___\uD9C8')); +assertEquals('"___\\ud9c9"', JSON.stringify('___\uD9C9')); +assertEquals('"___\\ud9ca"', JSON.stringify('___\uD9CA')); +assertEquals('"___\\ud9cb"', JSON.stringify('___\uD9CB')); +assertEquals('"___\\ud9cc"', JSON.stringify('___\uD9CC')); +assertEquals('"___\\ud9cd"', JSON.stringify('___\uD9CD')); +assertEquals('"___\\ud9ce"', JSON.stringify('___\uD9CE')); +assertEquals('"___\\ud9cf"', JSON.stringify('___\uD9CF')); +assertEquals('"___\\ud9d0"', JSON.stringify('___\uD9D0')); +assertEquals('"___\\ud9d1"', JSON.stringify('___\uD9D1')); +assertEquals('"___\\ud9d2"', JSON.stringify('___\uD9D2')); +assertEquals('"___\\ud9d3"', JSON.stringify('___\uD9D3')); +assertEquals('"___\\ud9d4"', JSON.stringify('___\uD9D4')); +assertEquals('"___\\ud9d5"', JSON.stringify('___\uD9D5')); +assertEquals('"___\\ud9d6"', JSON.stringify('___\uD9D6')); +assertEquals('"___\\ud9d7"', JSON.stringify('___\uD9D7')); +assertEquals('"___\\ud9d8"', JSON.stringify('___\uD9D8')); +assertEquals('"___\\ud9d9"', JSON.stringify('___\uD9D9')); +assertEquals('"___\\ud9da"', JSON.stringify('___\uD9DA')); +assertEquals('"___\\ud9db"', JSON.stringify('___\uD9DB')); +assertEquals('"___\\ud9dc"', JSON.stringify('___\uD9DC')); +assertEquals('"___\\ud9dd"', JSON.stringify('___\uD9DD')); +assertEquals('"___\\ud9de"', JSON.stringify('___\uD9DE')); +assertEquals('"___\\ud9df"', JSON.stringify('___\uD9DF')); +assertEquals('"___\\ud9e0"', JSON.stringify('___\uD9E0')); +assertEquals('"___\\ud9e1"', JSON.stringify('___\uD9E1')); +assertEquals('"___\\ud9e2"', JSON.stringify('___\uD9E2')); +assertEquals('"___\\ud9e3"', JSON.stringify('___\uD9E3')); +assertEquals('"___\\ud9e4"', JSON.stringify('___\uD9E4')); +assertEquals('"___\\ud9e5"', JSON.stringify('___\uD9E5')); +assertEquals('"___\\ud9e6"', JSON.stringify('___\uD9E6')); +assertEquals('"___\\ud9e7"', JSON.stringify('___\uD9E7')); +assertEquals('"___\\ud9e8"', JSON.stringify('___\uD9E8')); +assertEquals('"___\\ud9e9"', JSON.stringify('___\uD9E9')); +assertEquals('"___\\ud9ea"', JSON.stringify('___\uD9EA')); +assertEquals('"___\\ud9eb"', JSON.stringify('___\uD9EB')); +assertEquals('"___\\ud9ec"', JSON.stringify('___\uD9EC')); +assertEquals('"___\\ud9ed"', JSON.stringify('___\uD9ED')); +assertEquals('"___\\ud9ee"', JSON.stringify('___\uD9EE')); +assertEquals('"___\\ud9ef"', JSON.stringify('___\uD9EF')); +assertEquals('"___\\ud9f0"', JSON.stringify('___\uD9F0')); +assertEquals('"___\\ud9f1"', JSON.stringify('___\uD9F1')); +assertEquals('"___\\ud9f2"', JSON.stringify('___\uD9F2')); +assertEquals('"___\\ud9f3"', JSON.stringify('___\uD9F3')); +assertEquals('"___\\ud9f4"', JSON.stringify('___\uD9F4')); +assertEquals('"___\\ud9f5"', JSON.stringify('___\uD9F5')); +assertEquals('"___\\ud9f6"', JSON.stringify('___\uD9F6')); +assertEquals('"___\\ud9f7"', JSON.stringify('___\uD9F7')); +assertEquals('"___\\ud9f8"', JSON.stringify('___\uD9F8')); +assertEquals('"___\\ud9f9"', JSON.stringify('___\uD9F9')); +assertEquals('"___\\ud9fa"', JSON.stringify('___\uD9FA')); +assertEquals('"___\\ud9fb"', JSON.stringify('___\uD9FB')); +assertEquals('"___\\ud9fc"', JSON.stringify('___\uD9FC')); +assertEquals('"___\\ud9fd"', JSON.stringify('___\uD9FD')); +assertEquals('"___\\ud9fe"', JSON.stringify('___\uD9FE')); +assertEquals('"___\\ud9ff"', JSON.stringify('___\uD9FF')); +assertEquals('"___\\uda00"', JSON.stringify('___\uDA00')); +assertEquals('"___\\uda01"', JSON.stringify('___\uDA01')); +assertEquals('"___\\uda02"', JSON.stringify('___\uDA02')); +assertEquals('"___\\uda03"', JSON.stringify('___\uDA03')); +assertEquals('"___\\uda04"', JSON.stringify('___\uDA04')); +assertEquals('"___\\uda05"', JSON.stringify('___\uDA05')); +assertEquals('"___\\uda06"', JSON.stringify('___\uDA06')); +assertEquals('"___\\uda07"', JSON.stringify('___\uDA07')); +assertEquals('"___\\uda08"', JSON.stringify('___\uDA08')); +assertEquals('"___\\uda09"', JSON.stringify('___\uDA09')); +assertEquals('"___\\uda0a"', JSON.stringify('___\uDA0A')); +assertEquals('"___\\uda0b"', JSON.stringify('___\uDA0B')); +assertEquals('"___\\uda0c"', JSON.stringify('___\uDA0C')); +assertEquals('"___\\uda0d"', JSON.stringify('___\uDA0D')); +assertEquals('"___\\uda0e"', JSON.stringify('___\uDA0E')); +assertEquals('"___\\uda0f"', JSON.stringify('___\uDA0F')); +assertEquals('"___\\uda10"', JSON.stringify('___\uDA10')); +assertEquals('"___\\uda11"', JSON.stringify('___\uDA11')); +assertEquals('"___\\uda12"', JSON.stringify('___\uDA12')); +assertEquals('"___\\uda13"', JSON.stringify('___\uDA13')); +assertEquals('"___\\uda14"', JSON.stringify('___\uDA14')); +assertEquals('"___\\uda15"', JSON.stringify('___\uDA15')); +assertEquals('"___\\uda16"', JSON.stringify('___\uDA16')); +assertEquals('"___\\uda17"', JSON.stringify('___\uDA17')); +assertEquals('"___\\uda18"', JSON.stringify('___\uDA18')); +assertEquals('"___\\uda19"', JSON.stringify('___\uDA19')); +assertEquals('"___\\uda1a"', JSON.stringify('___\uDA1A')); +assertEquals('"___\\uda1b"', JSON.stringify('___\uDA1B')); +assertEquals('"___\\uda1c"', JSON.stringify('___\uDA1C')); +assertEquals('"___\\uda1d"', JSON.stringify('___\uDA1D')); +assertEquals('"___\\uda1e"', JSON.stringify('___\uDA1E')); +assertEquals('"___\\uda1f"', JSON.stringify('___\uDA1F')); +assertEquals('"___\\uda20"', JSON.stringify('___\uDA20')); +assertEquals('"___\\uda21"', JSON.stringify('___\uDA21')); +assertEquals('"___\\uda22"', JSON.stringify('___\uDA22')); +assertEquals('"___\\uda23"', JSON.stringify('___\uDA23')); +assertEquals('"___\\uda24"', JSON.stringify('___\uDA24')); +assertEquals('"___\\uda25"', JSON.stringify('___\uDA25')); +assertEquals('"___\\uda26"', JSON.stringify('___\uDA26')); +assertEquals('"___\\uda27"', JSON.stringify('___\uDA27')); +assertEquals('"___\\uda28"', JSON.stringify('___\uDA28')); +assertEquals('"___\\uda29"', JSON.stringify('___\uDA29')); +assertEquals('"___\\uda2a"', JSON.stringify('___\uDA2A')); +assertEquals('"___\\uda2b"', JSON.stringify('___\uDA2B')); +assertEquals('"___\\uda2c"', JSON.stringify('___\uDA2C')); +assertEquals('"___\\uda2d"', JSON.stringify('___\uDA2D')); +assertEquals('"___\\uda2e"', JSON.stringify('___\uDA2E')); +assertEquals('"___\\uda2f"', JSON.stringify('___\uDA2F')); +assertEquals('"___\\uda30"', JSON.stringify('___\uDA30')); +assertEquals('"___\\uda31"', JSON.stringify('___\uDA31')); +assertEquals('"___\\uda32"', JSON.stringify('___\uDA32')); +assertEquals('"___\\uda33"', JSON.stringify('___\uDA33')); +assertEquals('"___\\uda34"', JSON.stringify('___\uDA34')); +assertEquals('"___\\uda35"', JSON.stringify('___\uDA35')); +assertEquals('"___\\uda36"', JSON.stringify('___\uDA36')); +assertEquals('"___\\uda37"', JSON.stringify('___\uDA37')); +assertEquals('"___\\uda38"', JSON.stringify('___\uDA38')); +assertEquals('"___\\uda39"', JSON.stringify('___\uDA39')); +assertEquals('"___\\uda3a"', JSON.stringify('___\uDA3A')); +assertEquals('"___\\uda3b"', JSON.stringify('___\uDA3B')); +assertEquals('"___\\uda3c"', JSON.stringify('___\uDA3C')); +assertEquals('"___\\uda3d"', JSON.stringify('___\uDA3D')); +assertEquals('"___\\uda3e"', JSON.stringify('___\uDA3E')); +assertEquals('"___\\uda3f"', JSON.stringify('___\uDA3F')); +assertEquals('"___\\uda40"', JSON.stringify('___\uDA40')); +assertEquals('"___\\uda41"', JSON.stringify('___\uDA41')); +assertEquals('"___\\uda42"', JSON.stringify('___\uDA42')); +assertEquals('"___\\uda43"', JSON.stringify('___\uDA43')); +assertEquals('"___\\uda44"', JSON.stringify('___\uDA44')); +assertEquals('"___\\uda45"', JSON.stringify('___\uDA45')); +assertEquals('"___\\uda46"', JSON.stringify('___\uDA46')); +assertEquals('"___\\uda47"', JSON.stringify('___\uDA47')); +assertEquals('"___\\uda48"', JSON.stringify('___\uDA48')); +assertEquals('"___\\uda49"', JSON.stringify('___\uDA49')); +assertEquals('"___\\uda4a"', JSON.stringify('___\uDA4A')); +assertEquals('"___\\uda4b"', JSON.stringify('___\uDA4B')); +assertEquals('"___\\uda4c"', JSON.stringify('___\uDA4C')); +assertEquals('"___\\uda4d"', JSON.stringify('___\uDA4D')); +assertEquals('"___\\uda4e"', JSON.stringify('___\uDA4E')); +assertEquals('"___\\uda4f"', JSON.stringify('___\uDA4F')); +assertEquals('"___\\uda50"', JSON.stringify('___\uDA50')); +assertEquals('"___\\uda51"', JSON.stringify('___\uDA51')); +assertEquals('"___\\uda52"', JSON.stringify('___\uDA52')); +assertEquals('"___\\uda53"', JSON.stringify('___\uDA53')); +assertEquals('"___\\uda54"', JSON.stringify('___\uDA54')); +assertEquals('"___\\uda55"', JSON.stringify('___\uDA55')); +assertEquals('"___\\uda56"', JSON.stringify('___\uDA56')); +assertEquals('"___\\uda57"', JSON.stringify('___\uDA57')); +assertEquals('"___\\uda58"', JSON.stringify('___\uDA58')); +assertEquals('"___\\uda59"', JSON.stringify('___\uDA59')); +assertEquals('"___\\uda5a"', JSON.stringify('___\uDA5A')); +assertEquals('"___\\uda5b"', JSON.stringify('___\uDA5B')); +assertEquals('"___\\uda5c"', JSON.stringify('___\uDA5C')); +assertEquals('"___\\uda5d"', JSON.stringify('___\uDA5D')); +assertEquals('"___\\uda5e"', JSON.stringify('___\uDA5E')); +assertEquals('"___\\uda5f"', JSON.stringify('___\uDA5F')); +assertEquals('"___\\uda60"', JSON.stringify('___\uDA60')); +assertEquals('"___\\uda61"', JSON.stringify('___\uDA61')); +assertEquals('"___\\uda62"', JSON.stringify('___\uDA62')); +assertEquals('"___\\uda63"', JSON.stringify('___\uDA63')); +assertEquals('"___\\uda64"', JSON.stringify('___\uDA64')); +assertEquals('"___\\uda65"', JSON.stringify('___\uDA65')); +assertEquals('"___\\uda66"', JSON.stringify('___\uDA66')); +assertEquals('"___\\uda67"', JSON.stringify('___\uDA67')); +assertEquals('"___\\uda68"', JSON.stringify('___\uDA68')); +assertEquals('"___\\uda69"', JSON.stringify('___\uDA69')); +assertEquals('"___\\uda6a"', JSON.stringify('___\uDA6A')); +assertEquals('"___\\uda6b"', JSON.stringify('___\uDA6B')); +assertEquals('"___\\uda6c"', JSON.stringify('___\uDA6C')); +assertEquals('"___\\uda6d"', JSON.stringify('___\uDA6D')); +assertEquals('"___\\uda6e"', JSON.stringify('___\uDA6E')); +assertEquals('"___\\uda6f"', JSON.stringify('___\uDA6F')); +assertEquals('"___\\uda70"', JSON.stringify('___\uDA70')); +assertEquals('"___\\uda71"', JSON.stringify('___\uDA71')); +assertEquals('"___\\uda72"', JSON.stringify('___\uDA72')); +assertEquals('"___\\uda73"', JSON.stringify('___\uDA73')); +assertEquals('"___\\uda74"', JSON.stringify('___\uDA74')); +assertEquals('"___\\uda75"', JSON.stringify('___\uDA75')); +assertEquals('"___\\uda76"', JSON.stringify('___\uDA76')); +assertEquals('"___\\uda77"', JSON.stringify('___\uDA77')); +assertEquals('"___\\uda78"', JSON.stringify('___\uDA78')); +assertEquals('"___\\uda79"', JSON.stringify('___\uDA79')); +assertEquals('"___\\uda7a"', JSON.stringify('___\uDA7A')); +assertEquals('"___\\uda7b"', JSON.stringify('___\uDA7B')); +assertEquals('"___\\uda7c"', JSON.stringify('___\uDA7C')); +assertEquals('"___\\uda7d"', JSON.stringify('___\uDA7D')); +assertEquals('"___\\uda7e"', JSON.stringify('___\uDA7E')); +assertEquals('"___\\uda7f"', JSON.stringify('___\uDA7F')); +assertEquals('"___\\uda80"', JSON.stringify('___\uDA80')); +assertEquals('"___\\uda81"', JSON.stringify('___\uDA81')); +assertEquals('"___\\uda82"', JSON.stringify('___\uDA82')); +assertEquals('"___\\uda83"', JSON.stringify('___\uDA83')); +assertEquals('"___\\uda84"', JSON.stringify('___\uDA84')); +assertEquals('"___\\uda85"', JSON.stringify('___\uDA85')); +assertEquals('"___\\uda86"', JSON.stringify('___\uDA86')); +assertEquals('"___\\uda87"', JSON.stringify('___\uDA87')); +assertEquals('"___\\uda88"', JSON.stringify('___\uDA88')); +assertEquals('"___\\uda89"', JSON.stringify('___\uDA89')); +assertEquals('"___\\uda8a"', JSON.stringify('___\uDA8A')); +assertEquals('"___\\uda8b"', JSON.stringify('___\uDA8B')); +assertEquals('"___\\uda8c"', JSON.stringify('___\uDA8C')); +assertEquals('"___\\uda8d"', JSON.stringify('___\uDA8D')); +assertEquals('"___\\uda8e"', JSON.stringify('___\uDA8E')); +assertEquals('"___\\uda8f"', JSON.stringify('___\uDA8F')); +assertEquals('"___\\uda90"', JSON.stringify('___\uDA90')); +assertEquals('"___\\uda91"', JSON.stringify('___\uDA91')); +assertEquals('"___\\uda92"', JSON.stringify('___\uDA92')); +assertEquals('"___\\uda93"', JSON.stringify('___\uDA93')); +assertEquals('"___\\uda94"', JSON.stringify('___\uDA94')); +assertEquals('"___\\uda95"', JSON.stringify('___\uDA95')); +assertEquals('"___\\uda96"', JSON.stringify('___\uDA96')); +assertEquals('"___\\uda97"', JSON.stringify('___\uDA97')); +assertEquals('"___\\uda98"', JSON.stringify('___\uDA98')); +assertEquals('"___\\uda99"', JSON.stringify('___\uDA99')); +assertEquals('"___\\uda9a"', JSON.stringify('___\uDA9A')); +assertEquals('"___\\uda9b"', JSON.stringify('___\uDA9B')); +assertEquals('"___\\uda9c"', JSON.stringify('___\uDA9C')); +assertEquals('"___\\uda9d"', JSON.stringify('___\uDA9D')); +assertEquals('"___\\uda9e"', JSON.stringify('___\uDA9E')); +assertEquals('"___\\uda9f"', JSON.stringify('___\uDA9F')); +assertEquals('"___\\udaa0"', JSON.stringify('___\uDAA0')); +assertEquals('"___\\udaa1"', JSON.stringify('___\uDAA1')); +assertEquals('"___\\udaa2"', JSON.stringify('___\uDAA2')); +assertEquals('"___\\udaa3"', JSON.stringify('___\uDAA3')); +assertEquals('"___\\udaa4"', JSON.stringify('___\uDAA4')); +assertEquals('"___\\udaa5"', JSON.stringify('___\uDAA5')); +assertEquals('"___\\udaa6"', JSON.stringify('___\uDAA6')); +assertEquals('"___\\udaa7"', JSON.stringify('___\uDAA7')); +assertEquals('"___\\udaa8"', JSON.stringify('___\uDAA8')); +assertEquals('"___\\udaa9"', JSON.stringify('___\uDAA9')); +assertEquals('"___\\udaaa"', JSON.stringify('___\uDAAA')); +assertEquals('"___\\udaab"', JSON.stringify('___\uDAAB')); +assertEquals('"___\\udaac"', JSON.stringify('___\uDAAC')); +assertEquals('"___\\udaad"', JSON.stringify('___\uDAAD')); +assertEquals('"___\\udaae"', JSON.stringify('___\uDAAE')); +assertEquals('"___\\udaaf"', JSON.stringify('___\uDAAF')); +assertEquals('"___\\udab0"', JSON.stringify('___\uDAB0')); +assertEquals('"___\\udab1"', JSON.stringify('___\uDAB1')); +assertEquals('"___\\udab2"', JSON.stringify('___\uDAB2')); +assertEquals('"___\\udab3"', JSON.stringify('___\uDAB3')); +assertEquals('"___\\udab4"', JSON.stringify('___\uDAB4')); +assertEquals('"___\\udab5"', JSON.stringify('___\uDAB5')); +assertEquals('"___\\udab6"', JSON.stringify('___\uDAB6')); +assertEquals('"___\\udab7"', JSON.stringify('___\uDAB7')); +assertEquals('"___\\udab8"', JSON.stringify('___\uDAB8')); +assertEquals('"___\\udab9"', JSON.stringify('___\uDAB9')); +assertEquals('"___\\udaba"', JSON.stringify('___\uDABA')); +assertEquals('"___\\udabb"', JSON.stringify('___\uDABB')); +assertEquals('"___\\udabc"', JSON.stringify('___\uDABC')); +assertEquals('"___\\udabd"', JSON.stringify('___\uDABD')); +assertEquals('"___\\udabe"', JSON.stringify('___\uDABE')); +assertEquals('"___\\udabf"', JSON.stringify('___\uDABF')); +assertEquals('"___\\udac0"', JSON.stringify('___\uDAC0')); +assertEquals('"___\\udac1"', JSON.stringify('___\uDAC1')); +assertEquals('"___\\udac2"', JSON.stringify('___\uDAC2')); +assertEquals('"___\\udac3"', JSON.stringify('___\uDAC3')); +assertEquals('"___\\udac4"', JSON.stringify('___\uDAC4')); +assertEquals('"___\\udac5"', JSON.stringify('___\uDAC5')); +assertEquals('"___\\udac6"', JSON.stringify('___\uDAC6')); +assertEquals('"___\\udac7"', JSON.stringify('___\uDAC7')); +assertEquals('"___\\udac8"', JSON.stringify('___\uDAC8')); +assertEquals('"___\\udac9"', JSON.stringify('___\uDAC9')); +assertEquals('"___\\udaca"', JSON.stringify('___\uDACA')); +assertEquals('"___\\udacb"', JSON.stringify('___\uDACB')); +assertEquals('"___\\udacc"', JSON.stringify('___\uDACC')); +assertEquals('"___\\udacd"', JSON.stringify('___\uDACD')); +assertEquals('"___\\udace"', JSON.stringify('___\uDACE')); +assertEquals('"___\\udacf"', JSON.stringify('___\uDACF')); +assertEquals('"___\\udad0"', JSON.stringify('___\uDAD0')); +assertEquals('"___\\udad1"', JSON.stringify('___\uDAD1')); +assertEquals('"___\\udad2"', JSON.stringify('___\uDAD2')); +assertEquals('"___\\udad3"', JSON.stringify('___\uDAD3')); +assertEquals('"___\\udad4"', JSON.stringify('___\uDAD4')); +assertEquals('"___\\udad5"', JSON.stringify('___\uDAD5')); +assertEquals('"___\\udad6"', JSON.stringify('___\uDAD6')); +assertEquals('"___\\udad7"', JSON.stringify('___\uDAD7')); +assertEquals('"___\\udad8"', JSON.stringify('___\uDAD8')); +assertEquals('"___\\udad9"', JSON.stringify('___\uDAD9')); +assertEquals('"___\\udada"', JSON.stringify('___\uDADA')); +assertEquals('"___\\udadb"', JSON.stringify('___\uDADB')); +assertEquals('"___\\udadc"', JSON.stringify('___\uDADC')); +assertEquals('"___\\udadd"', JSON.stringify('___\uDADD')); +assertEquals('"___\\udade"', JSON.stringify('___\uDADE')); +assertEquals('"___\\udadf"', JSON.stringify('___\uDADF')); +assertEquals('"___\\udae0"', JSON.stringify('___\uDAE0')); +assertEquals('"___\\udae1"', JSON.stringify('___\uDAE1')); +assertEquals('"___\\udae2"', JSON.stringify('___\uDAE2')); +assertEquals('"___\\udae3"', JSON.stringify('___\uDAE3')); +assertEquals('"___\\udae4"', JSON.stringify('___\uDAE4')); +assertEquals('"___\\udae5"', JSON.stringify('___\uDAE5')); +assertEquals('"___\\udae6"', JSON.stringify('___\uDAE6')); +assertEquals('"___\\udae7"', JSON.stringify('___\uDAE7')); +assertEquals('"___\\udae8"', JSON.stringify('___\uDAE8')); +assertEquals('"___\\udae9"', JSON.stringify('___\uDAE9')); +assertEquals('"___\\udaea"', JSON.stringify('___\uDAEA')); +assertEquals('"___\\udaeb"', JSON.stringify('___\uDAEB')); +assertEquals('"___\\udaec"', JSON.stringify('___\uDAEC')); +assertEquals('"___\\udaed"', JSON.stringify('___\uDAED')); +assertEquals('"___\\udaee"', JSON.stringify('___\uDAEE')); +assertEquals('"___\\udaef"', JSON.stringify('___\uDAEF')); +assertEquals('"___\\udaf0"', JSON.stringify('___\uDAF0')); +assertEquals('"___\\udaf1"', JSON.stringify('___\uDAF1')); +assertEquals('"___\\udaf2"', JSON.stringify('___\uDAF2')); +assertEquals('"___\\udaf3"', JSON.stringify('___\uDAF3')); +assertEquals('"___\\udaf4"', JSON.stringify('___\uDAF4')); +assertEquals('"___\\udaf5"', JSON.stringify('___\uDAF5')); +assertEquals('"___\\udaf6"', JSON.stringify('___\uDAF6')); +assertEquals('"___\\udaf7"', JSON.stringify('___\uDAF7')); +assertEquals('"___\\udaf8"', JSON.stringify('___\uDAF8')); +assertEquals('"___\\udaf9"', JSON.stringify('___\uDAF9')); +assertEquals('"___\\udafa"', JSON.stringify('___\uDAFA')); +assertEquals('"___\\udafb"', JSON.stringify('___\uDAFB')); +assertEquals('"___\\udafc"', JSON.stringify('___\uDAFC')); +assertEquals('"___\\udafd"', JSON.stringify('___\uDAFD')); +assertEquals('"___\\udafe"', JSON.stringify('___\uDAFE')); +assertEquals('"___\\udaff"', JSON.stringify('___\uDAFF')); +assertEquals('"___\\udb00"', JSON.stringify('___\uDB00')); +assertEquals('"___\\udb01"', JSON.stringify('___\uDB01')); +assertEquals('"___\\udb02"', JSON.stringify('___\uDB02')); +assertEquals('"___\\udb03"', JSON.stringify('___\uDB03')); +assertEquals('"___\\udb04"', JSON.stringify('___\uDB04')); +assertEquals('"___\\udb05"', JSON.stringify('___\uDB05')); +assertEquals('"___\\udb06"', JSON.stringify('___\uDB06')); +assertEquals('"___\\udb07"', JSON.stringify('___\uDB07')); +assertEquals('"___\\udb08"', JSON.stringify('___\uDB08')); +assertEquals('"___\\udb09"', JSON.stringify('___\uDB09')); +assertEquals('"___\\udb0a"', JSON.stringify('___\uDB0A')); +assertEquals('"___\\udb0b"', JSON.stringify('___\uDB0B')); +assertEquals('"___\\udb0c"', JSON.stringify('___\uDB0C')); +assertEquals('"___\\udb0d"', JSON.stringify('___\uDB0D')); +assertEquals('"___\\udb0e"', JSON.stringify('___\uDB0E')); +assertEquals('"___\\udb0f"', JSON.stringify('___\uDB0F')); +assertEquals('"___\\udb10"', JSON.stringify('___\uDB10')); +assertEquals('"___\\udb11"', JSON.stringify('___\uDB11')); +assertEquals('"___\\udb12"', JSON.stringify('___\uDB12')); +assertEquals('"___\\udb13"', JSON.stringify('___\uDB13')); +assertEquals('"___\\udb14"', JSON.stringify('___\uDB14')); +assertEquals('"___\\udb15"', JSON.stringify('___\uDB15')); +assertEquals('"___\\udb16"', JSON.stringify('___\uDB16')); +assertEquals('"___\\udb17"', JSON.stringify('___\uDB17')); +assertEquals('"___\\udb18"', JSON.stringify('___\uDB18')); +assertEquals('"___\\udb19"', JSON.stringify('___\uDB19')); +assertEquals('"___\\udb1a"', JSON.stringify('___\uDB1A')); +assertEquals('"___\\udb1b"', JSON.stringify('___\uDB1B')); +assertEquals('"___\\udb1c"', JSON.stringify('___\uDB1C')); +assertEquals('"___\\udb1d"', JSON.stringify('___\uDB1D')); +assertEquals('"___\\udb1e"', JSON.stringify('___\uDB1E')); +assertEquals('"___\\udb1f"', JSON.stringify('___\uDB1F')); +assertEquals('"___\\udb20"', JSON.stringify('___\uDB20')); +assertEquals('"___\\udb21"', JSON.stringify('___\uDB21')); +assertEquals('"___\\udb22"', JSON.stringify('___\uDB22')); +assertEquals('"___\\udb23"', JSON.stringify('___\uDB23')); +assertEquals('"___\\udb24"', JSON.stringify('___\uDB24')); +assertEquals('"___\\udb25"', JSON.stringify('___\uDB25')); +assertEquals('"___\\udb26"', JSON.stringify('___\uDB26')); +assertEquals('"___\\udb27"', JSON.stringify('___\uDB27')); +assertEquals('"___\\udb28"', JSON.stringify('___\uDB28')); +assertEquals('"___\\udb29"', JSON.stringify('___\uDB29')); +assertEquals('"___\\udb2a"', JSON.stringify('___\uDB2A')); +assertEquals('"___\\udb2b"', JSON.stringify('___\uDB2B')); +assertEquals('"___\\udb2c"', JSON.stringify('___\uDB2C')); +assertEquals('"___\\udb2d"', JSON.stringify('___\uDB2D')); +assertEquals('"___\\udb2e"', JSON.stringify('___\uDB2E')); +assertEquals('"___\\udb2f"', JSON.stringify('___\uDB2F')); +assertEquals('"___\\udb30"', JSON.stringify('___\uDB30')); +assertEquals('"___\\udb31"', JSON.stringify('___\uDB31')); +assertEquals('"___\\udb32"', JSON.stringify('___\uDB32')); +assertEquals('"___\\udb33"', JSON.stringify('___\uDB33')); +assertEquals('"___\\udb34"', JSON.stringify('___\uDB34')); +assertEquals('"___\\udb35"', JSON.stringify('___\uDB35')); +assertEquals('"___\\udb36"', JSON.stringify('___\uDB36')); +assertEquals('"___\\udb37"', JSON.stringify('___\uDB37')); +assertEquals('"___\\udb38"', JSON.stringify('___\uDB38')); +assertEquals('"___\\udb39"', JSON.stringify('___\uDB39')); +assertEquals('"___\\udb3a"', JSON.stringify('___\uDB3A')); +assertEquals('"___\\udb3b"', JSON.stringify('___\uDB3B')); +assertEquals('"___\\udb3c"', JSON.stringify('___\uDB3C')); +assertEquals('"___\\udb3d"', JSON.stringify('___\uDB3D')); +assertEquals('"___\\udb3e"', JSON.stringify('___\uDB3E')); +assertEquals('"___\\udb3f"', JSON.stringify('___\uDB3F')); +assertEquals('"___\\udb40"', JSON.stringify('___\uDB40')); +assertEquals('"___\\udb41"', JSON.stringify('___\uDB41')); +assertEquals('"___\\udb42"', JSON.stringify('___\uDB42')); +assertEquals('"___\\udb43"', JSON.stringify('___\uDB43')); +assertEquals('"___\\udb44"', JSON.stringify('___\uDB44')); +assertEquals('"___\\udb45"', JSON.stringify('___\uDB45')); +assertEquals('"___\\udb46"', JSON.stringify('___\uDB46')); +assertEquals('"___\\udb47"', JSON.stringify('___\uDB47')); +assertEquals('"___\\udb48"', JSON.stringify('___\uDB48')); +assertEquals('"___\\udb49"', JSON.stringify('___\uDB49')); +assertEquals('"___\\udb4a"', JSON.stringify('___\uDB4A')); +assertEquals('"___\\udb4b"', JSON.stringify('___\uDB4B')); +assertEquals('"___\\udb4c"', JSON.stringify('___\uDB4C')); +assertEquals('"___\\udb4d"', JSON.stringify('___\uDB4D')); +assertEquals('"___\\udb4e"', JSON.stringify('___\uDB4E')); +assertEquals('"___\\udb4f"', JSON.stringify('___\uDB4F')); +assertEquals('"___\\udb50"', JSON.stringify('___\uDB50')); +assertEquals('"___\\udb51"', JSON.stringify('___\uDB51')); +assertEquals('"___\\udb52"', JSON.stringify('___\uDB52')); +assertEquals('"___\\udb53"', JSON.stringify('___\uDB53')); +assertEquals('"___\\udb54"', JSON.stringify('___\uDB54')); +assertEquals('"___\\udb55"', JSON.stringify('___\uDB55')); +assertEquals('"___\\udb56"', JSON.stringify('___\uDB56')); +assertEquals('"___\\udb57"', JSON.stringify('___\uDB57')); +assertEquals('"___\\udb58"', JSON.stringify('___\uDB58')); +assertEquals('"___\\udb59"', JSON.stringify('___\uDB59')); +assertEquals('"___\\udb5a"', JSON.stringify('___\uDB5A')); +assertEquals('"___\\udb5b"', JSON.stringify('___\uDB5B')); +assertEquals('"___\\udb5c"', JSON.stringify('___\uDB5C')); +assertEquals('"___\\udb5d"', JSON.stringify('___\uDB5D')); +assertEquals('"___\\udb5e"', JSON.stringify('___\uDB5E')); +assertEquals('"___\\udb5f"', JSON.stringify('___\uDB5F')); +assertEquals('"___\\udb60"', JSON.stringify('___\uDB60')); +assertEquals('"___\\udb61"', JSON.stringify('___\uDB61')); +assertEquals('"___\\udb62"', JSON.stringify('___\uDB62')); +assertEquals('"___\\udb63"', JSON.stringify('___\uDB63')); +assertEquals('"___\\udb64"', JSON.stringify('___\uDB64')); +assertEquals('"___\\udb65"', JSON.stringify('___\uDB65')); +assertEquals('"___\\udb66"', JSON.stringify('___\uDB66')); +assertEquals('"___\\udb67"', JSON.stringify('___\uDB67')); +assertEquals('"___\\udb68"', JSON.stringify('___\uDB68')); +assertEquals('"___\\udb69"', JSON.stringify('___\uDB69')); +assertEquals('"___\\udb6a"', JSON.stringify('___\uDB6A')); +assertEquals('"___\\udb6b"', JSON.stringify('___\uDB6B')); +assertEquals('"___\\udb6c"', JSON.stringify('___\uDB6C')); +assertEquals('"___\\udb6d"', JSON.stringify('___\uDB6D')); +assertEquals('"___\\udb6e"', JSON.stringify('___\uDB6E')); +assertEquals('"___\\udb6f"', JSON.stringify('___\uDB6F')); +assertEquals('"___\\udb70"', JSON.stringify('___\uDB70')); +assertEquals('"___\\udb71"', JSON.stringify('___\uDB71')); +assertEquals('"___\\udb72"', JSON.stringify('___\uDB72')); +assertEquals('"___\\udb73"', JSON.stringify('___\uDB73')); +assertEquals('"___\\udb74"', JSON.stringify('___\uDB74')); +assertEquals('"___\\udb75"', JSON.stringify('___\uDB75')); +assertEquals('"___\\udb76"', JSON.stringify('___\uDB76')); +assertEquals('"___\\udb77"', JSON.stringify('___\uDB77')); +assertEquals('"___\\udb78"', JSON.stringify('___\uDB78')); +assertEquals('"___\\udb79"', JSON.stringify('___\uDB79')); +assertEquals('"___\\udb7a"', JSON.stringify('___\uDB7A')); +assertEquals('"___\\udb7b"', JSON.stringify('___\uDB7B')); +assertEquals('"___\\udb7c"', JSON.stringify('___\uDB7C')); +assertEquals('"___\\udb7d"', JSON.stringify('___\uDB7D')); +assertEquals('"___\\udb7e"', JSON.stringify('___\uDB7E')); +assertEquals('"___\\udb7f"', JSON.stringify('___\uDB7F')); +assertEquals('"___\\udb80"', JSON.stringify('___\uDB80')); +assertEquals('"___\\udb81"', JSON.stringify('___\uDB81')); +assertEquals('"___\\udb82"', JSON.stringify('___\uDB82')); +assertEquals('"___\\udb83"', JSON.stringify('___\uDB83')); +assertEquals('"___\\udb84"', JSON.stringify('___\uDB84')); +assertEquals('"___\\udb85"', JSON.stringify('___\uDB85')); +assertEquals('"___\\udb86"', JSON.stringify('___\uDB86')); +assertEquals('"___\\udb87"', JSON.stringify('___\uDB87')); +assertEquals('"___\\udb88"', JSON.stringify('___\uDB88')); +assertEquals('"___\\udb89"', JSON.stringify('___\uDB89')); +assertEquals('"___\\udb8a"', JSON.stringify('___\uDB8A')); +assertEquals('"___\\udb8b"', JSON.stringify('___\uDB8B')); +assertEquals('"___\\udb8c"', JSON.stringify('___\uDB8C')); +assertEquals('"___\\udb8d"', JSON.stringify('___\uDB8D')); +assertEquals('"___\\udb8e"', JSON.stringify('___\uDB8E')); +assertEquals('"___\\udb8f"', JSON.stringify('___\uDB8F')); +assertEquals('"___\\udb90"', JSON.stringify('___\uDB90')); +assertEquals('"___\\udb91"', JSON.stringify('___\uDB91')); +assertEquals('"___\\udb92"', JSON.stringify('___\uDB92')); +assertEquals('"___\\udb93"', JSON.stringify('___\uDB93')); +assertEquals('"___\\udb94"', JSON.stringify('___\uDB94')); +assertEquals('"___\\udb95"', JSON.stringify('___\uDB95')); +assertEquals('"___\\udb96"', JSON.stringify('___\uDB96')); +assertEquals('"___\\udb97"', JSON.stringify('___\uDB97')); +assertEquals('"___\\udb98"', JSON.stringify('___\uDB98')); +assertEquals('"___\\udb99"', JSON.stringify('___\uDB99')); +assertEquals('"___\\udb9a"', JSON.stringify('___\uDB9A')); +assertEquals('"___\\udb9b"', JSON.stringify('___\uDB9B')); +assertEquals('"___\\udb9c"', JSON.stringify('___\uDB9C')); +assertEquals('"___\\udb9d"', JSON.stringify('___\uDB9D')); +assertEquals('"___\\udb9e"', JSON.stringify('___\uDB9E')); +assertEquals('"___\\udb9f"', JSON.stringify('___\uDB9F')); +assertEquals('"___\\udba0"', JSON.stringify('___\uDBA0')); +assertEquals('"___\\udba1"', JSON.stringify('___\uDBA1')); +assertEquals('"___\\udba2"', JSON.stringify('___\uDBA2')); +assertEquals('"___\\udba3"', JSON.stringify('___\uDBA3')); +assertEquals('"___\\udba4"', JSON.stringify('___\uDBA4')); +assertEquals('"___\\udba5"', JSON.stringify('___\uDBA5')); +assertEquals('"___\\udba6"', JSON.stringify('___\uDBA6')); +assertEquals('"___\\udba7"', JSON.stringify('___\uDBA7')); +assertEquals('"___\\udba8"', JSON.stringify('___\uDBA8')); +assertEquals('"___\\udba9"', JSON.stringify('___\uDBA9')); +assertEquals('"___\\udbaa"', JSON.stringify('___\uDBAA')); +assertEquals('"___\\udbab"', JSON.stringify('___\uDBAB')); +assertEquals('"___\\udbac"', JSON.stringify('___\uDBAC')); +assertEquals('"___\\udbad"', JSON.stringify('___\uDBAD')); +assertEquals('"___\\udbae"', JSON.stringify('___\uDBAE')); +assertEquals('"___\\udbaf"', JSON.stringify('___\uDBAF')); +assertEquals('"___\\udbb0"', JSON.stringify('___\uDBB0')); +assertEquals('"___\\udbb1"', JSON.stringify('___\uDBB1')); +assertEquals('"___\\udbb2"', JSON.stringify('___\uDBB2')); +assertEquals('"___\\udbb3"', JSON.stringify('___\uDBB3')); +assertEquals('"___\\udbb4"', JSON.stringify('___\uDBB4')); +assertEquals('"___\\udbb5"', JSON.stringify('___\uDBB5')); +assertEquals('"___\\udbb6"', JSON.stringify('___\uDBB6')); +assertEquals('"___\\udbb7"', JSON.stringify('___\uDBB7')); +assertEquals('"___\\udbb8"', JSON.stringify('___\uDBB8')); +assertEquals('"___\\udbb9"', JSON.stringify('___\uDBB9')); +assertEquals('"___\\udbba"', JSON.stringify('___\uDBBA')); +assertEquals('"___\\udbbb"', JSON.stringify('___\uDBBB')); +assertEquals('"___\\udbbc"', JSON.stringify('___\uDBBC')); +assertEquals('"___\\udbbd"', JSON.stringify('___\uDBBD')); +assertEquals('"___\\udbbe"', JSON.stringify('___\uDBBE')); +assertEquals('"___\\udbbf"', JSON.stringify('___\uDBBF')); +assertEquals('"___\\udbc0"', JSON.stringify('___\uDBC0')); +assertEquals('"___\\udbc1"', JSON.stringify('___\uDBC1')); +assertEquals('"___\\udbc2"', JSON.stringify('___\uDBC2')); +assertEquals('"___\\udbc3"', JSON.stringify('___\uDBC3')); +assertEquals('"___\\udbc4"', JSON.stringify('___\uDBC4')); +assertEquals('"___\\udbc5"', JSON.stringify('___\uDBC5')); +assertEquals('"___\\udbc6"', JSON.stringify('___\uDBC6')); +assertEquals('"___\\udbc7"', JSON.stringify('___\uDBC7')); +assertEquals('"___\\udbc8"', JSON.stringify('___\uDBC8')); +assertEquals('"___\\udbc9"', JSON.stringify('___\uDBC9')); +assertEquals('"___\\udbca"', JSON.stringify('___\uDBCA')); +assertEquals('"___\\udbcb"', JSON.stringify('___\uDBCB')); +assertEquals('"___\\udbcc"', JSON.stringify('___\uDBCC')); +assertEquals('"___\\udbcd"', JSON.stringify('___\uDBCD')); +assertEquals('"___\\udbce"', JSON.stringify('___\uDBCE')); +assertEquals('"___\\udbcf"', JSON.stringify('___\uDBCF')); +assertEquals('"___\\udbd0"', JSON.stringify('___\uDBD0')); +assertEquals('"___\\udbd1"', JSON.stringify('___\uDBD1')); +assertEquals('"___\\udbd2"', JSON.stringify('___\uDBD2')); +assertEquals('"___\\udbd3"', JSON.stringify('___\uDBD3')); +assertEquals('"___\\udbd4"', JSON.stringify('___\uDBD4')); +assertEquals('"___\\udbd5"', JSON.stringify('___\uDBD5')); +assertEquals('"___\\udbd6"', JSON.stringify('___\uDBD6')); +assertEquals('"___\\udbd7"', JSON.stringify('___\uDBD7')); +assertEquals('"___\\udbd8"', JSON.stringify('___\uDBD8')); +assertEquals('"___\\udbd9"', JSON.stringify('___\uDBD9')); +assertEquals('"___\\udbda"', JSON.stringify('___\uDBDA')); +assertEquals('"___\\udbdb"', JSON.stringify('___\uDBDB')); +assertEquals('"___\\udbdc"', JSON.stringify('___\uDBDC')); +assertEquals('"___\\udbdd"', JSON.stringify('___\uDBDD')); +assertEquals('"___\\udbde"', JSON.stringify('___\uDBDE')); +assertEquals('"___\\udbdf"', JSON.stringify('___\uDBDF')); +assertEquals('"___\\udbe0"', JSON.stringify('___\uDBE0')); +assertEquals('"___\\udbe1"', JSON.stringify('___\uDBE1')); +assertEquals('"___\\udbe2"', JSON.stringify('___\uDBE2')); +assertEquals('"___\\udbe3"', JSON.stringify('___\uDBE3')); +assertEquals('"___\\udbe4"', JSON.stringify('___\uDBE4')); +assertEquals('"___\\udbe5"', JSON.stringify('___\uDBE5')); +assertEquals('"___\\udbe6"', JSON.stringify('___\uDBE6')); +assertEquals('"___\\udbe7"', JSON.stringify('___\uDBE7')); +assertEquals('"___\\udbe8"', JSON.stringify('___\uDBE8')); +assertEquals('"___\\udbe9"', JSON.stringify('___\uDBE9')); +assertEquals('"___\\udbea"', JSON.stringify('___\uDBEA')); +assertEquals('"___\\udbeb"', JSON.stringify('___\uDBEB')); +assertEquals('"___\\udbec"', JSON.stringify('___\uDBEC')); +assertEquals('"___\\udbed"', JSON.stringify('___\uDBED')); +assertEquals('"___\\udbee"', JSON.stringify('___\uDBEE')); +assertEquals('"___\\udbef"', JSON.stringify('___\uDBEF')); +assertEquals('"___\\udbf0"', JSON.stringify('___\uDBF0')); +assertEquals('"___\\udbf1"', JSON.stringify('___\uDBF1')); +assertEquals('"___\\udbf2"', JSON.stringify('___\uDBF2')); +assertEquals('"___\\udbf3"', JSON.stringify('___\uDBF3')); +assertEquals('"___\\udbf4"', JSON.stringify('___\uDBF4')); +assertEquals('"___\\udbf5"', JSON.stringify('___\uDBF5')); +assertEquals('"___\\udbf6"', JSON.stringify('___\uDBF6')); +assertEquals('"___\\udbf7"', JSON.stringify('___\uDBF7')); +assertEquals('"___\\udbf8"', JSON.stringify('___\uDBF8')); +assertEquals('"___\\udbf9"', JSON.stringify('___\uDBF9')); +assertEquals('"___\\udbfa"', JSON.stringify('___\uDBFA')); +assertEquals('"___\\udbfb"', JSON.stringify('___\uDBFB')); +assertEquals('"___\\udbfc"', JSON.stringify('___\uDBFC')); +assertEquals('"___\\udbfd"', JSON.stringify('___\uDBFD')); +assertEquals('"___\\udbfe"', JSON.stringify('___\uDBFE')); +assertEquals('"___\\udbff"', JSON.stringify('___\uDBFF')); +assertEquals('"___\\udc00"', JSON.stringify('___\uDC00')); +assertEquals('"___\\udc01"', JSON.stringify('___\uDC01')); +assertEquals('"___\\udc02"', JSON.stringify('___\uDC02')); +assertEquals('"___\\udc03"', JSON.stringify('___\uDC03')); +assertEquals('"___\\udc04"', JSON.stringify('___\uDC04')); +assertEquals('"___\\udc05"', JSON.stringify('___\uDC05')); +assertEquals('"___\\udc06"', JSON.stringify('___\uDC06')); +assertEquals('"___\\udc07"', JSON.stringify('___\uDC07')); +assertEquals('"___\\udc08"', JSON.stringify('___\uDC08')); +assertEquals('"___\\udc09"', JSON.stringify('___\uDC09')); +assertEquals('"___\\udc0a"', JSON.stringify('___\uDC0A')); +assertEquals('"___\\udc0b"', JSON.stringify('___\uDC0B')); +assertEquals('"___\\udc0c"', JSON.stringify('___\uDC0C')); +assertEquals('"___\\udc0d"', JSON.stringify('___\uDC0D')); +assertEquals('"___\\udc0e"', JSON.stringify('___\uDC0E')); +assertEquals('"___\\udc0f"', JSON.stringify('___\uDC0F')); +assertEquals('"___\\udc10"', JSON.stringify('___\uDC10')); +assertEquals('"___\\udc11"', JSON.stringify('___\uDC11')); +assertEquals('"___\\udc12"', JSON.stringify('___\uDC12')); +assertEquals('"___\\udc13"', JSON.stringify('___\uDC13')); +assertEquals('"___\\udc14"', JSON.stringify('___\uDC14')); +assertEquals('"___\\udc15"', JSON.stringify('___\uDC15')); +assertEquals('"___\\udc16"', JSON.stringify('___\uDC16')); +assertEquals('"___\\udc17"', JSON.stringify('___\uDC17')); +assertEquals('"___\\udc18"', JSON.stringify('___\uDC18')); +assertEquals('"___\\udc19"', JSON.stringify('___\uDC19')); +assertEquals('"___\\udc1a"', JSON.stringify('___\uDC1A')); +assertEquals('"___\\udc1b"', JSON.stringify('___\uDC1B')); +assertEquals('"___\\udc1c"', JSON.stringify('___\uDC1C')); +assertEquals('"___\\udc1d"', JSON.stringify('___\uDC1D')); +assertEquals('"___\\udc1e"', JSON.stringify('___\uDC1E')); +assertEquals('"___\\udc1f"', JSON.stringify('___\uDC1F')); +assertEquals('"___\\udc20"', JSON.stringify('___\uDC20')); +assertEquals('"___\\udc21"', JSON.stringify('___\uDC21')); +assertEquals('"___\\udc22"', JSON.stringify('___\uDC22')); +assertEquals('"___\\udc23"', JSON.stringify('___\uDC23')); +assertEquals('"___\\udc24"', JSON.stringify('___\uDC24')); +assertEquals('"___\\udc25"', JSON.stringify('___\uDC25')); +assertEquals('"___\\udc26"', JSON.stringify('___\uDC26')); +assertEquals('"___\\udc27"', JSON.stringify('___\uDC27')); +assertEquals('"___\\udc28"', JSON.stringify('___\uDC28')); +assertEquals('"___\\udc29"', JSON.stringify('___\uDC29')); +assertEquals('"___\\udc2a"', JSON.stringify('___\uDC2A')); +assertEquals('"___\\udc2b"', JSON.stringify('___\uDC2B')); +assertEquals('"___\\udc2c"', JSON.stringify('___\uDC2C')); +assertEquals('"___\\udc2d"', JSON.stringify('___\uDC2D')); +assertEquals('"___\\udc2e"', JSON.stringify('___\uDC2E')); +assertEquals('"___\\udc2f"', JSON.stringify('___\uDC2F')); +assertEquals('"___\\udc30"', JSON.stringify('___\uDC30')); +assertEquals('"___\\udc31"', JSON.stringify('___\uDC31')); +assertEquals('"___\\udc32"', JSON.stringify('___\uDC32')); +assertEquals('"___\\udc33"', JSON.stringify('___\uDC33')); +assertEquals('"___\\udc34"', JSON.stringify('___\uDC34')); +assertEquals('"___\\udc35"', JSON.stringify('___\uDC35')); +assertEquals('"___\\udc36"', JSON.stringify('___\uDC36')); +assertEquals('"___\\udc37"', JSON.stringify('___\uDC37')); +assertEquals('"___\\udc38"', JSON.stringify('___\uDC38')); +assertEquals('"___\\udc39"', JSON.stringify('___\uDC39')); +assertEquals('"___\\udc3a"', JSON.stringify('___\uDC3A')); +assertEquals('"___\\udc3b"', JSON.stringify('___\uDC3B')); +assertEquals('"___\\udc3c"', JSON.stringify('___\uDC3C')); +assertEquals('"___\\udc3d"', JSON.stringify('___\uDC3D')); +assertEquals('"___\\udc3e"', JSON.stringify('___\uDC3E')); +assertEquals('"___\\udc3f"', JSON.stringify('___\uDC3F')); +assertEquals('"___\\udc40"', JSON.stringify('___\uDC40')); +assertEquals('"___\\udc41"', JSON.stringify('___\uDC41')); +assertEquals('"___\\udc42"', JSON.stringify('___\uDC42')); +assertEquals('"___\\udc43"', JSON.stringify('___\uDC43')); +assertEquals('"___\\udc44"', JSON.stringify('___\uDC44')); +assertEquals('"___\\udc45"', JSON.stringify('___\uDC45')); +assertEquals('"___\\udc46"', JSON.stringify('___\uDC46')); +assertEquals('"___\\udc47"', JSON.stringify('___\uDC47')); +assertEquals('"___\\udc48"', JSON.stringify('___\uDC48')); +assertEquals('"___\\udc49"', JSON.stringify('___\uDC49')); +assertEquals('"___\\udc4a"', JSON.stringify('___\uDC4A')); +assertEquals('"___\\udc4b"', JSON.stringify('___\uDC4B')); +assertEquals('"___\\udc4c"', JSON.stringify('___\uDC4C')); +assertEquals('"___\\udc4d"', JSON.stringify('___\uDC4D')); +assertEquals('"___\\udc4e"', JSON.stringify('___\uDC4E')); +assertEquals('"___\\udc4f"', JSON.stringify('___\uDC4F')); +assertEquals('"___\\udc50"', JSON.stringify('___\uDC50')); +assertEquals('"___\\udc51"', JSON.stringify('___\uDC51')); +assertEquals('"___\\udc52"', JSON.stringify('___\uDC52')); +assertEquals('"___\\udc53"', JSON.stringify('___\uDC53')); +assertEquals('"___\\udc54"', JSON.stringify('___\uDC54')); +assertEquals('"___\\udc55"', JSON.stringify('___\uDC55')); +assertEquals('"___\\udc56"', JSON.stringify('___\uDC56')); +assertEquals('"___\\udc57"', JSON.stringify('___\uDC57')); +assertEquals('"___\\udc58"', JSON.stringify('___\uDC58')); +assertEquals('"___\\udc59"', JSON.stringify('___\uDC59')); +assertEquals('"___\\udc5a"', JSON.stringify('___\uDC5A')); +assertEquals('"___\\udc5b"', JSON.stringify('___\uDC5B')); +assertEquals('"___\\udc5c"', JSON.stringify('___\uDC5C')); +assertEquals('"___\\udc5d"', JSON.stringify('___\uDC5D')); +assertEquals('"___\\udc5e"', JSON.stringify('___\uDC5E')); +assertEquals('"___\\udc5f"', JSON.stringify('___\uDC5F')); +assertEquals('"___\\udc60"', JSON.stringify('___\uDC60')); +assertEquals('"___\\udc61"', JSON.stringify('___\uDC61')); +assertEquals('"___\\udc62"', JSON.stringify('___\uDC62')); +assertEquals('"___\\udc63"', JSON.stringify('___\uDC63')); +assertEquals('"___\\udc64"', JSON.stringify('___\uDC64')); +assertEquals('"___\\udc65"', JSON.stringify('___\uDC65')); +assertEquals('"___\\udc66"', JSON.stringify('___\uDC66')); +assertEquals('"___\\udc67"', JSON.stringify('___\uDC67')); +assertEquals('"___\\udc68"', JSON.stringify('___\uDC68')); +assertEquals('"___\\udc69"', JSON.stringify('___\uDC69')); +assertEquals('"___\\udc6a"', JSON.stringify('___\uDC6A')); +assertEquals('"___\\udc6b"', JSON.stringify('___\uDC6B')); +assertEquals('"___\\udc6c"', JSON.stringify('___\uDC6C')); +assertEquals('"___\\udc6d"', JSON.stringify('___\uDC6D')); +assertEquals('"___\\udc6e"', JSON.stringify('___\uDC6E')); +assertEquals('"___\\udc6f"', JSON.stringify('___\uDC6F')); +assertEquals('"___\\udc70"', JSON.stringify('___\uDC70')); +assertEquals('"___\\udc71"', JSON.stringify('___\uDC71')); +assertEquals('"___\\udc72"', JSON.stringify('___\uDC72')); +assertEquals('"___\\udc73"', JSON.stringify('___\uDC73')); +assertEquals('"___\\udc74"', JSON.stringify('___\uDC74')); +assertEquals('"___\\udc75"', JSON.stringify('___\uDC75')); +assertEquals('"___\\udc76"', JSON.stringify('___\uDC76')); +assertEquals('"___\\udc77"', JSON.stringify('___\uDC77')); +assertEquals('"___\\udc78"', JSON.stringify('___\uDC78')); +assertEquals('"___\\udc79"', JSON.stringify('___\uDC79')); +assertEquals('"___\\udc7a"', JSON.stringify('___\uDC7A')); +assertEquals('"___\\udc7b"', JSON.stringify('___\uDC7B')); +assertEquals('"___\\udc7c"', JSON.stringify('___\uDC7C')); +assertEquals('"___\\udc7d"', JSON.stringify('___\uDC7D')); +assertEquals('"___\\udc7e"', JSON.stringify('___\uDC7E')); +assertEquals('"___\\udc7f"', JSON.stringify('___\uDC7F')); +assertEquals('"___\\udc80"', JSON.stringify('___\uDC80')); +assertEquals('"___\\udc81"', JSON.stringify('___\uDC81')); +assertEquals('"___\\udc82"', JSON.stringify('___\uDC82')); +assertEquals('"___\\udc83"', JSON.stringify('___\uDC83')); +assertEquals('"___\\udc84"', JSON.stringify('___\uDC84')); +assertEquals('"___\\udc85"', JSON.stringify('___\uDC85')); +assertEquals('"___\\udc86"', JSON.stringify('___\uDC86')); +assertEquals('"___\\udc87"', JSON.stringify('___\uDC87')); +assertEquals('"___\\udc88"', JSON.stringify('___\uDC88')); +assertEquals('"___\\udc89"', JSON.stringify('___\uDC89')); +assertEquals('"___\\udc8a"', JSON.stringify('___\uDC8A')); +assertEquals('"___\\udc8b"', JSON.stringify('___\uDC8B')); +assertEquals('"___\\udc8c"', JSON.stringify('___\uDC8C')); +assertEquals('"___\\udc8d"', JSON.stringify('___\uDC8D')); +assertEquals('"___\\udc8e"', JSON.stringify('___\uDC8E')); +assertEquals('"___\\udc8f"', JSON.stringify('___\uDC8F')); +assertEquals('"___\\udc90"', JSON.stringify('___\uDC90')); +assertEquals('"___\\udc91"', JSON.stringify('___\uDC91')); +assertEquals('"___\\udc92"', JSON.stringify('___\uDC92')); +assertEquals('"___\\udc93"', JSON.stringify('___\uDC93')); +assertEquals('"___\\udc94"', JSON.stringify('___\uDC94')); +assertEquals('"___\\udc95"', JSON.stringify('___\uDC95')); +assertEquals('"___\\udc96"', JSON.stringify('___\uDC96')); +assertEquals('"___\\udc97"', JSON.stringify('___\uDC97')); +assertEquals('"___\\udc98"', JSON.stringify('___\uDC98')); +assertEquals('"___\\udc99"', JSON.stringify('___\uDC99')); +assertEquals('"___\\udc9a"', JSON.stringify('___\uDC9A')); +assertEquals('"___\\udc9b"', JSON.stringify('___\uDC9B')); +assertEquals('"___\\udc9c"', JSON.stringify('___\uDC9C')); +assertEquals('"___\\udc9d"', JSON.stringify('___\uDC9D')); +assertEquals('"___\\udc9e"', JSON.stringify('___\uDC9E')); +assertEquals('"___\\udc9f"', JSON.stringify('___\uDC9F')); +assertEquals('"___\\udca0"', JSON.stringify('___\uDCA0')); +assertEquals('"___\\udca1"', JSON.stringify('___\uDCA1')); +assertEquals('"___\\udca2"', JSON.stringify('___\uDCA2')); +assertEquals('"___\\udca3"', JSON.stringify('___\uDCA3')); +assertEquals('"___\\udca4"', JSON.stringify('___\uDCA4')); +assertEquals('"___\\udca5"', JSON.stringify('___\uDCA5')); +assertEquals('"___\\udca6"', JSON.stringify('___\uDCA6')); +assertEquals('"___\\udca7"', JSON.stringify('___\uDCA7')); +assertEquals('"___\\udca8"', JSON.stringify('___\uDCA8')); +assertEquals('"___\\udca9"', JSON.stringify('___\uDCA9')); +assertEquals('"___\\udcaa"', JSON.stringify('___\uDCAA')); +assertEquals('"___\\udcab"', JSON.stringify('___\uDCAB')); +assertEquals('"___\\udcac"', JSON.stringify('___\uDCAC')); +assertEquals('"___\\udcad"', JSON.stringify('___\uDCAD')); +assertEquals('"___\\udcae"', JSON.stringify('___\uDCAE')); +assertEquals('"___\\udcaf"', JSON.stringify('___\uDCAF')); +assertEquals('"___\\udcb0"', JSON.stringify('___\uDCB0')); +assertEquals('"___\\udcb1"', JSON.stringify('___\uDCB1')); +assertEquals('"___\\udcb2"', JSON.stringify('___\uDCB2')); +assertEquals('"___\\udcb3"', JSON.stringify('___\uDCB3')); +assertEquals('"___\\udcb4"', JSON.stringify('___\uDCB4')); +assertEquals('"___\\udcb5"', JSON.stringify('___\uDCB5')); +assertEquals('"___\\udcb6"', JSON.stringify('___\uDCB6')); +assertEquals('"___\\udcb7"', JSON.stringify('___\uDCB7')); +assertEquals('"___\\udcb8"', JSON.stringify('___\uDCB8')); +assertEquals('"___\\udcb9"', JSON.stringify('___\uDCB9')); +assertEquals('"___\\udcba"', JSON.stringify('___\uDCBA')); +assertEquals('"___\\udcbb"', JSON.stringify('___\uDCBB')); +assertEquals('"___\\udcbc"', JSON.stringify('___\uDCBC')); +assertEquals('"___\\udcbd"', JSON.stringify('___\uDCBD')); +assertEquals('"___\\udcbe"', JSON.stringify('___\uDCBE')); +assertEquals('"___\\udcbf"', JSON.stringify('___\uDCBF')); +assertEquals('"___\\udcc0"', JSON.stringify('___\uDCC0')); +assertEquals('"___\\udcc1"', JSON.stringify('___\uDCC1')); +assertEquals('"___\\udcc2"', JSON.stringify('___\uDCC2')); +assertEquals('"___\\udcc3"', JSON.stringify('___\uDCC3')); +assertEquals('"___\\udcc4"', JSON.stringify('___\uDCC4')); +assertEquals('"___\\udcc5"', JSON.stringify('___\uDCC5')); +assertEquals('"___\\udcc6"', JSON.stringify('___\uDCC6')); +assertEquals('"___\\udcc7"', JSON.stringify('___\uDCC7')); +assertEquals('"___\\udcc8"', JSON.stringify('___\uDCC8')); +assertEquals('"___\\udcc9"', JSON.stringify('___\uDCC9')); +assertEquals('"___\\udcca"', JSON.stringify('___\uDCCA')); +assertEquals('"___\\udccb"', JSON.stringify('___\uDCCB')); +assertEquals('"___\\udccc"', JSON.stringify('___\uDCCC')); +assertEquals('"___\\udccd"', JSON.stringify('___\uDCCD')); +assertEquals('"___\\udcce"', JSON.stringify('___\uDCCE')); +assertEquals('"___\\udccf"', JSON.stringify('___\uDCCF')); +assertEquals('"___\\udcd0"', JSON.stringify('___\uDCD0')); +assertEquals('"___\\udcd1"', JSON.stringify('___\uDCD1')); +assertEquals('"___\\udcd2"', JSON.stringify('___\uDCD2')); +assertEquals('"___\\udcd3"', JSON.stringify('___\uDCD3')); +assertEquals('"___\\udcd4"', JSON.stringify('___\uDCD4')); +assertEquals('"___\\udcd5"', JSON.stringify('___\uDCD5')); +assertEquals('"___\\udcd6"', JSON.stringify('___\uDCD6')); +assertEquals('"___\\udcd7"', JSON.stringify('___\uDCD7')); +assertEquals('"___\\udcd8"', JSON.stringify('___\uDCD8')); +assertEquals('"___\\udcd9"', JSON.stringify('___\uDCD9')); +assertEquals('"___\\udcda"', JSON.stringify('___\uDCDA')); +assertEquals('"___\\udcdb"', JSON.stringify('___\uDCDB')); +assertEquals('"___\\udcdc"', JSON.stringify('___\uDCDC')); +assertEquals('"___\\udcdd"', JSON.stringify('___\uDCDD')); +assertEquals('"___\\udcde"', JSON.stringify('___\uDCDE')); +assertEquals('"___\\udcdf"', JSON.stringify('___\uDCDF')); +assertEquals('"___\\udce0"', JSON.stringify('___\uDCE0')); +assertEquals('"___\\udce1"', JSON.stringify('___\uDCE1')); +assertEquals('"___\\udce2"', JSON.stringify('___\uDCE2')); +assertEquals('"___\\udce3"', JSON.stringify('___\uDCE3')); +assertEquals('"___\\udce4"', JSON.stringify('___\uDCE4')); +assertEquals('"___\\udce5"', JSON.stringify('___\uDCE5')); +assertEquals('"___\\udce6"', JSON.stringify('___\uDCE6')); +assertEquals('"___\\udce7"', JSON.stringify('___\uDCE7')); +assertEquals('"___\\udce8"', JSON.stringify('___\uDCE8')); +assertEquals('"___\\udce9"', JSON.stringify('___\uDCE9')); +assertEquals('"___\\udcea"', JSON.stringify('___\uDCEA')); +assertEquals('"___\\udceb"', JSON.stringify('___\uDCEB')); +assertEquals('"___\\udcec"', JSON.stringify('___\uDCEC')); +assertEquals('"___\\udced"', JSON.stringify('___\uDCED')); +assertEquals('"___\\udcee"', JSON.stringify('___\uDCEE')); +assertEquals('"___\\udcef"', JSON.stringify('___\uDCEF')); +assertEquals('"___\\udcf0"', JSON.stringify('___\uDCF0')); +assertEquals('"___\\udcf1"', JSON.stringify('___\uDCF1')); +assertEquals('"___\\udcf2"', JSON.stringify('___\uDCF2')); +assertEquals('"___\\udcf3"', JSON.stringify('___\uDCF3')); +assertEquals('"___\\udcf4"', JSON.stringify('___\uDCF4')); +assertEquals('"___\\udcf5"', JSON.stringify('___\uDCF5')); +assertEquals('"___\\udcf6"', JSON.stringify('___\uDCF6')); +assertEquals('"___\\udcf7"', JSON.stringify('___\uDCF7')); +assertEquals('"___\\udcf8"', JSON.stringify('___\uDCF8')); +assertEquals('"___\\udcf9"', JSON.stringify('___\uDCF9')); +assertEquals('"___\\udcfa"', JSON.stringify('___\uDCFA')); +assertEquals('"___\\udcfb"', JSON.stringify('___\uDCFB')); +assertEquals('"___\\udcfc"', JSON.stringify('___\uDCFC')); +assertEquals('"___\\udcfd"', JSON.stringify('___\uDCFD')); +assertEquals('"___\\udcfe"', JSON.stringify('___\uDCFE')); +assertEquals('"___\\udcff"', JSON.stringify('___\uDCFF')); +assertEquals('"___\\udd00"', JSON.stringify('___\uDD00')); +assertEquals('"___\\udd01"', JSON.stringify('___\uDD01')); +assertEquals('"___\\udd02"', JSON.stringify('___\uDD02')); +assertEquals('"___\\udd03"', JSON.stringify('___\uDD03')); +assertEquals('"___\\udd04"', JSON.stringify('___\uDD04')); +assertEquals('"___\\udd05"', JSON.stringify('___\uDD05')); +assertEquals('"___\\udd06"', JSON.stringify('___\uDD06')); +assertEquals('"___\\udd07"', JSON.stringify('___\uDD07')); +assertEquals('"___\\udd08"', JSON.stringify('___\uDD08')); +assertEquals('"___\\udd09"', JSON.stringify('___\uDD09')); +assertEquals('"___\\udd0a"', JSON.stringify('___\uDD0A')); +assertEquals('"___\\udd0b"', JSON.stringify('___\uDD0B')); +assertEquals('"___\\udd0c"', JSON.stringify('___\uDD0C')); +assertEquals('"___\\udd0d"', JSON.stringify('___\uDD0D')); +assertEquals('"___\\udd0e"', JSON.stringify('___\uDD0E')); +assertEquals('"___\\udd0f"', JSON.stringify('___\uDD0F')); +assertEquals('"___\\udd10"', JSON.stringify('___\uDD10')); +assertEquals('"___\\udd11"', JSON.stringify('___\uDD11')); +assertEquals('"___\\udd12"', JSON.stringify('___\uDD12')); +assertEquals('"___\\udd13"', JSON.stringify('___\uDD13')); +assertEquals('"___\\udd14"', JSON.stringify('___\uDD14')); +assertEquals('"___\\udd15"', JSON.stringify('___\uDD15')); +assertEquals('"___\\udd16"', JSON.stringify('___\uDD16')); +assertEquals('"___\\udd17"', JSON.stringify('___\uDD17')); +assertEquals('"___\\udd18"', JSON.stringify('___\uDD18')); +assertEquals('"___\\udd19"', JSON.stringify('___\uDD19')); +assertEquals('"___\\udd1a"', JSON.stringify('___\uDD1A')); +assertEquals('"___\\udd1b"', JSON.stringify('___\uDD1B')); +assertEquals('"___\\udd1c"', JSON.stringify('___\uDD1C')); +assertEquals('"___\\udd1d"', JSON.stringify('___\uDD1D')); +assertEquals('"___\\udd1e"', JSON.stringify('___\uDD1E')); +assertEquals('"___\\udd1f"', JSON.stringify('___\uDD1F')); +assertEquals('"___\\udd20"', JSON.stringify('___\uDD20')); +assertEquals('"___\\udd21"', JSON.stringify('___\uDD21')); +assertEquals('"___\\udd22"', JSON.stringify('___\uDD22')); +assertEquals('"___\\udd23"', JSON.stringify('___\uDD23')); +assertEquals('"___\\udd24"', JSON.stringify('___\uDD24')); +assertEquals('"___\\udd25"', JSON.stringify('___\uDD25')); +assertEquals('"___\\udd26"', JSON.stringify('___\uDD26')); +assertEquals('"___\\udd27"', JSON.stringify('___\uDD27')); +assertEquals('"___\\udd28"', JSON.stringify('___\uDD28')); +assertEquals('"___\\udd29"', JSON.stringify('___\uDD29')); +assertEquals('"___\\udd2a"', JSON.stringify('___\uDD2A')); +assertEquals('"___\\udd2b"', JSON.stringify('___\uDD2B')); +assertEquals('"___\\udd2c"', JSON.stringify('___\uDD2C')); +assertEquals('"___\\udd2d"', JSON.stringify('___\uDD2D')); +assertEquals('"___\\udd2e"', JSON.stringify('___\uDD2E')); +assertEquals('"___\\udd2f"', JSON.stringify('___\uDD2F')); +assertEquals('"___\\udd30"', JSON.stringify('___\uDD30')); +assertEquals('"___\\udd31"', JSON.stringify('___\uDD31')); +assertEquals('"___\\udd32"', JSON.stringify('___\uDD32')); +assertEquals('"___\\udd33"', JSON.stringify('___\uDD33')); +assertEquals('"___\\udd34"', JSON.stringify('___\uDD34')); +assertEquals('"___\\udd35"', JSON.stringify('___\uDD35')); +assertEquals('"___\\udd36"', JSON.stringify('___\uDD36')); +assertEquals('"___\\udd37"', JSON.stringify('___\uDD37')); +assertEquals('"___\\udd38"', JSON.stringify('___\uDD38')); +assertEquals('"___\\udd39"', JSON.stringify('___\uDD39')); +assertEquals('"___\\udd3a"', JSON.stringify('___\uDD3A')); +assertEquals('"___\\udd3b"', JSON.stringify('___\uDD3B')); +assertEquals('"___\\udd3c"', JSON.stringify('___\uDD3C')); +assertEquals('"___\\udd3d"', JSON.stringify('___\uDD3D')); +assertEquals('"___\\udd3e"', JSON.stringify('___\uDD3E')); +assertEquals('"___\\udd3f"', JSON.stringify('___\uDD3F')); +assertEquals('"___\\udd40"', JSON.stringify('___\uDD40')); +assertEquals('"___\\udd41"', JSON.stringify('___\uDD41')); +assertEquals('"___\\udd42"', JSON.stringify('___\uDD42')); +assertEquals('"___\\udd43"', JSON.stringify('___\uDD43')); +assertEquals('"___\\udd44"', JSON.stringify('___\uDD44')); +assertEquals('"___\\udd45"', JSON.stringify('___\uDD45')); +assertEquals('"___\\udd46"', JSON.stringify('___\uDD46')); +assertEquals('"___\\udd47"', JSON.stringify('___\uDD47')); +assertEquals('"___\\udd48"', JSON.stringify('___\uDD48')); +assertEquals('"___\\udd49"', JSON.stringify('___\uDD49')); +assertEquals('"___\\udd4a"', JSON.stringify('___\uDD4A')); +assertEquals('"___\\udd4b"', JSON.stringify('___\uDD4B')); +assertEquals('"___\\udd4c"', JSON.stringify('___\uDD4C')); +assertEquals('"___\\udd4d"', JSON.stringify('___\uDD4D')); +assertEquals('"___\\udd4e"', JSON.stringify('___\uDD4E')); +assertEquals('"___\\udd4f"', JSON.stringify('___\uDD4F')); +assertEquals('"___\\udd50"', JSON.stringify('___\uDD50')); +assertEquals('"___\\udd51"', JSON.stringify('___\uDD51')); +assertEquals('"___\\udd52"', JSON.stringify('___\uDD52')); +assertEquals('"___\\udd53"', JSON.stringify('___\uDD53')); +assertEquals('"___\\udd54"', JSON.stringify('___\uDD54')); +assertEquals('"___\\udd55"', JSON.stringify('___\uDD55')); +assertEquals('"___\\udd56"', JSON.stringify('___\uDD56')); +assertEquals('"___\\udd57"', JSON.stringify('___\uDD57')); +assertEquals('"___\\udd58"', JSON.stringify('___\uDD58')); +assertEquals('"___\\udd59"', JSON.stringify('___\uDD59')); +assertEquals('"___\\udd5a"', JSON.stringify('___\uDD5A')); +assertEquals('"___\\udd5b"', JSON.stringify('___\uDD5B')); +assertEquals('"___\\udd5c"', JSON.stringify('___\uDD5C')); +assertEquals('"___\\udd5d"', JSON.stringify('___\uDD5D')); +assertEquals('"___\\udd5e"', JSON.stringify('___\uDD5E')); +assertEquals('"___\\udd5f"', JSON.stringify('___\uDD5F')); +assertEquals('"___\\udd60"', JSON.stringify('___\uDD60')); +assertEquals('"___\\udd61"', JSON.stringify('___\uDD61')); +assertEquals('"___\\udd62"', JSON.stringify('___\uDD62')); +assertEquals('"___\\udd63"', JSON.stringify('___\uDD63')); +assertEquals('"___\\udd64"', JSON.stringify('___\uDD64')); +assertEquals('"___\\udd65"', JSON.stringify('___\uDD65')); +assertEquals('"___\\udd66"', JSON.stringify('___\uDD66')); +assertEquals('"___\\udd67"', JSON.stringify('___\uDD67')); +assertEquals('"___\\udd68"', JSON.stringify('___\uDD68')); +assertEquals('"___\\udd69"', JSON.stringify('___\uDD69')); +assertEquals('"___\\udd6a"', JSON.stringify('___\uDD6A')); +assertEquals('"___\\udd6b"', JSON.stringify('___\uDD6B')); +assertEquals('"___\\udd6c"', JSON.stringify('___\uDD6C')); +assertEquals('"___\\udd6d"', JSON.stringify('___\uDD6D')); +assertEquals('"___\\udd6e"', JSON.stringify('___\uDD6E')); +assertEquals('"___\\udd6f"', JSON.stringify('___\uDD6F')); +assertEquals('"___\\udd70"', JSON.stringify('___\uDD70')); +assertEquals('"___\\udd71"', JSON.stringify('___\uDD71')); +assertEquals('"___\\udd72"', JSON.stringify('___\uDD72')); +assertEquals('"___\\udd73"', JSON.stringify('___\uDD73')); +assertEquals('"___\\udd74"', JSON.stringify('___\uDD74')); +assertEquals('"___\\udd75"', JSON.stringify('___\uDD75')); +assertEquals('"___\\udd76"', JSON.stringify('___\uDD76')); +assertEquals('"___\\udd77"', JSON.stringify('___\uDD77')); +assertEquals('"___\\udd78"', JSON.stringify('___\uDD78')); +assertEquals('"___\\udd79"', JSON.stringify('___\uDD79')); +assertEquals('"___\\udd7a"', JSON.stringify('___\uDD7A')); +assertEquals('"___\\udd7b"', JSON.stringify('___\uDD7B')); +assertEquals('"___\\udd7c"', JSON.stringify('___\uDD7C')); +assertEquals('"___\\udd7d"', JSON.stringify('___\uDD7D')); +assertEquals('"___\\udd7e"', JSON.stringify('___\uDD7E')); +assertEquals('"___\\udd7f"', JSON.stringify('___\uDD7F')); +assertEquals('"___\\udd80"', JSON.stringify('___\uDD80')); +assertEquals('"___\\udd81"', JSON.stringify('___\uDD81')); +assertEquals('"___\\udd82"', JSON.stringify('___\uDD82')); +assertEquals('"___\\udd83"', JSON.stringify('___\uDD83')); +assertEquals('"___\\udd84"', JSON.stringify('___\uDD84')); +assertEquals('"___\\udd85"', JSON.stringify('___\uDD85')); +assertEquals('"___\\udd86"', JSON.stringify('___\uDD86')); +assertEquals('"___\\udd87"', JSON.stringify('___\uDD87')); +assertEquals('"___\\udd88"', JSON.stringify('___\uDD88')); +assertEquals('"___\\udd89"', JSON.stringify('___\uDD89')); +assertEquals('"___\\udd8a"', JSON.stringify('___\uDD8A')); +assertEquals('"___\\udd8b"', JSON.stringify('___\uDD8B')); +assertEquals('"___\\udd8c"', JSON.stringify('___\uDD8C')); +assertEquals('"___\\udd8d"', JSON.stringify('___\uDD8D')); +assertEquals('"___\\udd8e"', JSON.stringify('___\uDD8E')); +assertEquals('"___\\udd8f"', JSON.stringify('___\uDD8F')); +assertEquals('"___\\udd90"', JSON.stringify('___\uDD90')); +assertEquals('"___\\udd91"', JSON.stringify('___\uDD91')); +assertEquals('"___\\udd92"', JSON.stringify('___\uDD92')); +assertEquals('"___\\udd93"', JSON.stringify('___\uDD93')); +assertEquals('"___\\udd94"', JSON.stringify('___\uDD94')); +assertEquals('"___\\udd95"', JSON.stringify('___\uDD95')); +assertEquals('"___\\udd96"', JSON.stringify('___\uDD96')); +assertEquals('"___\\udd97"', JSON.stringify('___\uDD97')); +assertEquals('"___\\udd98"', JSON.stringify('___\uDD98')); +assertEquals('"___\\udd99"', JSON.stringify('___\uDD99')); +assertEquals('"___\\udd9a"', JSON.stringify('___\uDD9A')); +assertEquals('"___\\udd9b"', JSON.stringify('___\uDD9B')); +assertEquals('"___\\udd9c"', JSON.stringify('___\uDD9C')); +assertEquals('"___\\udd9d"', JSON.stringify('___\uDD9D')); +assertEquals('"___\\udd9e"', JSON.stringify('___\uDD9E')); +assertEquals('"___\\udd9f"', JSON.stringify('___\uDD9F')); +assertEquals('"___\\udda0"', JSON.stringify('___\uDDA0')); +assertEquals('"___\\udda1"', JSON.stringify('___\uDDA1')); +assertEquals('"___\\udda2"', JSON.stringify('___\uDDA2')); +assertEquals('"___\\udda3"', JSON.stringify('___\uDDA3')); +assertEquals('"___\\udda4"', JSON.stringify('___\uDDA4')); +assertEquals('"___\\udda5"', JSON.stringify('___\uDDA5')); +assertEquals('"___\\udda6"', JSON.stringify('___\uDDA6')); +assertEquals('"___\\udda7"', JSON.stringify('___\uDDA7')); +assertEquals('"___\\udda8"', JSON.stringify('___\uDDA8')); +assertEquals('"___\\udda9"', JSON.stringify('___\uDDA9')); +assertEquals('"___\\uddaa"', JSON.stringify('___\uDDAA')); +assertEquals('"___\\uddab"', JSON.stringify('___\uDDAB')); +assertEquals('"___\\uddac"', JSON.stringify('___\uDDAC')); +assertEquals('"___\\uddad"', JSON.stringify('___\uDDAD')); +assertEquals('"___\\uddae"', JSON.stringify('___\uDDAE')); +assertEquals('"___\\uddaf"', JSON.stringify('___\uDDAF')); +assertEquals('"___\\uddb0"', JSON.stringify('___\uDDB0')); +assertEquals('"___\\uddb1"', JSON.stringify('___\uDDB1')); +assertEquals('"___\\uddb2"', JSON.stringify('___\uDDB2')); +assertEquals('"___\\uddb3"', JSON.stringify('___\uDDB3')); +assertEquals('"___\\uddb4"', JSON.stringify('___\uDDB4')); +assertEquals('"___\\uddb5"', JSON.stringify('___\uDDB5')); +assertEquals('"___\\uddb6"', JSON.stringify('___\uDDB6')); +assertEquals('"___\\uddb7"', JSON.stringify('___\uDDB7')); +assertEquals('"___\\uddb8"', JSON.stringify('___\uDDB8')); +assertEquals('"___\\uddb9"', JSON.stringify('___\uDDB9')); +assertEquals('"___\\uddba"', JSON.stringify('___\uDDBA')); +assertEquals('"___\\uddbb"', JSON.stringify('___\uDDBB')); +assertEquals('"___\\uddbc"', JSON.stringify('___\uDDBC')); +assertEquals('"___\\uddbd"', JSON.stringify('___\uDDBD')); +assertEquals('"___\\uddbe"', JSON.stringify('___\uDDBE')); +assertEquals('"___\\uddbf"', JSON.stringify('___\uDDBF')); +assertEquals('"___\\uddc0"', JSON.stringify('___\uDDC0')); +assertEquals('"___\\uddc1"', JSON.stringify('___\uDDC1')); +assertEquals('"___\\uddc2"', JSON.stringify('___\uDDC2')); +assertEquals('"___\\uddc3"', JSON.stringify('___\uDDC3')); +assertEquals('"___\\uddc4"', JSON.stringify('___\uDDC4')); +assertEquals('"___\\uddc5"', JSON.stringify('___\uDDC5')); +assertEquals('"___\\uddc6"', JSON.stringify('___\uDDC6')); +assertEquals('"___\\uddc7"', JSON.stringify('___\uDDC7')); +assertEquals('"___\\uddc8"', JSON.stringify('___\uDDC8')); +assertEquals('"___\\uddc9"', JSON.stringify('___\uDDC9')); +assertEquals('"___\\uddca"', JSON.stringify('___\uDDCA')); +assertEquals('"___\\uddcb"', JSON.stringify('___\uDDCB')); +assertEquals('"___\\uddcc"', JSON.stringify('___\uDDCC')); +assertEquals('"___\\uddcd"', JSON.stringify('___\uDDCD')); +assertEquals('"___\\uddce"', JSON.stringify('___\uDDCE')); +assertEquals('"___\\uddcf"', JSON.stringify('___\uDDCF')); +assertEquals('"___\\uddd0"', JSON.stringify('___\uDDD0')); +assertEquals('"___\\uddd1"', JSON.stringify('___\uDDD1')); +assertEquals('"___\\uddd2"', JSON.stringify('___\uDDD2')); +assertEquals('"___\\uddd3"', JSON.stringify('___\uDDD3')); +assertEquals('"___\\uddd4"', JSON.stringify('___\uDDD4')); +assertEquals('"___\\uddd5"', JSON.stringify('___\uDDD5')); +assertEquals('"___\\uddd6"', JSON.stringify('___\uDDD6')); +assertEquals('"___\\uddd7"', JSON.stringify('___\uDDD7')); +assertEquals('"___\\uddd8"', JSON.stringify('___\uDDD8')); +assertEquals('"___\\uddd9"', JSON.stringify('___\uDDD9')); +assertEquals('"___\\uddda"', JSON.stringify('___\uDDDA')); +assertEquals('"___\\udddb"', JSON.stringify('___\uDDDB')); +assertEquals('"___\\udddc"', JSON.stringify('___\uDDDC')); +assertEquals('"___\\udddd"', JSON.stringify('___\uDDDD')); +assertEquals('"___\\uddde"', JSON.stringify('___\uDDDE')); +assertEquals('"___\\udddf"', JSON.stringify('___\uDDDF')); +assertEquals('"___\\udde0"', JSON.stringify('___\uDDE0')); +assertEquals('"___\\udde1"', JSON.stringify('___\uDDE1')); +assertEquals('"___\\udde2"', JSON.stringify('___\uDDE2')); +assertEquals('"___\\udde3"', JSON.stringify('___\uDDE3')); +assertEquals('"___\\udde4"', JSON.stringify('___\uDDE4')); +assertEquals('"___\\udde5"', JSON.stringify('___\uDDE5')); +assertEquals('"___\\udde6"', JSON.stringify('___\uDDE6')); +assertEquals('"___\\udde7"', JSON.stringify('___\uDDE7')); +assertEquals('"___\\udde8"', JSON.stringify('___\uDDE8')); +assertEquals('"___\\udde9"', JSON.stringify('___\uDDE9')); +assertEquals('"___\\uddea"', JSON.stringify('___\uDDEA')); +assertEquals('"___\\uddeb"', JSON.stringify('___\uDDEB')); +assertEquals('"___\\uddec"', JSON.stringify('___\uDDEC')); +assertEquals('"___\\udded"', JSON.stringify('___\uDDED')); +assertEquals('"___\\uddee"', JSON.stringify('___\uDDEE')); +assertEquals('"___\\uddef"', JSON.stringify('___\uDDEF')); +assertEquals('"___\\uddf0"', JSON.stringify('___\uDDF0')); +assertEquals('"___\\uddf1"', JSON.stringify('___\uDDF1')); +assertEquals('"___\\uddf2"', JSON.stringify('___\uDDF2')); +assertEquals('"___\\uddf3"', JSON.stringify('___\uDDF3')); +assertEquals('"___\\uddf4"', JSON.stringify('___\uDDF4')); +assertEquals('"___\\uddf5"', JSON.stringify('___\uDDF5')); +assertEquals('"___\\uddf6"', JSON.stringify('___\uDDF6')); +assertEquals('"___\\uddf7"', JSON.stringify('___\uDDF7')); +assertEquals('"___\\uddf8"', JSON.stringify('___\uDDF8')); +assertEquals('"___\\uddf9"', JSON.stringify('___\uDDF9')); +assertEquals('"___\\uddfa"', JSON.stringify('___\uDDFA')); +assertEquals('"___\\uddfb"', JSON.stringify('___\uDDFB')); +assertEquals('"___\\uddfc"', JSON.stringify('___\uDDFC')); +assertEquals('"___\\uddfd"', JSON.stringify('___\uDDFD')); +assertEquals('"___\\uddfe"', JSON.stringify('___\uDDFE')); +assertEquals('"___\\uddff"', JSON.stringify('___\uDDFF')); +assertEquals('"___\\ude00"', JSON.stringify('___\uDE00')); +assertEquals('"___\\ude01"', JSON.stringify('___\uDE01')); +assertEquals('"___\\ude02"', JSON.stringify('___\uDE02')); +assertEquals('"___\\ude03"', JSON.stringify('___\uDE03')); +assertEquals('"___\\ude04"', JSON.stringify('___\uDE04')); +assertEquals('"___\\ude05"', JSON.stringify('___\uDE05')); +assertEquals('"___\\ude06"', JSON.stringify('___\uDE06')); +assertEquals('"___\\ude07"', JSON.stringify('___\uDE07')); +assertEquals('"___\\ude08"', JSON.stringify('___\uDE08')); +assertEquals('"___\\ude09"', JSON.stringify('___\uDE09')); +assertEquals('"___\\ude0a"', JSON.stringify('___\uDE0A')); +assertEquals('"___\\ude0b"', JSON.stringify('___\uDE0B')); +assertEquals('"___\\ude0c"', JSON.stringify('___\uDE0C')); +assertEquals('"___\\ude0d"', JSON.stringify('___\uDE0D')); +assertEquals('"___\\ude0e"', JSON.stringify('___\uDE0E')); +assertEquals('"___\\ude0f"', JSON.stringify('___\uDE0F')); +assertEquals('"___\\ude10"', JSON.stringify('___\uDE10')); +assertEquals('"___\\ude11"', JSON.stringify('___\uDE11')); +assertEquals('"___\\ude12"', JSON.stringify('___\uDE12')); +assertEquals('"___\\ude13"', JSON.stringify('___\uDE13')); +assertEquals('"___\\ude14"', JSON.stringify('___\uDE14')); +assertEquals('"___\\ude15"', JSON.stringify('___\uDE15')); +assertEquals('"___\\ude16"', JSON.stringify('___\uDE16')); +assertEquals('"___\\ude17"', JSON.stringify('___\uDE17')); +assertEquals('"___\\ude18"', JSON.stringify('___\uDE18')); +assertEquals('"___\\ude19"', JSON.stringify('___\uDE19')); +assertEquals('"___\\ude1a"', JSON.stringify('___\uDE1A')); +assertEquals('"___\\ude1b"', JSON.stringify('___\uDE1B')); +assertEquals('"___\\ude1c"', JSON.stringify('___\uDE1C')); +assertEquals('"___\\ude1d"', JSON.stringify('___\uDE1D')); +assertEquals('"___\\ude1e"', JSON.stringify('___\uDE1E')); +assertEquals('"___\\ude1f"', JSON.stringify('___\uDE1F')); +assertEquals('"___\\ude20"', JSON.stringify('___\uDE20')); +assertEquals('"___\\ude21"', JSON.stringify('___\uDE21')); +assertEquals('"___\\ude22"', JSON.stringify('___\uDE22')); +assertEquals('"___\\ude23"', JSON.stringify('___\uDE23')); +assertEquals('"___\\ude24"', JSON.stringify('___\uDE24')); +assertEquals('"___\\ude25"', JSON.stringify('___\uDE25')); +assertEquals('"___\\ude26"', JSON.stringify('___\uDE26')); +assertEquals('"___\\ude27"', JSON.stringify('___\uDE27')); +assertEquals('"___\\ude28"', JSON.stringify('___\uDE28')); +assertEquals('"___\\ude29"', JSON.stringify('___\uDE29')); +assertEquals('"___\\ude2a"', JSON.stringify('___\uDE2A')); +assertEquals('"___\\ude2b"', JSON.stringify('___\uDE2B')); +assertEquals('"___\\ude2c"', JSON.stringify('___\uDE2C')); +assertEquals('"___\\ude2d"', JSON.stringify('___\uDE2D')); +assertEquals('"___\\ude2e"', JSON.stringify('___\uDE2E')); +assertEquals('"___\\ude2f"', JSON.stringify('___\uDE2F')); +assertEquals('"___\\ude30"', JSON.stringify('___\uDE30')); +assertEquals('"___\\ude31"', JSON.stringify('___\uDE31')); +assertEquals('"___\\ude32"', JSON.stringify('___\uDE32')); +assertEquals('"___\\ude33"', JSON.stringify('___\uDE33')); +assertEquals('"___\\ude34"', JSON.stringify('___\uDE34')); +assertEquals('"___\\ude35"', JSON.stringify('___\uDE35')); +assertEquals('"___\\ude36"', JSON.stringify('___\uDE36')); +assertEquals('"___\\ude37"', JSON.stringify('___\uDE37')); +assertEquals('"___\\ude38"', JSON.stringify('___\uDE38')); +assertEquals('"___\\ude39"', JSON.stringify('___\uDE39')); +assertEquals('"___\\ude3a"', JSON.stringify('___\uDE3A')); +assertEquals('"___\\ude3b"', JSON.stringify('___\uDE3B')); +assertEquals('"___\\ude3c"', JSON.stringify('___\uDE3C')); +assertEquals('"___\\ude3d"', JSON.stringify('___\uDE3D')); +assertEquals('"___\\ude3e"', JSON.stringify('___\uDE3E')); +assertEquals('"___\\ude3f"', JSON.stringify('___\uDE3F')); +assertEquals('"___\\ude40"', JSON.stringify('___\uDE40')); +assertEquals('"___\\ude41"', JSON.stringify('___\uDE41')); +assertEquals('"___\\ude42"', JSON.stringify('___\uDE42')); +assertEquals('"___\\ude43"', JSON.stringify('___\uDE43')); +assertEquals('"___\\ude44"', JSON.stringify('___\uDE44')); +assertEquals('"___\\ude45"', JSON.stringify('___\uDE45')); +assertEquals('"___\\ude46"', JSON.stringify('___\uDE46')); +assertEquals('"___\\ude47"', JSON.stringify('___\uDE47')); +assertEquals('"___\\ude48"', JSON.stringify('___\uDE48')); +assertEquals('"___\\ude49"', JSON.stringify('___\uDE49')); +assertEquals('"___\\ude4a"', JSON.stringify('___\uDE4A')); +assertEquals('"___\\ude4b"', JSON.stringify('___\uDE4B')); +assertEquals('"___\\ude4c"', JSON.stringify('___\uDE4C')); +assertEquals('"___\\ude4d"', JSON.stringify('___\uDE4D')); +assertEquals('"___\\ude4e"', JSON.stringify('___\uDE4E')); +assertEquals('"___\\ude4f"', JSON.stringify('___\uDE4F')); +assertEquals('"___\\ude50"', JSON.stringify('___\uDE50')); +assertEquals('"___\\ude51"', JSON.stringify('___\uDE51')); +assertEquals('"___\\ude52"', JSON.stringify('___\uDE52')); +assertEquals('"___\\ude53"', JSON.stringify('___\uDE53')); +assertEquals('"___\\ude54"', JSON.stringify('___\uDE54')); +assertEquals('"___\\ude55"', JSON.stringify('___\uDE55')); +assertEquals('"___\\ude56"', JSON.stringify('___\uDE56')); +assertEquals('"___\\ude57"', JSON.stringify('___\uDE57')); +assertEquals('"___\\ude58"', JSON.stringify('___\uDE58')); +assertEquals('"___\\ude59"', JSON.stringify('___\uDE59')); +assertEquals('"___\\ude5a"', JSON.stringify('___\uDE5A')); +assertEquals('"___\\ude5b"', JSON.stringify('___\uDE5B')); +assertEquals('"___\\ude5c"', JSON.stringify('___\uDE5C')); +assertEquals('"___\\ude5d"', JSON.stringify('___\uDE5D')); +assertEquals('"___\\ude5e"', JSON.stringify('___\uDE5E')); +assertEquals('"___\\ude5f"', JSON.stringify('___\uDE5F')); +assertEquals('"___\\ude60"', JSON.stringify('___\uDE60')); +assertEquals('"___\\ude61"', JSON.stringify('___\uDE61')); +assertEquals('"___\\ude62"', JSON.stringify('___\uDE62')); +assertEquals('"___\\ude63"', JSON.stringify('___\uDE63')); +assertEquals('"___\\ude64"', JSON.stringify('___\uDE64')); +assertEquals('"___\\ude65"', JSON.stringify('___\uDE65')); +assertEquals('"___\\ude66"', JSON.stringify('___\uDE66')); +assertEquals('"___\\ude67"', JSON.stringify('___\uDE67')); +assertEquals('"___\\ude68"', JSON.stringify('___\uDE68')); +assertEquals('"___\\ude69"', JSON.stringify('___\uDE69')); +assertEquals('"___\\ude6a"', JSON.stringify('___\uDE6A')); +assertEquals('"___\\ude6b"', JSON.stringify('___\uDE6B')); +assertEquals('"___\\ude6c"', JSON.stringify('___\uDE6C')); +assertEquals('"___\\ude6d"', JSON.stringify('___\uDE6D')); +assertEquals('"___\\ude6e"', JSON.stringify('___\uDE6E')); +assertEquals('"___\\ude6f"', JSON.stringify('___\uDE6F')); +assertEquals('"___\\ude70"', JSON.stringify('___\uDE70')); +assertEquals('"___\\ude71"', JSON.stringify('___\uDE71')); +assertEquals('"___\\ude72"', JSON.stringify('___\uDE72')); +assertEquals('"___\\ude73"', JSON.stringify('___\uDE73')); +assertEquals('"___\\ude74"', JSON.stringify('___\uDE74')); +assertEquals('"___\\ude75"', JSON.stringify('___\uDE75')); +assertEquals('"___\\ude76"', JSON.stringify('___\uDE76')); +assertEquals('"___\\ude77"', JSON.stringify('___\uDE77')); +assertEquals('"___\\ude78"', JSON.stringify('___\uDE78')); +assertEquals('"___\\ude79"', JSON.stringify('___\uDE79')); +assertEquals('"___\\ude7a"', JSON.stringify('___\uDE7A')); +assertEquals('"___\\ude7b"', JSON.stringify('___\uDE7B')); +assertEquals('"___\\ude7c"', JSON.stringify('___\uDE7C')); +assertEquals('"___\\ude7d"', JSON.stringify('___\uDE7D')); +assertEquals('"___\\ude7e"', JSON.stringify('___\uDE7E')); +assertEquals('"___\\ude7f"', JSON.stringify('___\uDE7F')); +assertEquals('"___\\ude80"', JSON.stringify('___\uDE80')); +assertEquals('"___\\ude81"', JSON.stringify('___\uDE81')); +assertEquals('"___\\ude82"', JSON.stringify('___\uDE82')); +assertEquals('"___\\ude83"', JSON.stringify('___\uDE83')); +assertEquals('"___\\ude84"', JSON.stringify('___\uDE84')); +assertEquals('"___\\ude85"', JSON.stringify('___\uDE85')); +assertEquals('"___\\ude86"', JSON.stringify('___\uDE86')); +assertEquals('"___\\ude87"', JSON.stringify('___\uDE87')); +assertEquals('"___\\ude88"', JSON.stringify('___\uDE88')); +assertEquals('"___\\ude89"', JSON.stringify('___\uDE89')); +assertEquals('"___\\ude8a"', JSON.stringify('___\uDE8A')); +assertEquals('"___\\ude8b"', JSON.stringify('___\uDE8B')); +assertEquals('"___\\ude8c"', JSON.stringify('___\uDE8C')); +assertEquals('"___\\ude8d"', JSON.stringify('___\uDE8D')); +assertEquals('"___\\ude8e"', JSON.stringify('___\uDE8E')); +assertEquals('"___\\ude8f"', JSON.stringify('___\uDE8F')); +assertEquals('"___\\ude90"', JSON.stringify('___\uDE90')); +assertEquals('"___\\ude91"', JSON.stringify('___\uDE91')); +assertEquals('"___\\ude92"', JSON.stringify('___\uDE92')); +assertEquals('"___\\ude93"', JSON.stringify('___\uDE93')); +assertEquals('"___\\ude94"', JSON.stringify('___\uDE94')); +assertEquals('"___\\ude95"', JSON.stringify('___\uDE95')); +assertEquals('"___\\ude96"', JSON.stringify('___\uDE96')); +assertEquals('"___\\ude97"', JSON.stringify('___\uDE97')); +assertEquals('"___\\ude98"', JSON.stringify('___\uDE98')); +assertEquals('"___\\ude99"', JSON.stringify('___\uDE99')); +assertEquals('"___\\ude9a"', JSON.stringify('___\uDE9A')); +assertEquals('"___\\ude9b"', JSON.stringify('___\uDE9B')); +assertEquals('"___\\ude9c"', JSON.stringify('___\uDE9C')); +assertEquals('"___\\ude9d"', JSON.stringify('___\uDE9D')); +assertEquals('"___\\ude9e"', JSON.stringify('___\uDE9E')); +assertEquals('"___\\ude9f"', JSON.stringify('___\uDE9F')); +assertEquals('"___\\udea0"', JSON.stringify('___\uDEA0')); +assertEquals('"___\\udea1"', JSON.stringify('___\uDEA1')); +assertEquals('"___\\udea2"', JSON.stringify('___\uDEA2')); +assertEquals('"___\\udea3"', JSON.stringify('___\uDEA3')); +assertEquals('"___\\udea4"', JSON.stringify('___\uDEA4')); +assertEquals('"___\\udea5"', JSON.stringify('___\uDEA5')); +assertEquals('"___\\udea6"', JSON.stringify('___\uDEA6')); +assertEquals('"___\\udea7"', JSON.stringify('___\uDEA7')); +assertEquals('"___\\udea8"', JSON.stringify('___\uDEA8')); +assertEquals('"___\\udea9"', JSON.stringify('___\uDEA9')); +assertEquals('"___\\udeaa"', JSON.stringify('___\uDEAA')); +assertEquals('"___\\udeab"', JSON.stringify('___\uDEAB')); +assertEquals('"___\\udeac"', JSON.stringify('___\uDEAC')); +assertEquals('"___\\udead"', JSON.stringify('___\uDEAD')); +assertEquals('"___\\udeae"', JSON.stringify('___\uDEAE')); +assertEquals('"___\\udeaf"', JSON.stringify('___\uDEAF')); +assertEquals('"___\\udeb0"', JSON.stringify('___\uDEB0')); +assertEquals('"___\\udeb1"', JSON.stringify('___\uDEB1')); +assertEquals('"___\\udeb2"', JSON.stringify('___\uDEB2')); +assertEquals('"___\\udeb3"', JSON.stringify('___\uDEB3')); +assertEquals('"___\\udeb4"', JSON.stringify('___\uDEB4')); +assertEquals('"___\\udeb5"', JSON.stringify('___\uDEB5')); +assertEquals('"___\\udeb6"', JSON.stringify('___\uDEB6')); +assertEquals('"___\\udeb7"', JSON.stringify('___\uDEB7')); +assertEquals('"___\\udeb8"', JSON.stringify('___\uDEB8')); +assertEquals('"___\\udeb9"', JSON.stringify('___\uDEB9')); +assertEquals('"___\\udeba"', JSON.stringify('___\uDEBA')); +assertEquals('"___\\udebb"', JSON.stringify('___\uDEBB')); +assertEquals('"___\\udebc"', JSON.stringify('___\uDEBC')); +assertEquals('"___\\udebd"', JSON.stringify('___\uDEBD')); +assertEquals('"___\\udebe"', JSON.stringify('___\uDEBE')); +assertEquals('"___\\udebf"', JSON.stringify('___\uDEBF')); +assertEquals('"___\\udec0"', JSON.stringify('___\uDEC0')); +assertEquals('"___\\udec1"', JSON.stringify('___\uDEC1')); +assertEquals('"___\\udec2"', JSON.stringify('___\uDEC2')); +assertEquals('"___\\udec3"', JSON.stringify('___\uDEC3')); +assertEquals('"___\\udec4"', JSON.stringify('___\uDEC4')); +assertEquals('"___\\udec5"', JSON.stringify('___\uDEC5')); +assertEquals('"___\\udec6"', JSON.stringify('___\uDEC6')); +assertEquals('"___\\udec7"', JSON.stringify('___\uDEC7')); +assertEquals('"___\\udec8"', JSON.stringify('___\uDEC8')); +assertEquals('"___\\udec9"', JSON.stringify('___\uDEC9')); +assertEquals('"___\\udeca"', JSON.stringify('___\uDECA')); +assertEquals('"___\\udecb"', JSON.stringify('___\uDECB')); +assertEquals('"___\\udecc"', JSON.stringify('___\uDECC')); +assertEquals('"___\\udecd"', JSON.stringify('___\uDECD')); +assertEquals('"___\\udece"', JSON.stringify('___\uDECE')); +assertEquals('"___\\udecf"', JSON.stringify('___\uDECF')); +assertEquals('"___\\uded0"', JSON.stringify('___\uDED0')); +assertEquals('"___\\uded1"', JSON.stringify('___\uDED1')); +assertEquals('"___\\uded2"', JSON.stringify('___\uDED2')); +assertEquals('"___\\uded3"', JSON.stringify('___\uDED3')); +assertEquals('"___\\uded4"', JSON.stringify('___\uDED4')); +assertEquals('"___\\uded5"', JSON.stringify('___\uDED5')); +assertEquals('"___\\uded6"', JSON.stringify('___\uDED6')); +assertEquals('"___\\uded7"', JSON.stringify('___\uDED7')); +assertEquals('"___\\uded8"', JSON.stringify('___\uDED8')); +assertEquals('"___\\uded9"', JSON.stringify('___\uDED9')); +assertEquals('"___\\udeda"', JSON.stringify('___\uDEDA')); +assertEquals('"___\\udedb"', JSON.stringify('___\uDEDB')); +assertEquals('"___\\udedc"', JSON.stringify('___\uDEDC')); +assertEquals('"___\\udedd"', JSON.stringify('___\uDEDD')); +assertEquals('"___\\udede"', JSON.stringify('___\uDEDE')); +assertEquals('"___\\udedf"', JSON.stringify('___\uDEDF')); +assertEquals('"___\\udee0"', JSON.stringify('___\uDEE0')); +assertEquals('"___\\udee1"', JSON.stringify('___\uDEE1')); +assertEquals('"___\\udee2"', JSON.stringify('___\uDEE2')); +assertEquals('"___\\udee3"', JSON.stringify('___\uDEE3')); +assertEquals('"___\\udee4"', JSON.stringify('___\uDEE4')); +assertEquals('"___\\udee5"', JSON.stringify('___\uDEE5')); +assertEquals('"___\\udee6"', JSON.stringify('___\uDEE6')); +assertEquals('"___\\udee7"', JSON.stringify('___\uDEE7')); +assertEquals('"___\\udee8"', JSON.stringify('___\uDEE8')); +assertEquals('"___\\udee9"', JSON.stringify('___\uDEE9')); +assertEquals('"___\\udeea"', JSON.stringify('___\uDEEA')); +assertEquals('"___\\udeeb"', JSON.stringify('___\uDEEB')); +assertEquals('"___\\udeec"', JSON.stringify('___\uDEEC')); +assertEquals('"___\\udeed"', JSON.stringify('___\uDEED')); +assertEquals('"___\\udeee"', JSON.stringify('___\uDEEE')); +assertEquals('"___\\udeef"', JSON.stringify('___\uDEEF')); +assertEquals('"___\\udef0"', JSON.stringify('___\uDEF0')); +assertEquals('"___\\udef1"', JSON.stringify('___\uDEF1')); +assertEquals('"___\\udef2"', JSON.stringify('___\uDEF2')); +assertEquals('"___\\udef3"', JSON.stringify('___\uDEF3')); +assertEquals('"___\\udef4"', JSON.stringify('___\uDEF4')); +assertEquals('"___\\udef5"', JSON.stringify('___\uDEF5')); +assertEquals('"___\\udef6"', JSON.stringify('___\uDEF6')); +assertEquals('"___\\udef7"', JSON.stringify('___\uDEF7')); +assertEquals('"___\\udef8"', JSON.stringify('___\uDEF8')); +assertEquals('"___\\udef9"', JSON.stringify('___\uDEF9')); +assertEquals('"___\\udefa"', JSON.stringify('___\uDEFA')); +assertEquals('"___\\udefb"', JSON.stringify('___\uDEFB')); +assertEquals('"___\\udefc"', JSON.stringify('___\uDEFC')); +assertEquals('"___\\udefd"', JSON.stringify('___\uDEFD')); +assertEquals('"___\\udefe"', JSON.stringify('___\uDEFE')); +assertEquals('"___\\udeff"', JSON.stringify('___\uDEFF')); +assertEquals('"___\\udf00"', JSON.stringify('___\uDF00')); +assertEquals('"___\\udf01"', JSON.stringify('___\uDF01')); +assertEquals('"___\\udf02"', JSON.stringify('___\uDF02')); +assertEquals('"___\\udf03"', JSON.stringify('___\uDF03')); +assertEquals('"___\\udf04"', JSON.stringify('___\uDF04')); +assertEquals('"___\\udf05"', JSON.stringify('___\uDF05')); +assertEquals('"___\\udf06"', JSON.stringify('___\uDF06')); +assertEquals('"___\\udf07"', JSON.stringify('___\uDF07')); +assertEquals('"___\\udf08"', JSON.stringify('___\uDF08')); +assertEquals('"___\\udf09"', JSON.stringify('___\uDF09')); +assertEquals('"___\\udf0a"', JSON.stringify('___\uDF0A')); +assertEquals('"___\\udf0b"', JSON.stringify('___\uDF0B')); +assertEquals('"___\\udf0c"', JSON.stringify('___\uDF0C')); +assertEquals('"___\\udf0d"', JSON.stringify('___\uDF0D')); +assertEquals('"___\\udf0e"', JSON.stringify('___\uDF0E')); +assertEquals('"___\\udf0f"', JSON.stringify('___\uDF0F')); +assertEquals('"___\\udf10"', JSON.stringify('___\uDF10')); +assertEquals('"___\\udf11"', JSON.stringify('___\uDF11')); +assertEquals('"___\\udf12"', JSON.stringify('___\uDF12')); +assertEquals('"___\\udf13"', JSON.stringify('___\uDF13')); +assertEquals('"___\\udf14"', JSON.stringify('___\uDF14')); +assertEquals('"___\\udf15"', JSON.stringify('___\uDF15')); +assertEquals('"___\\udf16"', JSON.stringify('___\uDF16')); +assertEquals('"___\\udf17"', JSON.stringify('___\uDF17')); +assertEquals('"___\\udf18"', JSON.stringify('___\uDF18')); +assertEquals('"___\\udf19"', JSON.stringify('___\uDF19')); +assertEquals('"___\\udf1a"', JSON.stringify('___\uDF1A')); +assertEquals('"___\\udf1b"', JSON.stringify('___\uDF1B')); +assertEquals('"___\\udf1c"', JSON.stringify('___\uDF1C')); +assertEquals('"___\\udf1d"', JSON.stringify('___\uDF1D')); +assertEquals('"___\\udf1e"', JSON.stringify('___\uDF1E')); +assertEquals('"___\\udf1f"', JSON.stringify('___\uDF1F')); +assertEquals('"___\\udf20"', JSON.stringify('___\uDF20')); +assertEquals('"___\\udf21"', JSON.stringify('___\uDF21')); +assertEquals('"___\\udf22"', JSON.stringify('___\uDF22')); +assertEquals('"___\\udf23"', JSON.stringify('___\uDF23')); +assertEquals('"___\\udf24"', JSON.stringify('___\uDF24')); +assertEquals('"___\\udf25"', JSON.stringify('___\uDF25')); +assertEquals('"___\\udf26"', JSON.stringify('___\uDF26')); +assertEquals('"___\\udf27"', JSON.stringify('___\uDF27')); +assertEquals('"___\\udf28"', JSON.stringify('___\uDF28')); +assertEquals('"___\\udf29"', JSON.stringify('___\uDF29')); +assertEquals('"___\\udf2a"', JSON.stringify('___\uDF2A')); +assertEquals('"___\\udf2b"', JSON.stringify('___\uDF2B')); +assertEquals('"___\\udf2c"', JSON.stringify('___\uDF2C')); +assertEquals('"___\\udf2d"', JSON.stringify('___\uDF2D')); +assertEquals('"___\\udf2e"', JSON.stringify('___\uDF2E')); +assertEquals('"___\\udf2f"', JSON.stringify('___\uDF2F')); +assertEquals('"___\\udf30"', JSON.stringify('___\uDF30')); +assertEquals('"___\\udf31"', JSON.stringify('___\uDF31')); +assertEquals('"___\\udf32"', JSON.stringify('___\uDF32')); +assertEquals('"___\\udf33"', JSON.stringify('___\uDF33')); +assertEquals('"___\\udf34"', JSON.stringify('___\uDF34')); +assertEquals('"___\\udf35"', JSON.stringify('___\uDF35')); +assertEquals('"___\\udf36"', JSON.stringify('___\uDF36')); +assertEquals('"___\\udf37"', JSON.stringify('___\uDF37')); +assertEquals('"___\\udf38"', JSON.stringify('___\uDF38')); +assertEquals('"___\\udf39"', JSON.stringify('___\uDF39')); +assertEquals('"___\\udf3a"', JSON.stringify('___\uDF3A')); +assertEquals('"___\\udf3b"', JSON.stringify('___\uDF3B')); +assertEquals('"___\\udf3c"', JSON.stringify('___\uDF3C')); +assertEquals('"___\\udf3d"', JSON.stringify('___\uDF3D')); +assertEquals('"___\\udf3e"', JSON.stringify('___\uDF3E')); +assertEquals('"___\\udf3f"', JSON.stringify('___\uDF3F')); +assertEquals('"___\\udf40"', JSON.stringify('___\uDF40')); +assertEquals('"___\\udf41"', JSON.stringify('___\uDF41')); +assertEquals('"___\\udf42"', JSON.stringify('___\uDF42')); +assertEquals('"___\\udf43"', JSON.stringify('___\uDF43')); +assertEquals('"___\\udf44"', JSON.stringify('___\uDF44')); +assertEquals('"___\\udf45"', JSON.stringify('___\uDF45')); +assertEquals('"___\\udf46"', JSON.stringify('___\uDF46')); +assertEquals('"___\\udf47"', JSON.stringify('___\uDF47')); +assertEquals('"___\\udf48"', JSON.stringify('___\uDF48')); +assertEquals('"___\\udf49"', JSON.stringify('___\uDF49')); +assertEquals('"___\\udf4a"', JSON.stringify('___\uDF4A')); +assertEquals('"___\\udf4b"', JSON.stringify('___\uDF4B')); +assertEquals('"___\\udf4c"', JSON.stringify('___\uDF4C')); +assertEquals('"___\\udf4d"', JSON.stringify('___\uDF4D')); +assertEquals('"___\\udf4e"', JSON.stringify('___\uDF4E')); +assertEquals('"___\\udf4f"', JSON.stringify('___\uDF4F')); +assertEquals('"___\\udf50"', JSON.stringify('___\uDF50')); +assertEquals('"___\\udf51"', JSON.stringify('___\uDF51')); +assertEquals('"___\\udf52"', JSON.stringify('___\uDF52')); +assertEquals('"___\\udf53"', JSON.stringify('___\uDF53')); +assertEquals('"___\\udf54"', JSON.stringify('___\uDF54')); +assertEquals('"___\\udf55"', JSON.stringify('___\uDF55')); +assertEquals('"___\\udf56"', JSON.stringify('___\uDF56')); +assertEquals('"___\\udf57"', JSON.stringify('___\uDF57')); +assertEquals('"___\\udf58"', JSON.stringify('___\uDF58')); +assertEquals('"___\\udf59"', JSON.stringify('___\uDF59')); +assertEquals('"___\\udf5a"', JSON.stringify('___\uDF5A')); +assertEquals('"___\\udf5b"', JSON.stringify('___\uDF5B')); +assertEquals('"___\\udf5c"', JSON.stringify('___\uDF5C')); +assertEquals('"___\\udf5d"', JSON.stringify('___\uDF5D')); +assertEquals('"___\\udf5e"', JSON.stringify('___\uDF5E')); +assertEquals('"___\\udf5f"', JSON.stringify('___\uDF5F')); +assertEquals('"___\\udf60"', JSON.stringify('___\uDF60')); +assertEquals('"___\\udf61"', JSON.stringify('___\uDF61')); +assertEquals('"___\\udf62"', JSON.stringify('___\uDF62')); +assertEquals('"___\\udf63"', JSON.stringify('___\uDF63')); +assertEquals('"___\\udf64"', JSON.stringify('___\uDF64')); +assertEquals('"___\\udf65"', JSON.stringify('___\uDF65')); +assertEquals('"___\\udf66"', JSON.stringify('___\uDF66')); +assertEquals('"___\\udf67"', JSON.stringify('___\uDF67')); +assertEquals('"___\\udf68"', JSON.stringify('___\uDF68')); +assertEquals('"___\\udf69"', JSON.stringify('___\uDF69')); +assertEquals('"___\\udf6a"', JSON.stringify('___\uDF6A')); +assertEquals('"___\\udf6b"', JSON.stringify('___\uDF6B')); +assertEquals('"___\\udf6c"', JSON.stringify('___\uDF6C')); +assertEquals('"___\\udf6d"', JSON.stringify('___\uDF6D')); +assertEquals('"___\\udf6e"', JSON.stringify('___\uDF6E')); +assertEquals('"___\\udf6f"', JSON.stringify('___\uDF6F')); +assertEquals('"___\\udf70"', JSON.stringify('___\uDF70')); +assertEquals('"___\\udf71"', JSON.stringify('___\uDF71')); +assertEquals('"___\\udf72"', JSON.stringify('___\uDF72')); +assertEquals('"___\\udf73"', JSON.stringify('___\uDF73')); +assertEquals('"___\\udf74"', JSON.stringify('___\uDF74')); +assertEquals('"___\\udf75"', JSON.stringify('___\uDF75')); +assertEquals('"___\\udf76"', JSON.stringify('___\uDF76')); +assertEquals('"___\\udf77"', JSON.stringify('___\uDF77')); +assertEquals('"___\\udf78"', JSON.stringify('___\uDF78')); +assertEquals('"___\\udf79"', JSON.stringify('___\uDF79')); +assertEquals('"___\\udf7a"', JSON.stringify('___\uDF7A')); +assertEquals('"___\\udf7b"', JSON.stringify('___\uDF7B')); +assertEquals('"___\\udf7c"', JSON.stringify('___\uDF7C')); +assertEquals('"___\\udf7d"', JSON.stringify('___\uDF7D')); +assertEquals('"___\\udf7e"', JSON.stringify('___\uDF7E')); +assertEquals('"___\\udf7f"', JSON.stringify('___\uDF7F')); +assertEquals('"___\\udf80"', JSON.stringify('___\uDF80')); +assertEquals('"___\\udf81"', JSON.stringify('___\uDF81')); +assertEquals('"___\\udf82"', JSON.stringify('___\uDF82')); +assertEquals('"___\\udf83"', JSON.stringify('___\uDF83')); +assertEquals('"___\\udf84"', JSON.stringify('___\uDF84')); +assertEquals('"___\\udf85"', JSON.stringify('___\uDF85')); +assertEquals('"___\\udf86"', JSON.stringify('___\uDF86')); +assertEquals('"___\\udf87"', JSON.stringify('___\uDF87')); +assertEquals('"___\\udf88"', JSON.stringify('___\uDF88')); +assertEquals('"___\\udf89"', JSON.stringify('___\uDF89')); +assertEquals('"___\\udf8a"', JSON.stringify('___\uDF8A')); +assertEquals('"___\\udf8b"', JSON.stringify('___\uDF8B')); +assertEquals('"___\\udf8c"', JSON.stringify('___\uDF8C')); +assertEquals('"___\\udf8d"', JSON.stringify('___\uDF8D')); +assertEquals('"___\\udf8e"', JSON.stringify('___\uDF8E')); +assertEquals('"___\\udf8f"', JSON.stringify('___\uDF8F')); +assertEquals('"___\\udf90"', JSON.stringify('___\uDF90')); +assertEquals('"___\\udf91"', JSON.stringify('___\uDF91')); +assertEquals('"___\\udf92"', JSON.stringify('___\uDF92')); +assertEquals('"___\\udf93"', JSON.stringify('___\uDF93')); +assertEquals('"___\\udf94"', JSON.stringify('___\uDF94')); +assertEquals('"___\\udf95"', JSON.stringify('___\uDF95')); +assertEquals('"___\\udf96"', JSON.stringify('___\uDF96')); +assertEquals('"___\\udf97"', JSON.stringify('___\uDF97')); +assertEquals('"___\\udf98"', JSON.stringify('___\uDF98')); +assertEquals('"___\\udf99"', JSON.stringify('___\uDF99')); +assertEquals('"___\\udf9a"', JSON.stringify('___\uDF9A')); +assertEquals('"___\\udf9b"', JSON.stringify('___\uDF9B')); +assertEquals('"___\\udf9c"', JSON.stringify('___\uDF9C')); +assertEquals('"___\\udf9d"', JSON.stringify('___\uDF9D')); +assertEquals('"___\\udf9e"', JSON.stringify('___\uDF9E')); +assertEquals('"___\\udf9f"', JSON.stringify('___\uDF9F')); +assertEquals('"___\\udfa0"', JSON.stringify('___\uDFA0')); +assertEquals('"___\\udfa1"', JSON.stringify('___\uDFA1')); +assertEquals('"___\\udfa2"', JSON.stringify('___\uDFA2')); +assertEquals('"___\\udfa3"', JSON.stringify('___\uDFA3')); +assertEquals('"___\\udfa4"', JSON.stringify('___\uDFA4')); +assertEquals('"___\\udfa5"', JSON.stringify('___\uDFA5')); +assertEquals('"___\\udfa6"', JSON.stringify('___\uDFA6')); +assertEquals('"___\\udfa7"', JSON.stringify('___\uDFA7')); +assertEquals('"___\\udfa8"', JSON.stringify('___\uDFA8')); +assertEquals('"___\\udfa9"', JSON.stringify('___\uDFA9')); +assertEquals('"___\\udfaa"', JSON.stringify('___\uDFAA')); +assertEquals('"___\\udfab"', JSON.stringify('___\uDFAB')); +assertEquals('"___\\udfac"', JSON.stringify('___\uDFAC')); +assertEquals('"___\\udfad"', JSON.stringify('___\uDFAD')); +assertEquals('"___\\udfae"', JSON.stringify('___\uDFAE')); +assertEquals('"___\\udfaf"', JSON.stringify('___\uDFAF')); +assertEquals('"___\\udfb0"', JSON.stringify('___\uDFB0')); +assertEquals('"___\\udfb1"', JSON.stringify('___\uDFB1')); +assertEquals('"___\\udfb2"', JSON.stringify('___\uDFB2')); +assertEquals('"___\\udfb3"', JSON.stringify('___\uDFB3')); +assertEquals('"___\\udfb4"', JSON.stringify('___\uDFB4')); +assertEquals('"___\\udfb5"', JSON.stringify('___\uDFB5')); +assertEquals('"___\\udfb6"', JSON.stringify('___\uDFB6')); +assertEquals('"___\\udfb7"', JSON.stringify('___\uDFB7')); +assertEquals('"___\\udfb8"', JSON.stringify('___\uDFB8')); +assertEquals('"___\\udfb9"', JSON.stringify('___\uDFB9')); +assertEquals('"___\\udfba"', JSON.stringify('___\uDFBA')); +assertEquals('"___\\udfbb"', JSON.stringify('___\uDFBB')); +assertEquals('"___\\udfbc"', JSON.stringify('___\uDFBC')); +assertEquals('"___\\udfbd"', JSON.stringify('___\uDFBD')); +assertEquals('"___\\udfbe"', JSON.stringify('___\uDFBE')); +assertEquals('"___\\udfbf"', JSON.stringify('___\uDFBF')); +assertEquals('"___\\udfc0"', JSON.stringify('___\uDFC0')); +assertEquals('"___\\udfc1"', JSON.stringify('___\uDFC1')); +assertEquals('"___\\udfc2"', JSON.stringify('___\uDFC2')); +assertEquals('"___\\udfc3"', JSON.stringify('___\uDFC3')); +assertEquals('"___\\udfc4"', JSON.stringify('___\uDFC4')); +assertEquals('"___\\udfc5"', JSON.stringify('___\uDFC5')); +assertEquals('"___\\udfc6"', JSON.stringify('___\uDFC6')); +assertEquals('"___\\udfc7"', JSON.stringify('___\uDFC7')); +assertEquals('"___\\udfc8"', JSON.stringify('___\uDFC8')); +assertEquals('"___\\udfc9"', JSON.stringify('___\uDFC9')); +assertEquals('"___\\udfca"', JSON.stringify('___\uDFCA')); +assertEquals('"___\\udfcb"', JSON.stringify('___\uDFCB')); +assertEquals('"___\\udfcc"', JSON.stringify('___\uDFCC')); +assertEquals('"___\\udfcd"', JSON.stringify('___\uDFCD')); +assertEquals('"___\\udfce"', JSON.stringify('___\uDFCE')); +assertEquals('"___\\udfcf"', JSON.stringify('___\uDFCF')); +assertEquals('"___\\udfd0"', JSON.stringify('___\uDFD0')); +assertEquals('"___\\udfd1"', JSON.stringify('___\uDFD1')); +assertEquals('"___\\udfd2"', JSON.stringify('___\uDFD2')); +assertEquals('"___\\udfd3"', JSON.stringify('___\uDFD3')); +assertEquals('"___\\udfd4"', JSON.stringify('___\uDFD4')); +assertEquals('"___\\udfd5"', JSON.stringify('___\uDFD5')); +assertEquals('"___\\udfd6"', JSON.stringify('___\uDFD6')); +assertEquals('"___\\udfd7"', JSON.stringify('___\uDFD7')); +assertEquals('"___\\udfd8"', JSON.stringify('___\uDFD8')); +assertEquals('"___\\udfd9"', JSON.stringify('___\uDFD9')); +assertEquals('"___\\udfda"', JSON.stringify('___\uDFDA')); +assertEquals('"___\\udfdb"', JSON.stringify('___\uDFDB')); +assertEquals('"___\\udfdc"', JSON.stringify('___\uDFDC')); +assertEquals('"___\\udfdd"', JSON.stringify('___\uDFDD')); +assertEquals('"___\\udfde"', JSON.stringify('___\uDFDE')); +assertEquals('"___\\udfdf"', JSON.stringify('___\uDFDF')); +assertEquals('"___\\udfe0"', JSON.stringify('___\uDFE0')); +assertEquals('"___\\udfe1"', JSON.stringify('___\uDFE1')); +assertEquals('"___\\udfe2"', JSON.stringify('___\uDFE2')); +assertEquals('"___\\udfe3"', JSON.stringify('___\uDFE3')); +assertEquals('"___\\udfe4"', JSON.stringify('___\uDFE4')); +assertEquals('"___\\udfe5"', JSON.stringify('___\uDFE5')); +assertEquals('"___\\udfe6"', JSON.stringify('___\uDFE6')); +assertEquals('"___\\udfe7"', JSON.stringify('___\uDFE7')); +assertEquals('"___\\udfe8"', JSON.stringify('___\uDFE8')); +assertEquals('"___\\udfe9"', JSON.stringify('___\uDFE9')); +assertEquals('"___\\udfea"', JSON.stringify('___\uDFEA')); +assertEquals('"___\\udfeb"', JSON.stringify('___\uDFEB')); +assertEquals('"___\\udfec"', JSON.stringify('___\uDFEC')); +assertEquals('"___\\udfed"', JSON.stringify('___\uDFED')); +assertEquals('"___\\udfee"', JSON.stringify('___\uDFEE')); +assertEquals('"___\\udfef"', JSON.stringify('___\uDFEF')); +assertEquals('"___\\udff0"', JSON.stringify('___\uDFF0')); +assertEquals('"___\\udff1"', JSON.stringify('___\uDFF1')); +assertEquals('"___\\udff2"', JSON.stringify('___\uDFF2')); +assertEquals('"___\\udff3"', JSON.stringify('___\uDFF3')); +assertEquals('"___\\udff4"', JSON.stringify('___\uDFF4')); +assertEquals('"___\\udff5"', JSON.stringify('___\uDFF5')); +assertEquals('"___\\udff6"', JSON.stringify('___\uDFF6')); +assertEquals('"___\\udff7"', JSON.stringify('___\uDFF7')); +assertEquals('"___\\udff8"', JSON.stringify('___\uDFF8')); +assertEquals('"___\\udff9"', JSON.stringify('___\uDFF9')); +assertEquals('"___\\udffa"', JSON.stringify('___\uDFFA')); +assertEquals('"___\\udffb"', JSON.stringify('___\uDFFB')); +assertEquals('"___\\udffc"', JSON.stringify('___\uDFFC')); +assertEquals('"___\\udffd"', JSON.stringify('___\uDFFD')); +assertEquals('"___\\udffe"', JSON.stringify('___\uDFFE')); +assertEquals('"___\\udfff"', JSON.stringify('___\uDFFF')); + +// A random selection of code points from U+E000 to U+FFFF. +assertEquals('"___\uE000"', JSON.stringify('___\uE000')); +assertEquals('"___\uE00B"', JSON.stringify('___\uE00B')); +assertEquals('"___\uE0CC"', JSON.stringify('___\uE0CC')); +assertEquals('"___\uE0FD"', JSON.stringify('___\uE0FD')); +assertEquals('"___\uE19E"', JSON.stringify('___\uE19E')); +assertEquals('"___\uE1B1"', JSON.stringify('___\uE1B1')); +assertEquals('"___\uE24F"', JSON.stringify('___\uE24F')); +assertEquals('"___\uE262"', JSON.stringify('___\uE262')); +assertEquals('"___\uE2C9"', JSON.stringify('___\uE2C9')); +assertEquals('"___\uE2DF"', JSON.stringify('___\uE2DF')); +assertEquals('"___\uE389"', JSON.stringify('___\uE389')); +assertEquals('"___\uE413"', JSON.stringify('___\uE413')); +assertEquals('"___\uE546"', JSON.stringify('___\uE546')); +assertEquals('"___\uE5E4"', JSON.stringify('___\uE5E4')); +assertEquals('"___\uE66B"', JSON.stringify('___\uE66B')); +assertEquals('"___\uE73D"', JSON.stringify('___\uE73D')); +assertEquals('"___\uE74F"', JSON.stringify('___\uE74F')); +assertEquals('"___\uE759"', JSON.stringify('___\uE759')); +assertEquals('"___\uE795"', JSON.stringify('___\uE795')); +assertEquals('"___\uE836"', JSON.stringify('___\uE836')); +assertEquals('"___\uE85D"', JSON.stringify('___\uE85D')); +assertEquals('"___\uE909"', JSON.stringify('___\uE909')); +assertEquals('"___\uE990"', JSON.stringify('___\uE990')); +assertEquals('"___\uE99F"', JSON.stringify('___\uE99F')); +assertEquals('"___\uE9AC"', JSON.stringify('___\uE9AC')); +assertEquals('"___\uE9C2"', JSON.stringify('___\uE9C2')); +assertEquals('"___\uEB11"', JSON.stringify('___\uEB11')); +assertEquals('"___\uED33"', JSON.stringify('___\uED33')); +assertEquals('"___\uED7D"', JSON.stringify('___\uED7D')); +assertEquals('"___\uEDA9"', JSON.stringify('___\uEDA9')); +assertEquals('"___\uEDFB"', JSON.stringify('___\uEDFB')); +assertEquals('"___\uEE09"', JSON.stringify('___\uEE09')); +assertEquals('"___\uEE0D"', JSON.stringify('___\uEE0D')); +assertEquals('"___\uEE34"', JSON.stringify('___\uEE34')); +assertEquals('"___\uEE37"', JSON.stringify('___\uEE37')); +assertEquals('"___\uEE38"', JSON.stringify('___\uEE38')); +assertEquals('"___\uEF80"', JSON.stringify('___\uEF80')); +assertEquals('"___\uEFE2"', JSON.stringify('___\uEFE2')); +assertEquals('"___\uF02C"', JSON.stringify('___\uF02C')); +assertEquals('"___\uF09A"', JSON.stringify('___\uF09A')); +assertEquals('"___\uF0C1"', JSON.stringify('___\uF0C1')); +assertEquals('"___\uF12C"', JSON.stringify('___\uF12C')); +assertEquals('"___\uF250"', JSON.stringify('___\uF250')); +assertEquals('"___\uF2A3"', JSON.stringify('___\uF2A3')); +assertEquals('"___\uF340"', JSON.stringify('___\uF340')); +assertEquals('"___\uF3C9"', JSON.stringify('___\uF3C9')); +assertEquals('"___\uF3F5"', JSON.stringify('___\uF3F5')); +assertEquals('"___\uF41B"', JSON.stringify('___\uF41B')); +assertEquals('"___\uF420"', JSON.stringify('___\uF420')); +assertEquals('"___\uF440"', JSON.stringify('___\uF440')); +assertEquals('"___\uF4AE"', JSON.stringify('___\uF4AE')); +assertEquals('"___\uF4B0"', JSON.stringify('___\uF4B0')); +assertEquals('"___\uF50D"', JSON.stringify('___\uF50D')); +assertEquals('"___\uF55D"', JSON.stringify('___\uF55D')); +assertEquals('"___\uF55E"', JSON.stringify('___\uF55E')); +assertEquals('"___\uF5CD"', JSON.stringify('___\uF5CD')); +assertEquals('"___\uF657"', JSON.stringify('___\uF657')); +assertEquals('"___\uF66D"', JSON.stringify('___\uF66D')); +assertEquals('"___\uF68F"', JSON.stringify('___\uF68F')); +assertEquals('"___\uF6A6"', JSON.stringify('___\uF6A6')); +assertEquals('"___\uF6AA"', JSON.stringify('___\uF6AA')); +assertEquals('"___\uF6EB"', JSON.stringify('___\uF6EB')); +assertEquals('"___\uF79A"', JSON.stringify('___\uF79A')); +assertEquals('"___\uF7E7"', JSON.stringify('___\uF7E7')); +assertEquals('"___\uF7E8"', JSON.stringify('___\uF7E8')); +assertEquals('"___\uF834"', JSON.stringify('___\uF834')); +assertEquals('"___\uF88B"', JSON.stringify('___\uF88B')); +assertEquals('"___\uF8D5"', JSON.stringify('___\uF8D5')); +assertEquals('"___\uF8F1"', JSON.stringify('___\uF8F1')); +assertEquals('"___\uF905"', JSON.stringify('___\uF905')); +assertEquals('"___\uF927"', JSON.stringify('___\uF927')); +assertEquals('"___\uF943"', JSON.stringify('___\uF943')); +assertEquals('"___\uF949"', JSON.stringify('___\uF949')); +assertEquals('"___\uF9A1"', JSON.stringify('___\uF9A1')); +assertEquals('"___\uF9C7"', JSON.stringify('___\uF9C7')); +assertEquals('"___\uFA0F"', JSON.stringify('___\uFA0F')); +assertEquals('"___\uFA20"', JSON.stringify('___\uFA20')); +assertEquals('"___\uFAA7"', JSON.stringify('___\uFAA7')); +assertEquals('"___\uFBCD"', JSON.stringify('___\uFBCD')); +assertEquals('"___\uFBF7"', JSON.stringify('___\uFBF7')); +assertEquals('"___\uFC40"', JSON.stringify('___\uFC40')); +assertEquals('"___\uFC4B"', JSON.stringify('___\uFC4B')); +assertEquals('"___\uFC51"', JSON.stringify('___\uFC51')); +assertEquals('"___\uFC5E"', JSON.stringify('___\uFC5E')); +assertEquals('"___\uFC67"', JSON.stringify('___\uFC67')); +assertEquals('"___\uFC8B"', JSON.stringify('___\uFC8B')); +assertEquals('"___\uFE32"', JSON.stringify('___\uFE32')); +assertEquals('"___\uFFC4"', JSON.stringify('___\uFFC4')); +assertEquals('"___\uFFFD"', JSON.stringify('___\uFFFD')); +assertEquals('"___\uFFFE"', JSON.stringify('___\uFFFE')); +assertEquals('"___\uFFFF"', JSON.stringify('___\uFFFF')); + +// A random selection of astral symbols, i.e. surrogate pairs, i.e. +// code points from U+010000 to U+10FFFF. +assertEquals('"___\u{10000}"', JSON.stringify('___\u{10000}')); +assertEquals('"___\u{11DE7}"', JSON.stringify('___\u{11DE7}')); +assertEquals('"___\u{15997}"', JSON.stringify('___\u{15997}')); +assertEquals('"___\u{187B0}"', JSON.stringify('___\u{187B0}')); +assertEquals('"___\u{190B2}"', JSON.stringify('___\u{190B2}')); +assertEquals('"___\u{1BF79}"', JSON.stringify('___\u{1BF79}')); +assertEquals('"___\u{1C624}"', JSON.stringify('___\u{1C624}')); +assertEquals('"___\u{1D9F4}"', JSON.stringify('___\u{1D9F4}')); +assertEquals('"___\u{24149}"', JSON.stringify('___\u{24149}')); +assertEquals('"___\u{2521C}"', JSON.stringify('___\u{2521C}')); +assertEquals('"___\u{2762D}"', JSON.stringify('___\u{2762D}')); +assertEquals('"___\u{2930B}"', JSON.stringify('___\u{2930B}')); +assertEquals('"___\u{29EC4}"', JSON.stringify('___\u{29EC4}')); +assertEquals('"___\u{29F9A}"', JSON.stringify('___\u{29F9A}')); +assertEquals('"___\u{2A27D}"', JSON.stringify('___\u{2A27D}')); +assertEquals('"___\u{2B363}"', JSON.stringify('___\u{2B363}')); +assertEquals('"___\u{2C037}"', JSON.stringify('___\u{2C037}')); +assertEquals('"___\u{2FAE0}"', JSON.stringify('___\u{2FAE0}')); +assertEquals('"___\u{2FFCF}"', JSON.stringify('___\u{2FFCF}')); +assertEquals('"___\u{32C1C}"', JSON.stringify('___\u{32C1C}')); +assertEquals('"___\u{33DA8}"', JSON.stringify('___\u{33DA8}')); +assertEquals('"___\u{3DCA4}"', JSON.stringify('___\u{3DCA4}')); +assertEquals('"___\u{44FA0}"', JSON.stringify('___\u{44FA0}')); +assertEquals('"___\u{45618}"', JSON.stringify('___\u{45618}')); +assertEquals('"___\u{47395}"', JSON.stringify('___\u{47395}')); +assertEquals('"___\u{4752C}"', JSON.stringify('___\u{4752C}')); +assertEquals('"___\u{483FE}"', JSON.stringify('___\u{483FE}')); +assertEquals('"___\u{49D35}"', JSON.stringify('___\u{49D35}')); +assertEquals('"___\u{4CE3B}"', JSON.stringify('___\u{4CE3B}')); +assertEquals('"___\u{55196}"', JSON.stringify('___\u{55196}')); +assertEquals('"___\u{58B3E}"', JSON.stringify('___\u{58B3E}')); +assertEquals('"___\u{5AA47}"', JSON.stringify('___\u{5AA47}')); +assertEquals('"___\u{5C4B8}"', JSON.stringify('___\u{5C4B8}')); +assertEquals('"___\u{5DD1B}"', JSON.stringify('___\u{5DD1B}')); +assertEquals('"___\u{5FDCB}"', JSON.stringify('___\u{5FDCB}')); +assertEquals('"___\u{611BA}"', JSON.stringify('___\u{611BA}')); +assertEquals('"___\u{66433}"', JSON.stringify('___\u{66433}')); +assertEquals('"___\u{690D7}"', JSON.stringify('___\u{690D7}')); +assertEquals('"___\u{6F617}"', JSON.stringify('___\u{6F617}')); +assertEquals('"___\u{711E4}"', JSON.stringify('___\u{711E4}')); +assertEquals('"___\u{758D2}"', JSON.stringify('___\u{758D2}')); +assertEquals('"___\u{780AC}"', JSON.stringify('___\u{780AC}')); +assertEquals('"___\u{7AE5F}"', JSON.stringify('___\u{7AE5F}')); +assertEquals('"___\u{7C2FB}"', JSON.stringify('___\u{7C2FB}')); +assertEquals('"___\u{7D25F}"', JSON.stringify('___\u{7D25F}')); +assertEquals('"___\u{8027A}"', JSON.stringify('___\u{8027A}')); +assertEquals('"___\u{84817}"', JSON.stringify('___\u{84817}')); +assertEquals('"___\u{8B070}"', JSON.stringify('___\u{8B070}')); +assertEquals('"___\u{8B390}"', JSON.stringify('___\u{8B390}')); +assertEquals('"___\u{8BC03}"', JSON.stringify('___\u{8BC03}')); +assertEquals('"___\u{8BE63}"', JSON.stringify('___\u{8BE63}')); +assertEquals('"___\u{8F12A}"', JSON.stringify('___\u{8F12A}')); +assertEquals('"___\u{9345D}"', JSON.stringify('___\u{9345D}')); +assertEquals('"___\u{937A9}"', JSON.stringify('___\u{937A9}')); +assertEquals('"___\u{94596}"', JSON.stringify('___\u{94596}')); +assertEquals('"___\u{967BB}"', JSON.stringify('___\u{967BB}')); +assertEquals('"___\u{A19D1}"', JSON.stringify('___\u{A19D1}')); +assertEquals('"___\u{A4FC5}"', JSON.stringify('___\u{A4FC5}')); +assertEquals('"___\u{AC9CF}"', JSON.stringify('___\u{AC9CF}')); +assertEquals('"___\u{B1366}"', JSON.stringify('___\u{B1366}')); +assertEquals('"___\u{B3D32}"', JSON.stringify('___\u{B3D32}')); +assertEquals('"___\u{B74BA}"', JSON.stringify('___\u{B74BA}')); +assertEquals('"___\u{B8FB0}"', JSON.stringify('___\u{B8FB0}')); +assertEquals('"___\u{BA0A5}"', JSON.stringify('___\u{BA0A5}')); +assertEquals('"___\u{BB48E}"', JSON.stringify('___\u{BB48E}')); +assertEquals('"___\u{C0B60}"', JSON.stringify('___\u{C0B60}')); +assertEquals('"___\u{C2D34}"', JSON.stringify('___\u{C2D34}')); +assertEquals('"___\u{C6C75}"', JSON.stringify('___\u{C6C75}')); +assertEquals('"___\u{C9F26}"', JSON.stringify('___\u{C9F26}')); +assertEquals('"___\u{CDBD0}"', JSON.stringify('___\u{CDBD0}')); +assertEquals('"___\u{D1E28}"', JSON.stringify('___\u{D1E28}')); +assertEquals('"___\u{D4A80}"', JSON.stringify('___\u{D4A80}')); +assertEquals('"___\u{D947F}"', JSON.stringify('___\u{D947F}')); +assertEquals('"___\u{D9B8A}"', JSON.stringify('___\u{D9B8A}')); +assertEquals('"___\u{DA203}"', JSON.stringify('___\u{DA203}')); +assertEquals('"___\u{DEFD3}"', JSON.stringify('___\u{DEFD3}')); +assertEquals('"___\u{E4F7C}"', JSON.stringify('___\u{E4F7C}')); +assertEquals('"___\u{E6BB3}"', JSON.stringify('___\u{E6BB3}')); +assertEquals('"___\u{E972D}"', JSON.stringify('___\u{E972D}')); +assertEquals('"___\u{EB335}"', JSON.stringify('___\u{EB335}')); +assertEquals('"___\u{ED3F8}"', JSON.stringify('___\u{ED3F8}')); +assertEquals('"___\u{ED940}"', JSON.stringify('___\u{ED940}')); +assertEquals('"___\u{EF6F8}"', JSON.stringify('___\u{EF6F8}')); +assertEquals('"___\u{F1F57}"', JSON.stringify('___\u{F1F57}')); +assertEquals('"___\u{F33B5}"', JSON.stringify('___\u{F33B5}')); +assertEquals('"___\u{F4D2A}"', JSON.stringify('___\u{F4D2A}')); +assertEquals('"___\u{F70BA}"', JSON.stringify('___\u{F70BA}')); +assertEquals('"___\u{F899F}"', JSON.stringify('___\u{F899F}')); +assertEquals('"___\u{1034BF}"', JSON.stringify('___\u{1034BF}')); +assertEquals('"___\u{107ACF}"', JSON.stringify('___\u{107ACF}')); +assertEquals('"___\u{10881F}"', JSON.stringify('___\u{10881F}')); +assertEquals('"___\u{1098A5}"', JSON.stringify('___\u{1098A5}')); +assertEquals('"___\u{10ABD1}"', JSON.stringify('___\u{10ABD1}')); +assertEquals('"___\u{10B5C5}"', JSON.stringify('___\u{10B5C5}')); +assertEquals('"___\u{10CC79}"', JSON.stringify('___\u{10CC79}')); +assertEquals('"___\u{10CD19}"', JSON.stringify('___\u{10CD19}')); +assertEquals('"___\u{10FFFF}"', JSON.stringify('___\u{10FFFF}')); diff --git a/deps/v8/test/mjsunit/harmony/well-formed-json-stringify-unchecked.js b/deps/v8/test/mjsunit/harmony/well-formed-json-stringify-unchecked.js new file mode 100644 index 0000000000..260d748ece --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/well-formed-json-stringify-unchecked.js @@ -0,0 +1,2575 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --harmony-json-stringify + +// Test JSON.stringify for cases that hit +// JsonStringifier::SerializeStringUnchecked_. + +// All code points from U+0000 to U+00FF. +assertEquals('"\\u0000"', JSON.stringify('\0')); +assertEquals('"\\u0001"', JSON.stringify('\x01')); +assertEquals('"\\u0002"', JSON.stringify('\x02')); +assertEquals('"\\u0003"', JSON.stringify('\x03')); +assertEquals('"\\u0004"', JSON.stringify('\x04')); +assertEquals('"\\u0005"', JSON.stringify('\x05')); +assertEquals('"\\u0006"', JSON.stringify('\x06')); +assertEquals('"\\u0007"', JSON.stringify('\x07')); +assertEquals('"\\b"', JSON.stringify('\b')); +assertEquals('"\\t"', JSON.stringify('\t')); +assertEquals('"\\n"', JSON.stringify('\n')); +assertEquals('"\\u000b"', JSON.stringify('\x0B')); +assertEquals('"\\f"', JSON.stringify('\f')); +assertEquals('"\\r"', JSON.stringify('\r')); +assertEquals('"\\u000e"', JSON.stringify('\x0E')); +assertEquals('"\\u000f"', JSON.stringify('\x0F')); +assertEquals('"\\u0010"', JSON.stringify('\x10')); +assertEquals('"\\u0011"', JSON.stringify('\x11')); +assertEquals('"\\u0012"', JSON.stringify('\x12')); +assertEquals('"\\u0013"', JSON.stringify('\x13')); +assertEquals('"\\u0014"', JSON.stringify('\x14')); +assertEquals('"\\u0015"', JSON.stringify('\x15')); +assertEquals('"\\u0016"', JSON.stringify('\x16')); +assertEquals('"\\u0017"', JSON.stringify('\x17')); +assertEquals('"\\u0018"', JSON.stringify('\x18')); +assertEquals('"\\u0019"', JSON.stringify('\x19')); +assertEquals('"\\u001a"', JSON.stringify('\x1A')); +assertEquals('"\\u001b"', JSON.stringify('\x1B')); +assertEquals('"\\u001c"', JSON.stringify('\x1C')); +assertEquals('"\\u001d"', JSON.stringify('\x1D')); +assertEquals('"\\u001e"', JSON.stringify('\x1E')); +assertEquals('"\\u001f"', JSON.stringify('\x1F')); +assertEquals('" "', JSON.stringify(' ')); +assertEquals('"!"', JSON.stringify('!')); +assertEquals('"\\""', JSON.stringify('"')); +assertEquals('"#"', JSON.stringify('#')); +assertEquals('"$"', JSON.stringify('$')); +assertEquals('"%"', JSON.stringify('%')); +assertEquals('"&"', JSON.stringify('&')); +assertEquals('"\'"', JSON.stringify('\'')); +assertEquals('"("', JSON.stringify('(')); +assertEquals('")"', JSON.stringify(')')); +assertEquals('"*"', JSON.stringify('*')); +assertEquals('"+"', JSON.stringify('+')); +assertEquals('","', JSON.stringify(',')); +assertEquals('"-"', JSON.stringify('-')); +assertEquals('"."', JSON.stringify('.')); +assertEquals('"/"', JSON.stringify('/')); +assertEquals('"0"', JSON.stringify('0')); +assertEquals('"1"', JSON.stringify('1')); +assertEquals('"2"', JSON.stringify('2')); +assertEquals('"3"', JSON.stringify('3')); +assertEquals('"4"', JSON.stringify('4')); +assertEquals('"5"', JSON.stringify('5')); +assertEquals('"6"', JSON.stringify('6')); +assertEquals('"7"', JSON.stringify('7')); +assertEquals('"8"', JSON.stringify('8')); +assertEquals('"9"', JSON.stringify('9')); +assertEquals('":"', JSON.stringify(':')); +assertEquals('";"', JSON.stringify(';')); +assertEquals('"<"', JSON.stringify('<')); +assertEquals('"="', JSON.stringify('=')); +assertEquals('">"', JSON.stringify('>')); +assertEquals('"?"', JSON.stringify('?')); +assertEquals('"@"', JSON.stringify('@')); +assertEquals('"A"', JSON.stringify('A')); +assertEquals('"B"', JSON.stringify('B')); +assertEquals('"C"', JSON.stringify('C')); +assertEquals('"D"', JSON.stringify('D')); +assertEquals('"E"', JSON.stringify('E')); +assertEquals('"F"', JSON.stringify('F')); +assertEquals('"G"', JSON.stringify('G')); +assertEquals('"H"', JSON.stringify('H')); +assertEquals('"I"', JSON.stringify('I')); +assertEquals('"J"', JSON.stringify('J')); +assertEquals('"K"', JSON.stringify('K')); +assertEquals('"L"', JSON.stringify('L')); +assertEquals('"M"', JSON.stringify('M')); +assertEquals('"N"', JSON.stringify('N')); +assertEquals('"O"', JSON.stringify('O')); +assertEquals('"P"', JSON.stringify('P')); +assertEquals('"Q"', JSON.stringify('Q')); +assertEquals('"R"', JSON.stringify('R')); +assertEquals('"S"', JSON.stringify('S')); +assertEquals('"T"', JSON.stringify('T')); +assertEquals('"U"', JSON.stringify('U')); +assertEquals('"V"', JSON.stringify('V')); +assertEquals('"W"', JSON.stringify('W')); +assertEquals('"X"', JSON.stringify('X')); +assertEquals('"Y"', JSON.stringify('Y')); +assertEquals('"Z"', JSON.stringify('Z')); +assertEquals('"["', JSON.stringify('[')); +assertEquals('"\\\\"', JSON.stringify('\\')); +assertEquals('"]"', JSON.stringify(']')); +assertEquals('"^"', JSON.stringify('^')); +assertEquals('"_"', JSON.stringify('_')); +assertEquals('"`"', JSON.stringify('`')); +assertEquals('"a"', JSON.stringify('a')); +assertEquals('"b"', JSON.stringify('b')); +assertEquals('"c"', JSON.stringify('c')); +assertEquals('"d"', JSON.stringify('d')); +assertEquals('"e"', JSON.stringify('e')); +assertEquals('"f"', JSON.stringify('f')); +assertEquals('"g"', JSON.stringify('g')); +assertEquals('"h"', JSON.stringify('h')); +assertEquals('"i"', JSON.stringify('i')); +assertEquals('"j"', JSON.stringify('j')); +assertEquals('"k"', JSON.stringify('k')); +assertEquals('"l"', JSON.stringify('l')); +assertEquals('"m"', JSON.stringify('m')); +assertEquals('"n"', JSON.stringify('n')); +assertEquals('"o"', JSON.stringify('o')); +assertEquals('"p"', JSON.stringify('p')); +assertEquals('"q"', JSON.stringify('q')); +assertEquals('"r"', JSON.stringify('r')); +assertEquals('"s"', JSON.stringify('s')); +assertEquals('"t"', JSON.stringify('t')); +assertEquals('"u"', JSON.stringify('u')); +assertEquals('"v"', JSON.stringify('v')); +assertEquals('"w"', JSON.stringify('w')); +assertEquals('"x"', JSON.stringify('x')); +assertEquals('"y"', JSON.stringify('y')); +assertEquals('"z"', JSON.stringify('z')); +assertEquals('"{"', JSON.stringify('{')); +assertEquals('"|"', JSON.stringify('|')); +assertEquals('"}"', JSON.stringify('}')); +assertEquals('"~"', JSON.stringify('~')); +assertEquals('"\x7F"', JSON.stringify('\x7F')); +assertEquals('"\x80"', JSON.stringify('\x80')); +assertEquals('"\x81"', JSON.stringify('\x81')); +assertEquals('"\x82"', JSON.stringify('\x82')); +assertEquals('"\x83"', JSON.stringify('\x83')); +assertEquals('"\x84"', JSON.stringify('\x84')); +assertEquals('"\x85"', JSON.stringify('\x85')); +assertEquals('"\x86"', JSON.stringify('\x86')); +assertEquals('"\x87"', JSON.stringify('\x87')); +assertEquals('"\x88"', JSON.stringify('\x88')); +assertEquals('"\x89"', JSON.stringify('\x89')); +assertEquals('"\x8A"', JSON.stringify('\x8A')); +assertEquals('"\x8B"', JSON.stringify('\x8B')); +assertEquals('"\x8C"', JSON.stringify('\x8C')); +assertEquals('"\x8D"', JSON.stringify('\x8D')); +assertEquals('"\x8E"', JSON.stringify('\x8E')); +assertEquals('"\x8F"', JSON.stringify('\x8F')); +assertEquals('"\x90"', JSON.stringify('\x90')); +assertEquals('"\x91"', JSON.stringify('\x91')); +assertEquals('"\x92"', JSON.stringify('\x92')); +assertEquals('"\x93"', JSON.stringify('\x93')); +assertEquals('"\x94"', JSON.stringify('\x94')); +assertEquals('"\x95"', JSON.stringify('\x95')); +assertEquals('"\x96"', JSON.stringify('\x96')); +assertEquals('"\x97"', JSON.stringify('\x97')); +assertEquals('"\x98"', JSON.stringify('\x98')); +assertEquals('"\x99"', JSON.stringify('\x99')); +assertEquals('"\x9A"', JSON.stringify('\x9A')); +assertEquals('"\x9B"', JSON.stringify('\x9B')); +assertEquals('"\x9C"', JSON.stringify('\x9C')); +assertEquals('"\x9D"', JSON.stringify('\x9D')); +assertEquals('"\x9E"', JSON.stringify('\x9E')); +assertEquals('"\x9F"', JSON.stringify('\x9F')); +assertEquals('"\xA0"', JSON.stringify('\xA0')); +assertEquals('"\xA1"', JSON.stringify('\xA1')); +assertEquals('"\xA2"', JSON.stringify('\xA2')); +assertEquals('"\xA3"', JSON.stringify('\xA3')); +assertEquals('"\xA4"', JSON.stringify('\xA4')); +assertEquals('"\xA5"', JSON.stringify('\xA5')); +assertEquals('"\xA6"', JSON.stringify('\xA6')); +assertEquals('"\xA7"', JSON.stringify('\xA7')); +assertEquals('"\xA8"', JSON.stringify('\xA8')); +assertEquals('"\xA9"', JSON.stringify('\xA9')); +assertEquals('"\xAA"', JSON.stringify('\xAA')); +assertEquals('"\xAB"', JSON.stringify('\xAB')); +assertEquals('"\xAC"', JSON.stringify('\xAC')); +assertEquals('"\xAD"', JSON.stringify('\xAD')); +assertEquals('"\xAE"', JSON.stringify('\xAE')); +assertEquals('"\xAF"', JSON.stringify('\xAF')); +assertEquals('"\xB0"', JSON.stringify('\xB0')); +assertEquals('"\xB1"', JSON.stringify('\xB1')); +assertEquals('"\xB2"', JSON.stringify('\xB2')); +assertEquals('"\xB3"', JSON.stringify('\xB3')); +assertEquals('"\xB4"', JSON.stringify('\xB4')); +assertEquals('"\xB5"', JSON.stringify('\xB5')); +assertEquals('"\xB6"', JSON.stringify('\xB6')); +assertEquals('"\xB7"', JSON.stringify('\xB7')); +assertEquals('"\xB8"', JSON.stringify('\xB8')); +assertEquals('"\xB9"', JSON.stringify('\xB9')); +assertEquals('"\xBA"', JSON.stringify('\xBA')); +assertEquals('"\xBB"', JSON.stringify('\xBB')); +assertEquals('"\xBC"', JSON.stringify('\xBC')); +assertEquals('"\xBD"', JSON.stringify('\xBD')); +assertEquals('"\xBE"', JSON.stringify('\xBE')); +assertEquals('"\xBF"', JSON.stringify('\xBF')); +assertEquals('"\xC0"', JSON.stringify('\xC0')); +assertEquals('"\xC1"', JSON.stringify('\xC1')); +assertEquals('"\xC2"', JSON.stringify('\xC2')); +assertEquals('"\xC3"', JSON.stringify('\xC3')); +assertEquals('"\xC4"', JSON.stringify('\xC4')); +assertEquals('"\xC5"', JSON.stringify('\xC5')); +assertEquals('"\xC6"', JSON.stringify('\xC6')); +assertEquals('"\xC7"', JSON.stringify('\xC7')); +assertEquals('"\xC8"', JSON.stringify('\xC8')); +assertEquals('"\xC9"', JSON.stringify('\xC9')); +assertEquals('"\xCA"', JSON.stringify('\xCA')); +assertEquals('"\xCB"', JSON.stringify('\xCB')); +assertEquals('"\xCC"', JSON.stringify('\xCC')); +assertEquals('"\xCD"', JSON.stringify('\xCD')); +assertEquals('"\xCE"', JSON.stringify('\xCE')); +assertEquals('"\xCF"', JSON.stringify('\xCF')); +assertEquals('"\xD0"', JSON.stringify('\xD0')); +assertEquals('"\xD1"', JSON.stringify('\xD1')); +assertEquals('"\xD2"', JSON.stringify('\xD2')); +assertEquals('"\xD3"', JSON.stringify('\xD3')); +assertEquals('"\xD4"', JSON.stringify('\xD4')); +assertEquals('"\xD5"', JSON.stringify('\xD5')); +assertEquals('"\xD6"', JSON.stringify('\xD6')); +assertEquals('"\xD7"', JSON.stringify('\xD7')); +assertEquals('"\xD8"', JSON.stringify('\xD8')); +assertEquals('"\xD9"', JSON.stringify('\xD9')); +assertEquals('"\xDA"', JSON.stringify('\xDA')); +assertEquals('"\xDB"', JSON.stringify('\xDB')); +assertEquals('"\xDC"', JSON.stringify('\xDC')); +assertEquals('"\xDD"', JSON.stringify('\xDD')); +assertEquals('"\xDE"', JSON.stringify('\xDE')); +assertEquals('"\xDF"', JSON.stringify('\xDF')); +assertEquals('"\xE0"', JSON.stringify('\xE0')); +assertEquals('"\xE1"', JSON.stringify('\xE1')); +assertEquals('"\xE2"', JSON.stringify('\xE2')); +assertEquals('"\xE3"', JSON.stringify('\xE3')); +assertEquals('"\xE4"', JSON.stringify('\xE4')); +assertEquals('"\xE5"', JSON.stringify('\xE5')); +assertEquals('"\xE6"', JSON.stringify('\xE6')); +assertEquals('"\xE7"', JSON.stringify('\xE7')); +assertEquals('"\xE8"', JSON.stringify('\xE8')); +assertEquals('"\xE9"', JSON.stringify('\xE9')); +assertEquals('"\xEA"', JSON.stringify('\xEA')); +assertEquals('"\xEB"', JSON.stringify('\xEB')); +assertEquals('"\xEC"', JSON.stringify('\xEC')); +assertEquals('"\xED"', JSON.stringify('\xED')); +assertEquals('"\xEE"', JSON.stringify('\xEE')); +assertEquals('"\xEF"', JSON.stringify('\xEF')); +assertEquals('"\xF0"', JSON.stringify('\xF0')); +assertEquals('"\xF1"', JSON.stringify('\xF1')); +assertEquals('"\xF2"', JSON.stringify('\xF2')); +assertEquals('"\xF3"', JSON.stringify('\xF3')); +assertEquals('"\xF4"', JSON.stringify('\xF4')); +assertEquals('"\xF5"', JSON.stringify('\xF5')); +assertEquals('"\xF6"', JSON.stringify('\xF6')); +assertEquals('"\xF7"', JSON.stringify('\xF7')); +assertEquals('"\xF8"', JSON.stringify('\xF8')); +assertEquals('"\xF9"', JSON.stringify('\xF9')); +assertEquals('"\xFA"', JSON.stringify('\xFA')); +assertEquals('"\xFB"', JSON.stringify('\xFB')); +assertEquals('"\xFC"', JSON.stringify('\xFC')); +assertEquals('"\xFD"', JSON.stringify('\xFD')); +assertEquals('"\xFE"', JSON.stringify('\xFE')); +assertEquals('"\xFF"', JSON.stringify('\xFF')); + +// A random selection of code points from U+0100 to U+D7FF. +assertEquals('"\u0100"', JSON.stringify('\u0100')); +assertEquals('"\u0120"', JSON.stringify('\u0120')); +assertEquals('"\u07D3"', JSON.stringify('\u07D3')); +assertEquals('"\u0B8B"', JSON.stringify('\u0B8B')); +assertEquals('"\u0C4C"', JSON.stringify('\u0C4C')); +assertEquals('"\u178D"', JSON.stringify('\u178D')); +assertEquals('"\u18B8"', JSON.stringify('\u18B8')); +assertEquals('"\u193E"', JSON.stringify('\u193E')); +assertEquals('"\u198A"', JSON.stringify('\u198A')); +assertEquals('"\u1AF5"', JSON.stringify('\u1AF5')); +assertEquals('"\u1D38"', JSON.stringify('\u1D38')); +assertEquals('"\u1E37"', JSON.stringify('\u1E37')); +assertEquals('"\u1FC2"', JSON.stringify('\u1FC2')); +assertEquals('"\u22C7"', JSON.stringify('\u22C7')); +assertEquals('"\u2619"', JSON.stringify('\u2619')); +assertEquals('"\u272A"', JSON.stringify('\u272A')); +assertEquals('"\u2B7F"', JSON.stringify('\u2B7F')); +assertEquals('"\u2DFF"', JSON.stringify('\u2DFF')); +assertEquals('"\u341B"', JSON.stringify('\u341B')); +assertEquals('"\u3A3C"', JSON.stringify('\u3A3C')); +assertEquals('"\u3E53"', JSON.stringify('\u3E53')); +assertEquals('"\u3EC2"', JSON.stringify('\u3EC2')); +assertEquals('"\u3F76"', JSON.stringify('\u3F76')); +assertEquals('"\u3F85"', JSON.stringify('\u3F85')); +assertEquals('"\u43C7"', JSON.stringify('\u43C7')); +assertEquals('"\u4A19"', JSON.stringify('\u4A19')); +assertEquals('"\u4A1C"', JSON.stringify('\u4A1C')); +assertEquals('"\u4F80"', JSON.stringify('\u4F80')); +assertEquals('"\u5A30"', JSON.stringify('\u5A30')); +assertEquals('"\u5B55"', JSON.stringify('\u5B55')); +assertEquals('"\u5C74"', JSON.stringify('\u5C74')); +assertEquals('"\u6006"', JSON.stringify('\u6006')); +assertEquals('"\u63CC"', JSON.stringify('\u63CC')); +assertEquals('"\u6608"', JSON.stringify('\u6608')); +assertEquals('"\u6ABF"', JSON.stringify('\u6ABF')); +assertEquals('"\u6AE9"', JSON.stringify('\u6AE9')); +assertEquals('"\u6C91"', JSON.stringify('\u6C91')); +assertEquals('"\u714B"', JSON.stringify('\u714B')); +assertEquals('"\u728A"', JSON.stringify('\u728A')); +assertEquals('"\u7485"', JSON.stringify('\u7485')); +assertEquals('"\u77C8"', JSON.stringify('\u77C8')); +assertEquals('"\u7BE9"', JSON.stringify('\u7BE9')); +assertEquals('"\u7CEF"', JSON.stringify('\u7CEF')); +assertEquals('"\u7DD5"', JSON.stringify('\u7DD5')); +assertEquals('"\u8DF1"', JSON.stringify('\u8DF1')); +assertEquals('"\u94A9"', JSON.stringify('\u94A9')); +assertEquals('"\u94F2"', JSON.stringify('\u94F2')); +assertEquals('"\u9A7A"', JSON.stringify('\u9A7A')); +assertEquals('"\u9AA6"', JSON.stringify('\u9AA6')); +assertEquals('"\uA2B0"', JSON.stringify('\uA2B0')); +assertEquals('"\uB711"', JSON.stringify('\uB711')); +assertEquals('"\uBC01"', JSON.stringify('\uBC01')); +assertEquals('"\uBCB6"', JSON.stringify('\uBCB6')); +assertEquals('"\uBD70"', JSON.stringify('\uBD70')); +assertEquals('"\uC3CD"', JSON.stringify('\uC3CD')); +assertEquals('"\uC451"', JSON.stringify('\uC451')); +assertEquals('"\uC677"', JSON.stringify('\uC677')); +assertEquals('"\uC89B"', JSON.stringify('\uC89B')); +assertEquals('"\uCBEF"', JSON.stringify('\uCBEF')); +assertEquals('"\uCEF8"', JSON.stringify('\uCEF8')); +assertEquals('"\uD089"', JSON.stringify('\uD089')); +assertEquals('"\uD24D"', JSON.stringify('\uD24D')); +assertEquals('"\uD3A7"', JSON.stringify('\uD3A7')); +assertEquals('"\uD7FF"', JSON.stringify('\uD7FF')); + +// All lone surrogates, i.e. code points from U+D800 to U+DFFF. +assertEquals('"\\ud800"', JSON.stringify('\uD800')); +assertEquals('"\\ud801"', JSON.stringify('\uD801')); +assertEquals('"\\ud802"', JSON.stringify('\uD802')); +assertEquals('"\\ud803"', JSON.stringify('\uD803')); +assertEquals('"\\ud804"', JSON.stringify('\uD804')); +assertEquals('"\\ud805"', JSON.stringify('\uD805')); +assertEquals('"\\ud806"', JSON.stringify('\uD806')); +assertEquals('"\\ud807"', JSON.stringify('\uD807')); +assertEquals('"\\ud808"', JSON.stringify('\uD808')); +assertEquals('"\\ud809"', JSON.stringify('\uD809')); +assertEquals('"\\ud80a"', JSON.stringify('\uD80A')); +assertEquals('"\\ud80b"', JSON.stringify('\uD80B')); +assertEquals('"\\ud80c"', JSON.stringify('\uD80C')); +assertEquals('"\\ud80d"', JSON.stringify('\uD80D')); +assertEquals('"\\ud80e"', JSON.stringify('\uD80E')); +assertEquals('"\\ud80f"', JSON.stringify('\uD80F')); +assertEquals('"\\ud810"', JSON.stringify('\uD810')); +assertEquals('"\\ud811"', JSON.stringify('\uD811')); +assertEquals('"\\ud812"', JSON.stringify('\uD812')); +assertEquals('"\\ud813"', JSON.stringify('\uD813')); +assertEquals('"\\ud814"', JSON.stringify('\uD814')); +assertEquals('"\\ud815"', JSON.stringify('\uD815')); +assertEquals('"\\ud816"', JSON.stringify('\uD816')); +assertEquals('"\\ud817"', JSON.stringify('\uD817')); +assertEquals('"\\ud818"', JSON.stringify('\uD818')); +assertEquals('"\\ud819"', JSON.stringify('\uD819')); +assertEquals('"\\ud81a"', JSON.stringify('\uD81A')); +assertEquals('"\\ud81b"', JSON.stringify('\uD81B')); +assertEquals('"\\ud81c"', JSON.stringify('\uD81C')); +assertEquals('"\\ud81d"', JSON.stringify('\uD81D')); +assertEquals('"\\ud81e"', JSON.stringify('\uD81E')); +assertEquals('"\\ud81f"', JSON.stringify('\uD81F')); +assertEquals('"\\ud820"', JSON.stringify('\uD820')); +assertEquals('"\\ud821"', JSON.stringify('\uD821')); +assertEquals('"\\ud822"', JSON.stringify('\uD822')); +assertEquals('"\\ud823"', JSON.stringify('\uD823')); +assertEquals('"\\ud824"', JSON.stringify('\uD824')); +assertEquals('"\\ud825"', JSON.stringify('\uD825')); +assertEquals('"\\ud826"', JSON.stringify('\uD826')); +assertEquals('"\\ud827"', JSON.stringify('\uD827')); +assertEquals('"\\ud828"', JSON.stringify('\uD828')); +assertEquals('"\\ud829"', JSON.stringify('\uD829')); +assertEquals('"\\ud82a"', JSON.stringify('\uD82A')); +assertEquals('"\\ud82b"', JSON.stringify('\uD82B')); +assertEquals('"\\ud82c"', JSON.stringify('\uD82C')); +assertEquals('"\\ud82d"', JSON.stringify('\uD82D')); +assertEquals('"\\ud82e"', JSON.stringify('\uD82E')); +assertEquals('"\\ud82f"', JSON.stringify('\uD82F')); +assertEquals('"\\ud830"', JSON.stringify('\uD830')); +assertEquals('"\\ud831"', JSON.stringify('\uD831')); +assertEquals('"\\ud832"', JSON.stringify('\uD832')); +assertEquals('"\\ud833"', JSON.stringify('\uD833')); +assertEquals('"\\ud834"', JSON.stringify('\uD834')); +assertEquals('"\\ud835"', JSON.stringify('\uD835')); +assertEquals('"\\ud836"', JSON.stringify('\uD836')); +assertEquals('"\\ud837"', JSON.stringify('\uD837')); +assertEquals('"\\ud838"', JSON.stringify('\uD838')); +assertEquals('"\\ud839"', JSON.stringify('\uD839')); +assertEquals('"\\ud83a"', JSON.stringify('\uD83A')); +assertEquals('"\\ud83b"', JSON.stringify('\uD83B')); +assertEquals('"\\ud83c"', JSON.stringify('\uD83C')); +assertEquals('"\\ud83d"', JSON.stringify('\uD83D')); +assertEquals('"\\ud83e"', JSON.stringify('\uD83E')); +assertEquals('"\\ud83f"', JSON.stringify('\uD83F')); +assertEquals('"\\ud840"', JSON.stringify('\uD840')); +assertEquals('"\\ud841"', JSON.stringify('\uD841')); +assertEquals('"\\ud842"', JSON.stringify('\uD842')); +assertEquals('"\\ud843"', JSON.stringify('\uD843')); +assertEquals('"\\ud844"', JSON.stringify('\uD844')); +assertEquals('"\\ud845"', JSON.stringify('\uD845')); +assertEquals('"\\ud846"', JSON.stringify('\uD846')); +assertEquals('"\\ud847"', JSON.stringify('\uD847')); +assertEquals('"\\ud848"', JSON.stringify('\uD848')); +assertEquals('"\\ud849"', JSON.stringify('\uD849')); +assertEquals('"\\ud84a"', JSON.stringify('\uD84A')); +assertEquals('"\\ud84b"', JSON.stringify('\uD84B')); +assertEquals('"\\ud84c"', JSON.stringify('\uD84C')); +assertEquals('"\\ud84d"', JSON.stringify('\uD84D')); +assertEquals('"\\ud84e"', JSON.stringify('\uD84E')); +assertEquals('"\\ud84f"', JSON.stringify('\uD84F')); +assertEquals('"\\ud850"', JSON.stringify('\uD850')); +assertEquals('"\\ud851"', JSON.stringify('\uD851')); +assertEquals('"\\ud852"', JSON.stringify('\uD852')); +assertEquals('"\\ud853"', JSON.stringify('\uD853')); +assertEquals('"\\ud854"', JSON.stringify('\uD854')); +assertEquals('"\\ud855"', JSON.stringify('\uD855')); +assertEquals('"\\ud856"', JSON.stringify('\uD856')); +assertEquals('"\\ud857"', JSON.stringify('\uD857')); +assertEquals('"\\ud858"', JSON.stringify('\uD858')); +assertEquals('"\\ud859"', JSON.stringify('\uD859')); +assertEquals('"\\ud85a"', JSON.stringify('\uD85A')); +assertEquals('"\\ud85b"', JSON.stringify('\uD85B')); +assertEquals('"\\ud85c"', JSON.stringify('\uD85C')); +assertEquals('"\\ud85d"', JSON.stringify('\uD85D')); +assertEquals('"\\ud85e"', JSON.stringify('\uD85E')); +assertEquals('"\\ud85f"', JSON.stringify('\uD85F')); +assertEquals('"\\ud860"', JSON.stringify('\uD860')); +assertEquals('"\\ud861"', JSON.stringify('\uD861')); +assertEquals('"\\ud862"', JSON.stringify('\uD862')); +assertEquals('"\\ud863"', JSON.stringify('\uD863')); +assertEquals('"\\ud864"', JSON.stringify('\uD864')); +assertEquals('"\\ud865"', JSON.stringify('\uD865')); +assertEquals('"\\ud866"', JSON.stringify('\uD866')); +assertEquals('"\\ud867"', JSON.stringify('\uD867')); +assertEquals('"\\ud868"', JSON.stringify('\uD868')); +assertEquals('"\\ud869"', JSON.stringify('\uD869')); +assertEquals('"\\ud86a"', JSON.stringify('\uD86A')); +assertEquals('"\\ud86b"', JSON.stringify('\uD86B')); +assertEquals('"\\ud86c"', JSON.stringify('\uD86C')); +assertEquals('"\\ud86d"', JSON.stringify('\uD86D')); +assertEquals('"\\ud86e"', JSON.stringify('\uD86E')); +assertEquals('"\\ud86f"', JSON.stringify('\uD86F')); +assertEquals('"\\ud870"', JSON.stringify('\uD870')); +assertEquals('"\\ud871"', JSON.stringify('\uD871')); +assertEquals('"\\ud872"', JSON.stringify('\uD872')); +assertEquals('"\\ud873"', JSON.stringify('\uD873')); +assertEquals('"\\ud874"', JSON.stringify('\uD874')); +assertEquals('"\\ud875"', JSON.stringify('\uD875')); +assertEquals('"\\ud876"', JSON.stringify('\uD876')); +assertEquals('"\\ud877"', JSON.stringify('\uD877')); +assertEquals('"\\ud878"', JSON.stringify('\uD878')); +assertEquals('"\\ud879"', JSON.stringify('\uD879')); +assertEquals('"\\ud87a"', JSON.stringify('\uD87A')); +assertEquals('"\\ud87b"', JSON.stringify('\uD87B')); +assertEquals('"\\ud87c"', JSON.stringify('\uD87C')); +assertEquals('"\\ud87d"', JSON.stringify('\uD87D')); +assertEquals('"\\ud87e"', JSON.stringify('\uD87E')); +assertEquals('"\\ud87f"', JSON.stringify('\uD87F')); +assertEquals('"\\ud880"', JSON.stringify('\uD880')); +assertEquals('"\\ud881"', JSON.stringify('\uD881')); +assertEquals('"\\ud882"', JSON.stringify('\uD882')); +assertEquals('"\\ud883"', JSON.stringify('\uD883')); +assertEquals('"\\ud884"', JSON.stringify('\uD884')); +assertEquals('"\\ud885"', JSON.stringify('\uD885')); +assertEquals('"\\ud886"', JSON.stringify('\uD886')); +assertEquals('"\\ud887"', JSON.stringify('\uD887')); +assertEquals('"\\ud888"', JSON.stringify('\uD888')); +assertEquals('"\\ud889"', JSON.stringify('\uD889')); +assertEquals('"\\ud88a"', JSON.stringify('\uD88A')); +assertEquals('"\\ud88b"', JSON.stringify('\uD88B')); +assertEquals('"\\ud88c"', JSON.stringify('\uD88C')); +assertEquals('"\\ud88d"', JSON.stringify('\uD88D')); +assertEquals('"\\ud88e"', JSON.stringify('\uD88E')); +assertEquals('"\\ud88f"', JSON.stringify('\uD88F')); +assertEquals('"\\ud890"', JSON.stringify('\uD890')); +assertEquals('"\\ud891"', JSON.stringify('\uD891')); +assertEquals('"\\ud892"', JSON.stringify('\uD892')); +assertEquals('"\\ud893"', JSON.stringify('\uD893')); +assertEquals('"\\ud894"', JSON.stringify('\uD894')); +assertEquals('"\\ud895"', JSON.stringify('\uD895')); +assertEquals('"\\ud896"', JSON.stringify('\uD896')); +assertEquals('"\\ud897"', JSON.stringify('\uD897')); +assertEquals('"\\ud898"', JSON.stringify('\uD898')); +assertEquals('"\\ud899"', JSON.stringify('\uD899')); +assertEquals('"\\ud89a"', JSON.stringify('\uD89A')); +assertEquals('"\\ud89b"', JSON.stringify('\uD89B')); +assertEquals('"\\ud89c"', JSON.stringify('\uD89C')); +assertEquals('"\\ud89d"', JSON.stringify('\uD89D')); +assertEquals('"\\ud89e"', JSON.stringify('\uD89E')); +assertEquals('"\\ud89f"', JSON.stringify('\uD89F')); +assertEquals('"\\ud8a0"', JSON.stringify('\uD8A0')); +assertEquals('"\\ud8a1"', JSON.stringify('\uD8A1')); +assertEquals('"\\ud8a2"', JSON.stringify('\uD8A2')); +assertEquals('"\\ud8a3"', JSON.stringify('\uD8A3')); +assertEquals('"\\ud8a4"', JSON.stringify('\uD8A4')); +assertEquals('"\\ud8a5"', JSON.stringify('\uD8A5')); +assertEquals('"\\ud8a6"', JSON.stringify('\uD8A6')); +assertEquals('"\\ud8a7"', JSON.stringify('\uD8A7')); +assertEquals('"\\ud8a8"', JSON.stringify('\uD8A8')); +assertEquals('"\\ud8a9"', JSON.stringify('\uD8A9')); +assertEquals('"\\ud8aa"', JSON.stringify('\uD8AA')); +assertEquals('"\\ud8ab"', JSON.stringify('\uD8AB')); +assertEquals('"\\ud8ac"', JSON.stringify('\uD8AC')); +assertEquals('"\\ud8ad"', JSON.stringify('\uD8AD')); +assertEquals('"\\ud8ae"', JSON.stringify('\uD8AE')); +assertEquals('"\\ud8af"', JSON.stringify('\uD8AF')); +assertEquals('"\\ud8b0"', JSON.stringify('\uD8B0')); +assertEquals('"\\ud8b1"', JSON.stringify('\uD8B1')); +assertEquals('"\\ud8b2"', JSON.stringify('\uD8B2')); +assertEquals('"\\ud8b3"', JSON.stringify('\uD8B3')); +assertEquals('"\\ud8b4"', JSON.stringify('\uD8B4')); +assertEquals('"\\ud8b5"', JSON.stringify('\uD8B5')); +assertEquals('"\\ud8b6"', JSON.stringify('\uD8B6')); +assertEquals('"\\ud8b7"', JSON.stringify('\uD8B7')); +assertEquals('"\\ud8b8"', JSON.stringify('\uD8B8')); +assertEquals('"\\ud8b9"', JSON.stringify('\uD8B9')); +assertEquals('"\\ud8ba"', JSON.stringify('\uD8BA')); +assertEquals('"\\ud8bb"', JSON.stringify('\uD8BB')); +assertEquals('"\\ud8bc"', JSON.stringify('\uD8BC')); +assertEquals('"\\ud8bd"', JSON.stringify('\uD8BD')); +assertEquals('"\\ud8be"', JSON.stringify('\uD8BE')); +assertEquals('"\\ud8bf"', JSON.stringify('\uD8BF')); +assertEquals('"\\ud8c0"', JSON.stringify('\uD8C0')); +assertEquals('"\\ud8c1"', JSON.stringify('\uD8C1')); +assertEquals('"\\ud8c2"', JSON.stringify('\uD8C2')); +assertEquals('"\\ud8c3"', JSON.stringify('\uD8C3')); +assertEquals('"\\ud8c4"', JSON.stringify('\uD8C4')); +assertEquals('"\\ud8c5"', JSON.stringify('\uD8C5')); +assertEquals('"\\ud8c6"', JSON.stringify('\uD8C6')); +assertEquals('"\\ud8c7"', JSON.stringify('\uD8C7')); +assertEquals('"\\ud8c8"', JSON.stringify('\uD8C8')); +assertEquals('"\\ud8c9"', JSON.stringify('\uD8C9')); +assertEquals('"\\ud8ca"', JSON.stringify('\uD8CA')); +assertEquals('"\\ud8cb"', JSON.stringify('\uD8CB')); +assertEquals('"\\ud8cc"', JSON.stringify('\uD8CC')); +assertEquals('"\\ud8cd"', JSON.stringify('\uD8CD')); +assertEquals('"\\ud8ce"', JSON.stringify('\uD8CE')); +assertEquals('"\\ud8cf"', JSON.stringify('\uD8CF')); +assertEquals('"\\ud8d0"', JSON.stringify('\uD8D0')); +assertEquals('"\\ud8d1"', JSON.stringify('\uD8D1')); +assertEquals('"\\ud8d2"', JSON.stringify('\uD8D2')); +assertEquals('"\\ud8d3"', JSON.stringify('\uD8D3')); +assertEquals('"\\ud8d4"', JSON.stringify('\uD8D4')); +assertEquals('"\\ud8d5"', JSON.stringify('\uD8D5')); +assertEquals('"\\ud8d6"', JSON.stringify('\uD8D6')); +assertEquals('"\\ud8d7"', JSON.stringify('\uD8D7')); +assertEquals('"\\ud8d8"', JSON.stringify('\uD8D8')); +assertEquals('"\\ud8d9"', JSON.stringify('\uD8D9')); +assertEquals('"\\ud8da"', JSON.stringify('\uD8DA')); +assertEquals('"\\ud8db"', JSON.stringify('\uD8DB')); +assertEquals('"\\ud8dc"', JSON.stringify('\uD8DC')); +assertEquals('"\\ud8dd"', JSON.stringify('\uD8DD')); +assertEquals('"\\ud8de"', JSON.stringify('\uD8DE')); +assertEquals('"\\ud8df"', JSON.stringify('\uD8DF')); +assertEquals('"\\ud8e0"', JSON.stringify('\uD8E0')); +assertEquals('"\\ud8e1"', JSON.stringify('\uD8E1')); +assertEquals('"\\ud8e2"', JSON.stringify('\uD8E2')); +assertEquals('"\\ud8e3"', JSON.stringify('\uD8E3')); +assertEquals('"\\ud8e4"', JSON.stringify('\uD8E4')); +assertEquals('"\\ud8e5"', JSON.stringify('\uD8E5')); +assertEquals('"\\ud8e6"', JSON.stringify('\uD8E6')); +assertEquals('"\\ud8e7"', JSON.stringify('\uD8E7')); +assertEquals('"\\ud8e8"', JSON.stringify('\uD8E8')); +assertEquals('"\\ud8e9"', JSON.stringify('\uD8E9')); +assertEquals('"\\ud8ea"', JSON.stringify('\uD8EA')); +assertEquals('"\\ud8eb"', JSON.stringify('\uD8EB')); +assertEquals('"\\ud8ec"', JSON.stringify('\uD8EC')); +assertEquals('"\\ud8ed"', JSON.stringify('\uD8ED')); +assertEquals('"\\ud8ee"', JSON.stringify('\uD8EE')); +assertEquals('"\\ud8ef"', JSON.stringify('\uD8EF')); +assertEquals('"\\ud8f0"', JSON.stringify('\uD8F0')); +assertEquals('"\\ud8f1"', JSON.stringify('\uD8F1')); +assertEquals('"\\ud8f2"', JSON.stringify('\uD8F2')); +assertEquals('"\\ud8f3"', JSON.stringify('\uD8F3')); +assertEquals('"\\ud8f4"', JSON.stringify('\uD8F4')); +assertEquals('"\\ud8f5"', JSON.stringify('\uD8F5')); +assertEquals('"\\ud8f6"', JSON.stringify('\uD8F6')); +assertEquals('"\\ud8f7"', JSON.stringify('\uD8F7')); +assertEquals('"\\ud8f8"', JSON.stringify('\uD8F8')); +assertEquals('"\\ud8f9"', JSON.stringify('\uD8F9')); +assertEquals('"\\ud8fa"', JSON.stringify('\uD8FA')); +assertEquals('"\\ud8fb"', JSON.stringify('\uD8FB')); +assertEquals('"\\ud8fc"', JSON.stringify('\uD8FC')); +assertEquals('"\\ud8fd"', JSON.stringify('\uD8FD')); +assertEquals('"\\ud8fe"', JSON.stringify('\uD8FE')); +assertEquals('"\\ud8ff"', JSON.stringify('\uD8FF')); +assertEquals('"\\ud900"', JSON.stringify('\uD900')); +assertEquals('"\\ud901"', JSON.stringify('\uD901')); +assertEquals('"\\ud902"', JSON.stringify('\uD902')); +assertEquals('"\\ud903"', JSON.stringify('\uD903')); +assertEquals('"\\ud904"', JSON.stringify('\uD904')); +assertEquals('"\\ud905"', JSON.stringify('\uD905')); +assertEquals('"\\ud906"', JSON.stringify('\uD906')); +assertEquals('"\\ud907"', JSON.stringify('\uD907')); +assertEquals('"\\ud908"', JSON.stringify('\uD908')); +assertEquals('"\\ud909"', JSON.stringify('\uD909')); +assertEquals('"\\ud90a"', JSON.stringify('\uD90A')); +assertEquals('"\\ud90b"', JSON.stringify('\uD90B')); +assertEquals('"\\ud90c"', JSON.stringify('\uD90C')); +assertEquals('"\\ud90d"', JSON.stringify('\uD90D')); +assertEquals('"\\ud90e"', JSON.stringify('\uD90E')); +assertEquals('"\\ud90f"', JSON.stringify('\uD90F')); +assertEquals('"\\ud910"', JSON.stringify('\uD910')); +assertEquals('"\\ud911"', JSON.stringify('\uD911')); +assertEquals('"\\ud912"', JSON.stringify('\uD912')); +assertEquals('"\\ud913"', JSON.stringify('\uD913')); +assertEquals('"\\ud914"', JSON.stringify('\uD914')); +assertEquals('"\\ud915"', JSON.stringify('\uD915')); +assertEquals('"\\ud916"', JSON.stringify('\uD916')); +assertEquals('"\\ud917"', JSON.stringify('\uD917')); +assertEquals('"\\ud918"', JSON.stringify('\uD918')); +assertEquals('"\\ud919"', JSON.stringify('\uD919')); +assertEquals('"\\ud91a"', JSON.stringify('\uD91A')); +assertEquals('"\\ud91b"', JSON.stringify('\uD91B')); +assertEquals('"\\ud91c"', JSON.stringify('\uD91C')); +assertEquals('"\\ud91d"', JSON.stringify('\uD91D')); +assertEquals('"\\ud91e"', JSON.stringify('\uD91E')); +assertEquals('"\\ud91f"', JSON.stringify('\uD91F')); +assertEquals('"\\ud920"', JSON.stringify('\uD920')); +assertEquals('"\\ud921"', JSON.stringify('\uD921')); +assertEquals('"\\ud922"', JSON.stringify('\uD922')); +assertEquals('"\\ud923"', JSON.stringify('\uD923')); +assertEquals('"\\ud924"', JSON.stringify('\uD924')); +assertEquals('"\\ud925"', JSON.stringify('\uD925')); +assertEquals('"\\ud926"', JSON.stringify('\uD926')); +assertEquals('"\\ud927"', JSON.stringify('\uD927')); +assertEquals('"\\ud928"', JSON.stringify('\uD928')); +assertEquals('"\\ud929"', JSON.stringify('\uD929')); +assertEquals('"\\ud92a"', JSON.stringify('\uD92A')); +assertEquals('"\\ud92b"', JSON.stringify('\uD92B')); +assertEquals('"\\ud92c"', JSON.stringify('\uD92C')); +assertEquals('"\\ud92d"', JSON.stringify('\uD92D')); +assertEquals('"\\ud92e"', JSON.stringify('\uD92E')); +assertEquals('"\\ud92f"', JSON.stringify('\uD92F')); +assertEquals('"\\ud930"', JSON.stringify('\uD930')); +assertEquals('"\\ud931"', JSON.stringify('\uD931')); +assertEquals('"\\ud932"', JSON.stringify('\uD932')); +assertEquals('"\\ud933"', JSON.stringify('\uD933')); +assertEquals('"\\ud934"', JSON.stringify('\uD934')); +assertEquals('"\\ud935"', JSON.stringify('\uD935')); +assertEquals('"\\ud936"', JSON.stringify('\uD936')); +assertEquals('"\\ud937"', JSON.stringify('\uD937')); +assertEquals('"\\ud938"', JSON.stringify('\uD938')); +assertEquals('"\\ud939"', JSON.stringify('\uD939')); +assertEquals('"\\ud93a"', JSON.stringify('\uD93A')); +assertEquals('"\\ud93b"', JSON.stringify('\uD93B')); +assertEquals('"\\ud93c"', JSON.stringify('\uD93C')); +assertEquals('"\\ud93d"', JSON.stringify('\uD93D')); +assertEquals('"\\ud93e"', JSON.stringify('\uD93E')); +assertEquals('"\\ud93f"', JSON.stringify('\uD93F')); +assertEquals('"\\ud940"', JSON.stringify('\uD940')); +assertEquals('"\\ud941"', JSON.stringify('\uD941')); +assertEquals('"\\ud942"', JSON.stringify('\uD942')); +assertEquals('"\\ud943"', JSON.stringify('\uD943')); +assertEquals('"\\ud944"', JSON.stringify('\uD944')); +assertEquals('"\\ud945"', JSON.stringify('\uD945')); +assertEquals('"\\ud946"', JSON.stringify('\uD946')); +assertEquals('"\\ud947"', JSON.stringify('\uD947')); +assertEquals('"\\ud948"', JSON.stringify('\uD948')); +assertEquals('"\\ud949"', JSON.stringify('\uD949')); +assertEquals('"\\ud94a"', JSON.stringify('\uD94A')); +assertEquals('"\\ud94b"', JSON.stringify('\uD94B')); +assertEquals('"\\ud94c"', JSON.stringify('\uD94C')); +assertEquals('"\\ud94d"', JSON.stringify('\uD94D')); +assertEquals('"\\ud94e"', JSON.stringify('\uD94E')); +assertEquals('"\\ud94f"', JSON.stringify('\uD94F')); +assertEquals('"\\ud950"', JSON.stringify('\uD950')); +assertEquals('"\\ud951"', JSON.stringify('\uD951')); +assertEquals('"\\ud952"', JSON.stringify('\uD952')); +assertEquals('"\\ud953"', JSON.stringify('\uD953')); +assertEquals('"\\ud954"', JSON.stringify('\uD954')); +assertEquals('"\\ud955"', JSON.stringify('\uD955')); +assertEquals('"\\ud956"', JSON.stringify('\uD956')); +assertEquals('"\\ud957"', JSON.stringify('\uD957')); +assertEquals('"\\ud958"', JSON.stringify('\uD958')); +assertEquals('"\\ud959"', JSON.stringify('\uD959')); +assertEquals('"\\ud95a"', JSON.stringify('\uD95A')); +assertEquals('"\\ud95b"', JSON.stringify('\uD95B')); +assertEquals('"\\ud95c"', JSON.stringify('\uD95C')); +assertEquals('"\\ud95d"', JSON.stringify('\uD95D')); +assertEquals('"\\ud95e"', JSON.stringify('\uD95E')); +assertEquals('"\\ud95f"', JSON.stringify('\uD95F')); +assertEquals('"\\ud960"', JSON.stringify('\uD960')); +assertEquals('"\\ud961"', JSON.stringify('\uD961')); +assertEquals('"\\ud962"', JSON.stringify('\uD962')); +assertEquals('"\\ud963"', JSON.stringify('\uD963')); +assertEquals('"\\ud964"', JSON.stringify('\uD964')); +assertEquals('"\\ud965"', JSON.stringify('\uD965')); +assertEquals('"\\ud966"', JSON.stringify('\uD966')); +assertEquals('"\\ud967"', JSON.stringify('\uD967')); +assertEquals('"\\ud968"', JSON.stringify('\uD968')); +assertEquals('"\\ud969"', JSON.stringify('\uD969')); +assertEquals('"\\ud96a"', JSON.stringify('\uD96A')); +assertEquals('"\\ud96b"', JSON.stringify('\uD96B')); +assertEquals('"\\ud96c"', JSON.stringify('\uD96C')); +assertEquals('"\\ud96d"', JSON.stringify('\uD96D')); +assertEquals('"\\ud96e"', JSON.stringify('\uD96E')); +assertEquals('"\\ud96f"', JSON.stringify('\uD96F')); +assertEquals('"\\ud970"', JSON.stringify('\uD970')); +assertEquals('"\\ud971"', JSON.stringify('\uD971')); +assertEquals('"\\ud972"', JSON.stringify('\uD972')); +assertEquals('"\\ud973"', JSON.stringify('\uD973')); +assertEquals('"\\ud974"', JSON.stringify('\uD974')); +assertEquals('"\\ud975"', JSON.stringify('\uD975')); +assertEquals('"\\ud976"', JSON.stringify('\uD976')); +assertEquals('"\\ud977"', JSON.stringify('\uD977')); +assertEquals('"\\ud978"', JSON.stringify('\uD978')); +assertEquals('"\\ud979"', JSON.stringify('\uD979')); +assertEquals('"\\ud97a"', JSON.stringify('\uD97A')); +assertEquals('"\\ud97b"', JSON.stringify('\uD97B')); +assertEquals('"\\ud97c"', JSON.stringify('\uD97C')); +assertEquals('"\\ud97d"', JSON.stringify('\uD97D')); +assertEquals('"\\ud97e"', JSON.stringify('\uD97E')); +assertEquals('"\\ud97f"', JSON.stringify('\uD97F')); +assertEquals('"\\ud980"', JSON.stringify('\uD980')); +assertEquals('"\\ud981"', JSON.stringify('\uD981')); +assertEquals('"\\ud982"', JSON.stringify('\uD982')); +assertEquals('"\\ud983"', JSON.stringify('\uD983')); +assertEquals('"\\ud984"', JSON.stringify('\uD984')); +assertEquals('"\\ud985"', JSON.stringify('\uD985')); +assertEquals('"\\ud986"', JSON.stringify('\uD986')); +assertEquals('"\\ud987"', JSON.stringify('\uD987')); +assertEquals('"\\ud988"', JSON.stringify('\uD988')); +assertEquals('"\\ud989"', JSON.stringify('\uD989')); +assertEquals('"\\ud98a"', JSON.stringify('\uD98A')); +assertEquals('"\\ud98b"', JSON.stringify('\uD98B')); +assertEquals('"\\ud98c"', JSON.stringify('\uD98C')); +assertEquals('"\\ud98d"', JSON.stringify('\uD98D')); +assertEquals('"\\ud98e"', JSON.stringify('\uD98E')); +assertEquals('"\\ud98f"', JSON.stringify('\uD98F')); +assertEquals('"\\ud990"', JSON.stringify('\uD990')); +assertEquals('"\\ud991"', JSON.stringify('\uD991')); +assertEquals('"\\ud992"', JSON.stringify('\uD992')); +assertEquals('"\\ud993"', JSON.stringify('\uD993')); +assertEquals('"\\ud994"', JSON.stringify('\uD994')); +assertEquals('"\\ud995"', JSON.stringify('\uD995')); +assertEquals('"\\ud996"', JSON.stringify('\uD996')); +assertEquals('"\\ud997"', JSON.stringify('\uD997')); +assertEquals('"\\ud998"', JSON.stringify('\uD998')); +assertEquals('"\\ud999"', JSON.stringify('\uD999')); +assertEquals('"\\ud99a"', JSON.stringify('\uD99A')); +assertEquals('"\\ud99b"', JSON.stringify('\uD99B')); +assertEquals('"\\ud99c"', JSON.stringify('\uD99C')); +assertEquals('"\\ud99d"', JSON.stringify('\uD99D')); +assertEquals('"\\ud99e"', JSON.stringify('\uD99E')); +assertEquals('"\\ud99f"', JSON.stringify('\uD99F')); +assertEquals('"\\ud9a0"', JSON.stringify('\uD9A0')); +assertEquals('"\\ud9a1"', JSON.stringify('\uD9A1')); +assertEquals('"\\ud9a2"', JSON.stringify('\uD9A2')); +assertEquals('"\\ud9a3"', JSON.stringify('\uD9A3')); +assertEquals('"\\ud9a4"', JSON.stringify('\uD9A4')); +assertEquals('"\\ud9a5"', JSON.stringify('\uD9A5')); +assertEquals('"\\ud9a6"', JSON.stringify('\uD9A6')); +assertEquals('"\\ud9a7"', JSON.stringify('\uD9A7')); +assertEquals('"\\ud9a8"', JSON.stringify('\uD9A8')); +assertEquals('"\\ud9a9"', JSON.stringify('\uD9A9')); +assertEquals('"\\ud9aa"', JSON.stringify('\uD9AA')); +assertEquals('"\\ud9ab"', JSON.stringify('\uD9AB')); +assertEquals('"\\ud9ac"', JSON.stringify('\uD9AC')); +assertEquals('"\\ud9ad"', JSON.stringify('\uD9AD')); +assertEquals('"\\ud9ae"', JSON.stringify('\uD9AE')); +assertEquals('"\\ud9af"', JSON.stringify('\uD9AF')); +assertEquals('"\\ud9b0"', JSON.stringify('\uD9B0')); +assertEquals('"\\ud9b1"', JSON.stringify('\uD9B1')); +assertEquals('"\\ud9b2"', JSON.stringify('\uD9B2')); +assertEquals('"\\ud9b3"', JSON.stringify('\uD9B3')); +assertEquals('"\\ud9b4"', JSON.stringify('\uD9B4')); +assertEquals('"\\ud9b5"', JSON.stringify('\uD9B5')); +assertEquals('"\\ud9b6"', JSON.stringify('\uD9B6')); +assertEquals('"\\ud9b7"', JSON.stringify('\uD9B7')); +assertEquals('"\\ud9b8"', JSON.stringify('\uD9B8')); +assertEquals('"\\ud9b9"', JSON.stringify('\uD9B9')); +assertEquals('"\\ud9ba"', JSON.stringify('\uD9BA')); +assertEquals('"\\ud9bb"', JSON.stringify('\uD9BB')); +assertEquals('"\\ud9bc"', JSON.stringify('\uD9BC')); +assertEquals('"\\ud9bd"', JSON.stringify('\uD9BD')); +assertEquals('"\\ud9be"', JSON.stringify('\uD9BE')); +assertEquals('"\\ud9bf"', JSON.stringify('\uD9BF')); +assertEquals('"\\ud9c0"', JSON.stringify('\uD9C0')); +assertEquals('"\\ud9c1"', JSON.stringify('\uD9C1')); +assertEquals('"\\ud9c2"', JSON.stringify('\uD9C2')); +assertEquals('"\\ud9c3"', JSON.stringify('\uD9C3')); +assertEquals('"\\ud9c4"', JSON.stringify('\uD9C4')); +assertEquals('"\\ud9c5"', JSON.stringify('\uD9C5')); +assertEquals('"\\ud9c6"', JSON.stringify('\uD9C6')); +assertEquals('"\\ud9c7"', JSON.stringify('\uD9C7')); +assertEquals('"\\ud9c8"', JSON.stringify('\uD9C8')); +assertEquals('"\\ud9c9"', JSON.stringify('\uD9C9')); +assertEquals('"\\ud9ca"', JSON.stringify('\uD9CA')); +assertEquals('"\\ud9cb"', JSON.stringify('\uD9CB')); +assertEquals('"\\ud9cc"', JSON.stringify('\uD9CC')); +assertEquals('"\\ud9cd"', JSON.stringify('\uD9CD')); +assertEquals('"\\ud9ce"', JSON.stringify('\uD9CE')); +assertEquals('"\\ud9cf"', JSON.stringify('\uD9CF')); +assertEquals('"\\ud9d0"', JSON.stringify('\uD9D0')); +assertEquals('"\\ud9d1"', JSON.stringify('\uD9D1')); +assertEquals('"\\ud9d2"', JSON.stringify('\uD9D2')); +assertEquals('"\\ud9d3"', JSON.stringify('\uD9D3')); +assertEquals('"\\ud9d4"', JSON.stringify('\uD9D4')); +assertEquals('"\\ud9d5"', JSON.stringify('\uD9D5')); +assertEquals('"\\ud9d6"', JSON.stringify('\uD9D6')); +assertEquals('"\\ud9d7"', JSON.stringify('\uD9D7')); +assertEquals('"\\ud9d8"', JSON.stringify('\uD9D8')); +assertEquals('"\\ud9d9"', JSON.stringify('\uD9D9')); +assertEquals('"\\ud9da"', JSON.stringify('\uD9DA')); +assertEquals('"\\ud9db"', JSON.stringify('\uD9DB')); +assertEquals('"\\ud9dc"', JSON.stringify('\uD9DC')); +assertEquals('"\\ud9dd"', JSON.stringify('\uD9DD')); +assertEquals('"\\ud9de"', JSON.stringify('\uD9DE')); +assertEquals('"\\ud9df"', JSON.stringify('\uD9DF')); +assertEquals('"\\ud9e0"', JSON.stringify('\uD9E0')); +assertEquals('"\\ud9e1"', JSON.stringify('\uD9E1')); +assertEquals('"\\ud9e2"', JSON.stringify('\uD9E2')); +assertEquals('"\\ud9e3"', JSON.stringify('\uD9E3')); +assertEquals('"\\ud9e4"', JSON.stringify('\uD9E4')); +assertEquals('"\\ud9e5"', JSON.stringify('\uD9E5')); +assertEquals('"\\ud9e6"', JSON.stringify('\uD9E6')); +assertEquals('"\\ud9e7"', JSON.stringify('\uD9E7')); +assertEquals('"\\ud9e8"', JSON.stringify('\uD9E8')); +assertEquals('"\\ud9e9"', JSON.stringify('\uD9E9')); +assertEquals('"\\ud9ea"', JSON.stringify('\uD9EA')); +assertEquals('"\\ud9eb"', JSON.stringify('\uD9EB')); +assertEquals('"\\ud9ec"', JSON.stringify('\uD9EC')); +assertEquals('"\\ud9ed"', JSON.stringify('\uD9ED')); +assertEquals('"\\ud9ee"', JSON.stringify('\uD9EE')); +assertEquals('"\\ud9ef"', JSON.stringify('\uD9EF')); +assertEquals('"\\ud9f0"', JSON.stringify('\uD9F0')); +assertEquals('"\\ud9f1"', JSON.stringify('\uD9F1')); +assertEquals('"\\ud9f2"', JSON.stringify('\uD9F2')); +assertEquals('"\\ud9f3"', JSON.stringify('\uD9F3')); +assertEquals('"\\ud9f4"', JSON.stringify('\uD9F4')); +assertEquals('"\\ud9f5"', JSON.stringify('\uD9F5')); +assertEquals('"\\ud9f6"', JSON.stringify('\uD9F6')); +assertEquals('"\\ud9f7"', JSON.stringify('\uD9F7')); +assertEquals('"\\ud9f8"', JSON.stringify('\uD9F8')); +assertEquals('"\\ud9f9"', JSON.stringify('\uD9F9')); +assertEquals('"\\ud9fa"', JSON.stringify('\uD9FA')); +assertEquals('"\\ud9fb"', JSON.stringify('\uD9FB')); +assertEquals('"\\ud9fc"', JSON.stringify('\uD9FC')); +assertEquals('"\\ud9fd"', JSON.stringify('\uD9FD')); +assertEquals('"\\ud9fe"', JSON.stringify('\uD9FE')); +assertEquals('"\\ud9ff"', JSON.stringify('\uD9FF')); +assertEquals('"\\uda00"', JSON.stringify('\uDA00')); +assertEquals('"\\uda01"', JSON.stringify('\uDA01')); +assertEquals('"\\uda02"', JSON.stringify('\uDA02')); +assertEquals('"\\uda03"', JSON.stringify('\uDA03')); +assertEquals('"\\uda04"', JSON.stringify('\uDA04')); +assertEquals('"\\uda05"', JSON.stringify('\uDA05')); +assertEquals('"\\uda06"', JSON.stringify('\uDA06')); +assertEquals('"\\uda07"', JSON.stringify('\uDA07')); +assertEquals('"\\uda08"', JSON.stringify('\uDA08')); +assertEquals('"\\uda09"', JSON.stringify('\uDA09')); +assertEquals('"\\uda0a"', JSON.stringify('\uDA0A')); +assertEquals('"\\uda0b"', JSON.stringify('\uDA0B')); +assertEquals('"\\uda0c"', JSON.stringify('\uDA0C')); +assertEquals('"\\uda0d"', JSON.stringify('\uDA0D')); +assertEquals('"\\uda0e"', JSON.stringify('\uDA0E')); +assertEquals('"\\uda0f"', JSON.stringify('\uDA0F')); +assertEquals('"\\uda10"', JSON.stringify('\uDA10')); +assertEquals('"\\uda11"', JSON.stringify('\uDA11')); +assertEquals('"\\uda12"', JSON.stringify('\uDA12')); +assertEquals('"\\uda13"', JSON.stringify('\uDA13')); +assertEquals('"\\uda14"', JSON.stringify('\uDA14')); +assertEquals('"\\uda15"', JSON.stringify('\uDA15')); +assertEquals('"\\uda16"', JSON.stringify('\uDA16')); +assertEquals('"\\uda17"', JSON.stringify('\uDA17')); +assertEquals('"\\uda18"', JSON.stringify('\uDA18')); +assertEquals('"\\uda19"', JSON.stringify('\uDA19')); +assertEquals('"\\uda1a"', JSON.stringify('\uDA1A')); +assertEquals('"\\uda1b"', JSON.stringify('\uDA1B')); +assertEquals('"\\uda1c"', JSON.stringify('\uDA1C')); +assertEquals('"\\uda1d"', JSON.stringify('\uDA1D')); +assertEquals('"\\uda1e"', JSON.stringify('\uDA1E')); +assertEquals('"\\uda1f"', JSON.stringify('\uDA1F')); +assertEquals('"\\uda20"', JSON.stringify('\uDA20')); +assertEquals('"\\uda21"', JSON.stringify('\uDA21')); +assertEquals('"\\uda22"', JSON.stringify('\uDA22')); +assertEquals('"\\uda23"', JSON.stringify('\uDA23')); +assertEquals('"\\uda24"', JSON.stringify('\uDA24')); +assertEquals('"\\uda25"', JSON.stringify('\uDA25')); +assertEquals('"\\uda26"', JSON.stringify('\uDA26')); +assertEquals('"\\uda27"', JSON.stringify('\uDA27')); +assertEquals('"\\uda28"', JSON.stringify('\uDA28')); +assertEquals('"\\uda29"', JSON.stringify('\uDA29')); +assertEquals('"\\uda2a"', JSON.stringify('\uDA2A')); +assertEquals('"\\uda2b"', JSON.stringify('\uDA2B')); +assertEquals('"\\uda2c"', JSON.stringify('\uDA2C')); +assertEquals('"\\uda2d"', JSON.stringify('\uDA2D')); +assertEquals('"\\uda2e"', JSON.stringify('\uDA2E')); +assertEquals('"\\uda2f"', JSON.stringify('\uDA2F')); +assertEquals('"\\uda30"', JSON.stringify('\uDA30')); +assertEquals('"\\uda31"', JSON.stringify('\uDA31')); +assertEquals('"\\uda32"', JSON.stringify('\uDA32')); +assertEquals('"\\uda33"', JSON.stringify('\uDA33')); +assertEquals('"\\uda34"', JSON.stringify('\uDA34')); +assertEquals('"\\uda35"', JSON.stringify('\uDA35')); +assertEquals('"\\uda36"', JSON.stringify('\uDA36')); +assertEquals('"\\uda37"', JSON.stringify('\uDA37')); +assertEquals('"\\uda38"', JSON.stringify('\uDA38')); +assertEquals('"\\uda39"', JSON.stringify('\uDA39')); +assertEquals('"\\uda3a"', JSON.stringify('\uDA3A')); +assertEquals('"\\uda3b"', JSON.stringify('\uDA3B')); +assertEquals('"\\uda3c"', JSON.stringify('\uDA3C')); +assertEquals('"\\uda3d"', JSON.stringify('\uDA3D')); +assertEquals('"\\uda3e"', JSON.stringify('\uDA3E')); +assertEquals('"\\uda3f"', JSON.stringify('\uDA3F')); +assertEquals('"\\uda40"', JSON.stringify('\uDA40')); +assertEquals('"\\uda41"', JSON.stringify('\uDA41')); +assertEquals('"\\uda42"', JSON.stringify('\uDA42')); +assertEquals('"\\uda43"', JSON.stringify('\uDA43')); +assertEquals('"\\uda44"', JSON.stringify('\uDA44')); +assertEquals('"\\uda45"', JSON.stringify('\uDA45')); +assertEquals('"\\uda46"', JSON.stringify('\uDA46')); +assertEquals('"\\uda47"', JSON.stringify('\uDA47')); +assertEquals('"\\uda48"', JSON.stringify('\uDA48')); +assertEquals('"\\uda49"', JSON.stringify('\uDA49')); +assertEquals('"\\uda4a"', JSON.stringify('\uDA4A')); +assertEquals('"\\uda4b"', JSON.stringify('\uDA4B')); +assertEquals('"\\uda4c"', JSON.stringify('\uDA4C')); +assertEquals('"\\uda4d"', JSON.stringify('\uDA4D')); +assertEquals('"\\uda4e"', JSON.stringify('\uDA4E')); +assertEquals('"\\uda4f"', JSON.stringify('\uDA4F')); +assertEquals('"\\uda50"', JSON.stringify('\uDA50')); +assertEquals('"\\uda51"', JSON.stringify('\uDA51')); +assertEquals('"\\uda52"', JSON.stringify('\uDA52')); +assertEquals('"\\uda53"', JSON.stringify('\uDA53')); +assertEquals('"\\uda54"', JSON.stringify('\uDA54')); +assertEquals('"\\uda55"', JSON.stringify('\uDA55')); +assertEquals('"\\uda56"', JSON.stringify('\uDA56')); +assertEquals('"\\uda57"', JSON.stringify('\uDA57')); +assertEquals('"\\uda58"', JSON.stringify('\uDA58')); +assertEquals('"\\uda59"', JSON.stringify('\uDA59')); +assertEquals('"\\uda5a"', JSON.stringify('\uDA5A')); +assertEquals('"\\uda5b"', JSON.stringify('\uDA5B')); +assertEquals('"\\uda5c"', JSON.stringify('\uDA5C')); +assertEquals('"\\uda5d"', JSON.stringify('\uDA5D')); +assertEquals('"\\uda5e"', JSON.stringify('\uDA5E')); +assertEquals('"\\uda5f"', JSON.stringify('\uDA5F')); +assertEquals('"\\uda60"', JSON.stringify('\uDA60')); +assertEquals('"\\uda61"', JSON.stringify('\uDA61')); +assertEquals('"\\uda62"', JSON.stringify('\uDA62')); +assertEquals('"\\uda63"', JSON.stringify('\uDA63')); +assertEquals('"\\uda64"', JSON.stringify('\uDA64')); +assertEquals('"\\uda65"', JSON.stringify('\uDA65')); +assertEquals('"\\uda66"', JSON.stringify('\uDA66')); +assertEquals('"\\uda67"', JSON.stringify('\uDA67')); +assertEquals('"\\uda68"', JSON.stringify('\uDA68')); +assertEquals('"\\uda69"', JSON.stringify('\uDA69')); +assertEquals('"\\uda6a"', JSON.stringify('\uDA6A')); +assertEquals('"\\uda6b"', JSON.stringify('\uDA6B')); +assertEquals('"\\uda6c"', JSON.stringify('\uDA6C')); +assertEquals('"\\uda6d"', JSON.stringify('\uDA6D')); +assertEquals('"\\uda6e"', JSON.stringify('\uDA6E')); +assertEquals('"\\uda6f"', JSON.stringify('\uDA6F')); +assertEquals('"\\uda70"', JSON.stringify('\uDA70')); +assertEquals('"\\uda71"', JSON.stringify('\uDA71')); +assertEquals('"\\uda72"', JSON.stringify('\uDA72')); +assertEquals('"\\uda73"', JSON.stringify('\uDA73')); +assertEquals('"\\uda74"', JSON.stringify('\uDA74')); +assertEquals('"\\uda75"', JSON.stringify('\uDA75')); +assertEquals('"\\uda76"', JSON.stringify('\uDA76')); +assertEquals('"\\uda77"', JSON.stringify('\uDA77')); +assertEquals('"\\uda78"', JSON.stringify('\uDA78')); +assertEquals('"\\uda79"', JSON.stringify('\uDA79')); +assertEquals('"\\uda7a"', JSON.stringify('\uDA7A')); +assertEquals('"\\uda7b"', JSON.stringify('\uDA7B')); +assertEquals('"\\uda7c"', JSON.stringify('\uDA7C')); +assertEquals('"\\uda7d"', JSON.stringify('\uDA7D')); +assertEquals('"\\uda7e"', JSON.stringify('\uDA7E')); +assertEquals('"\\uda7f"', JSON.stringify('\uDA7F')); +assertEquals('"\\uda80"', JSON.stringify('\uDA80')); +assertEquals('"\\uda81"', JSON.stringify('\uDA81')); +assertEquals('"\\uda82"', JSON.stringify('\uDA82')); +assertEquals('"\\uda83"', JSON.stringify('\uDA83')); +assertEquals('"\\uda84"', JSON.stringify('\uDA84')); +assertEquals('"\\uda85"', JSON.stringify('\uDA85')); +assertEquals('"\\uda86"', JSON.stringify('\uDA86')); +assertEquals('"\\uda87"', JSON.stringify('\uDA87')); +assertEquals('"\\uda88"', JSON.stringify('\uDA88')); +assertEquals('"\\uda89"', JSON.stringify('\uDA89')); +assertEquals('"\\uda8a"', JSON.stringify('\uDA8A')); +assertEquals('"\\uda8b"', JSON.stringify('\uDA8B')); +assertEquals('"\\uda8c"', JSON.stringify('\uDA8C')); +assertEquals('"\\uda8d"', JSON.stringify('\uDA8D')); +assertEquals('"\\uda8e"', JSON.stringify('\uDA8E')); +assertEquals('"\\uda8f"', JSON.stringify('\uDA8F')); +assertEquals('"\\uda90"', JSON.stringify('\uDA90')); +assertEquals('"\\uda91"', JSON.stringify('\uDA91')); +assertEquals('"\\uda92"', JSON.stringify('\uDA92')); +assertEquals('"\\uda93"', JSON.stringify('\uDA93')); +assertEquals('"\\uda94"', JSON.stringify('\uDA94')); +assertEquals('"\\uda95"', JSON.stringify('\uDA95')); +assertEquals('"\\uda96"', JSON.stringify('\uDA96')); +assertEquals('"\\uda97"', JSON.stringify('\uDA97')); +assertEquals('"\\uda98"', JSON.stringify('\uDA98')); +assertEquals('"\\uda99"', JSON.stringify('\uDA99')); +assertEquals('"\\uda9a"', JSON.stringify('\uDA9A')); +assertEquals('"\\uda9b"', JSON.stringify('\uDA9B')); +assertEquals('"\\uda9c"', JSON.stringify('\uDA9C')); +assertEquals('"\\uda9d"', JSON.stringify('\uDA9D')); +assertEquals('"\\uda9e"', JSON.stringify('\uDA9E')); +assertEquals('"\\uda9f"', JSON.stringify('\uDA9F')); +assertEquals('"\\udaa0"', JSON.stringify('\uDAA0')); +assertEquals('"\\udaa1"', JSON.stringify('\uDAA1')); +assertEquals('"\\udaa2"', JSON.stringify('\uDAA2')); +assertEquals('"\\udaa3"', JSON.stringify('\uDAA3')); +assertEquals('"\\udaa4"', JSON.stringify('\uDAA4')); +assertEquals('"\\udaa5"', JSON.stringify('\uDAA5')); +assertEquals('"\\udaa6"', JSON.stringify('\uDAA6')); +assertEquals('"\\udaa7"', JSON.stringify('\uDAA7')); +assertEquals('"\\udaa8"', JSON.stringify('\uDAA8')); +assertEquals('"\\udaa9"', JSON.stringify('\uDAA9')); +assertEquals('"\\udaaa"', JSON.stringify('\uDAAA')); +assertEquals('"\\udaab"', JSON.stringify('\uDAAB')); +assertEquals('"\\udaac"', JSON.stringify('\uDAAC')); +assertEquals('"\\udaad"', JSON.stringify('\uDAAD')); +assertEquals('"\\udaae"', JSON.stringify('\uDAAE')); +assertEquals('"\\udaaf"', JSON.stringify('\uDAAF')); +assertEquals('"\\udab0"', JSON.stringify('\uDAB0')); +assertEquals('"\\udab1"', JSON.stringify('\uDAB1')); +assertEquals('"\\udab2"', JSON.stringify('\uDAB2')); +assertEquals('"\\udab3"', JSON.stringify('\uDAB3')); +assertEquals('"\\udab4"', JSON.stringify('\uDAB4')); +assertEquals('"\\udab5"', JSON.stringify('\uDAB5')); +assertEquals('"\\udab6"', JSON.stringify('\uDAB6')); +assertEquals('"\\udab7"', JSON.stringify('\uDAB7')); +assertEquals('"\\udab8"', JSON.stringify('\uDAB8')); +assertEquals('"\\udab9"', JSON.stringify('\uDAB9')); +assertEquals('"\\udaba"', JSON.stringify('\uDABA')); +assertEquals('"\\udabb"', JSON.stringify('\uDABB')); +assertEquals('"\\udabc"', JSON.stringify('\uDABC')); +assertEquals('"\\udabd"', JSON.stringify('\uDABD')); +assertEquals('"\\udabe"', JSON.stringify('\uDABE')); +assertEquals('"\\udabf"', JSON.stringify('\uDABF')); +assertEquals('"\\udac0"', JSON.stringify('\uDAC0')); +assertEquals('"\\udac1"', JSON.stringify('\uDAC1')); +assertEquals('"\\udac2"', JSON.stringify('\uDAC2')); +assertEquals('"\\udac3"', JSON.stringify('\uDAC3')); +assertEquals('"\\udac4"', JSON.stringify('\uDAC4')); +assertEquals('"\\udac5"', JSON.stringify('\uDAC5')); +assertEquals('"\\udac6"', JSON.stringify('\uDAC6')); +assertEquals('"\\udac7"', JSON.stringify('\uDAC7')); +assertEquals('"\\udac8"', JSON.stringify('\uDAC8')); +assertEquals('"\\udac9"', JSON.stringify('\uDAC9')); +assertEquals('"\\udaca"', JSON.stringify('\uDACA')); +assertEquals('"\\udacb"', JSON.stringify('\uDACB')); +assertEquals('"\\udacc"', JSON.stringify('\uDACC')); +assertEquals('"\\udacd"', JSON.stringify('\uDACD')); +assertEquals('"\\udace"', JSON.stringify('\uDACE')); +assertEquals('"\\udacf"', JSON.stringify('\uDACF')); +assertEquals('"\\udad0"', JSON.stringify('\uDAD0')); +assertEquals('"\\udad1"', JSON.stringify('\uDAD1')); +assertEquals('"\\udad2"', JSON.stringify('\uDAD2')); +assertEquals('"\\udad3"', JSON.stringify('\uDAD3')); +assertEquals('"\\udad4"', JSON.stringify('\uDAD4')); +assertEquals('"\\udad5"', JSON.stringify('\uDAD5')); +assertEquals('"\\udad6"', JSON.stringify('\uDAD6')); +assertEquals('"\\udad7"', JSON.stringify('\uDAD7')); +assertEquals('"\\udad8"', JSON.stringify('\uDAD8')); +assertEquals('"\\udad9"', JSON.stringify('\uDAD9')); +assertEquals('"\\udada"', JSON.stringify('\uDADA')); +assertEquals('"\\udadb"', JSON.stringify('\uDADB')); +assertEquals('"\\udadc"', JSON.stringify('\uDADC')); +assertEquals('"\\udadd"', JSON.stringify('\uDADD')); +assertEquals('"\\udade"', JSON.stringify('\uDADE')); +assertEquals('"\\udadf"', JSON.stringify('\uDADF')); +assertEquals('"\\udae0"', JSON.stringify('\uDAE0')); +assertEquals('"\\udae1"', JSON.stringify('\uDAE1')); +assertEquals('"\\udae2"', JSON.stringify('\uDAE2')); +assertEquals('"\\udae3"', JSON.stringify('\uDAE3')); +assertEquals('"\\udae4"', JSON.stringify('\uDAE4')); +assertEquals('"\\udae5"', JSON.stringify('\uDAE5')); +assertEquals('"\\udae6"', JSON.stringify('\uDAE6')); +assertEquals('"\\udae7"', JSON.stringify('\uDAE7')); +assertEquals('"\\udae8"', JSON.stringify('\uDAE8')); +assertEquals('"\\udae9"', JSON.stringify('\uDAE9')); +assertEquals('"\\udaea"', JSON.stringify('\uDAEA')); +assertEquals('"\\udaeb"', JSON.stringify('\uDAEB')); +assertEquals('"\\udaec"', JSON.stringify('\uDAEC')); +assertEquals('"\\udaed"', JSON.stringify('\uDAED')); +assertEquals('"\\udaee"', JSON.stringify('\uDAEE')); +assertEquals('"\\udaef"', JSON.stringify('\uDAEF')); +assertEquals('"\\udaf0"', JSON.stringify('\uDAF0')); +assertEquals('"\\udaf1"', JSON.stringify('\uDAF1')); +assertEquals('"\\udaf2"', JSON.stringify('\uDAF2')); +assertEquals('"\\udaf3"', JSON.stringify('\uDAF3')); +assertEquals('"\\udaf4"', JSON.stringify('\uDAF4')); +assertEquals('"\\udaf5"', JSON.stringify('\uDAF5')); +assertEquals('"\\udaf6"', JSON.stringify('\uDAF6')); +assertEquals('"\\udaf7"', JSON.stringify('\uDAF7')); +assertEquals('"\\udaf8"', JSON.stringify('\uDAF8')); +assertEquals('"\\udaf9"', JSON.stringify('\uDAF9')); +assertEquals('"\\udafa"', JSON.stringify('\uDAFA')); +assertEquals('"\\udafb"', JSON.stringify('\uDAFB')); +assertEquals('"\\udafc"', JSON.stringify('\uDAFC')); +assertEquals('"\\udafd"', JSON.stringify('\uDAFD')); +assertEquals('"\\udafe"', JSON.stringify('\uDAFE')); +assertEquals('"\\udaff"', JSON.stringify('\uDAFF')); +assertEquals('"\\udb00"', JSON.stringify('\uDB00')); +assertEquals('"\\udb01"', JSON.stringify('\uDB01')); +assertEquals('"\\udb02"', JSON.stringify('\uDB02')); +assertEquals('"\\udb03"', JSON.stringify('\uDB03')); +assertEquals('"\\udb04"', JSON.stringify('\uDB04')); +assertEquals('"\\udb05"', JSON.stringify('\uDB05')); +assertEquals('"\\udb06"', JSON.stringify('\uDB06')); +assertEquals('"\\udb07"', JSON.stringify('\uDB07')); +assertEquals('"\\udb08"', JSON.stringify('\uDB08')); +assertEquals('"\\udb09"', JSON.stringify('\uDB09')); +assertEquals('"\\udb0a"', JSON.stringify('\uDB0A')); +assertEquals('"\\udb0b"', JSON.stringify('\uDB0B')); +assertEquals('"\\udb0c"', JSON.stringify('\uDB0C')); +assertEquals('"\\udb0d"', JSON.stringify('\uDB0D')); +assertEquals('"\\udb0e"', JSON.stringify('\uDB0E')); +assertEquals('"\\udb0f"', JSON.stringify('\uDB0F')); +assertEquals('"\\udb10"', JSON.stringify('\uDB10')); +assertEquals('"\\udb11"', JSON.stringify('\uDB11')); +assertEquals('"\\udb12"', JSON.stringify('\uDB12')); +assertEquals('"\\udb13"', JSON.stringify('\uDB13')); +assertEquals('"\\udb14"', JSON.stringify('\uDB14')); +assertEquals('"\\udb15"', JSON.stringify('\uDB15')); +assertEquals('"\\udb16"', JSON.stringify('\uDB16')); +assertEquals('"\\udb17"', JSON.stringify('\uDB17')); +assertEquals('"\\udb18"', JSON.stringify('\uDB18')); +assertEquals('"\\udb19"', JSON.stringify('\uDB19')); +assertEquals('"\\udb1a"', JSON.stringify('\uDB1A')); +assertEquals('"\\udb1b"', JSON.stringify('\uDB1B')); +assertEquals('"\\udb1c"', JSON.stringify('\uDB1C')); +assertEquals('"\\udb1d"', JSON.stringify('\uDB1D')); +assertEquals('"\\udb1e"', JSON.stringify('\uDB1E')); +assertEquals('"\\udb1f"', JSON.stringify('\uDB1F')); +assertEquals('"\\udb20"', JSON.stringify('\uDB20')); +assertEquals('"\\udb21"', JSON.stringify('\uDB21')); +assertEquals('"\\udb22"', JSON.stringify('\uDB22')); +assertEquals('"\\udb23"', JSON.stringify('\uDB23')); +assertEquals('"\\udb24"', JSON.stringify('\uDB24')); +assertEquals('"\\udb25"', JSON.stringify('\uDB25')); +assertEquals('"\\udb26"', JSON.stringify('\uDB26')); +assertEquals('"\\udb27"', JSON.stringify('\uDB27')); +assertEquals('"\\udb28"', JSON.stringify('\uDB28')); +assertEquals('"\\udb29"', JSON.stringify('\uDB29')); +assertEquals('"\\udb2a"', JSON.stringify('\uDB2A')); +assertEquals('"\\udb2b"', JSON.stringify('\uDB2B')); +assertEquals('"\\udb2c"', JSON.stringify('\uDB2C')); +assertEquals('"\\udb2d"', JSON.stringify('\uDB2D')); +assertEquals('"\\udb2e"', JSON.stringify('\uDB2E')); +assertEquals('"\\udb2f"', JSON.stringify('\uDB2F')); +assertEquals('"\\udb30"', JSON.stringify('\uDB30')); +assertEquals('"\\udb31"', JSON.stringify('\uDB31')); +assertEquals('"\\udb32"', JSON.stringify('\uDB32')); +assertEquals('"\\udb33"', JSON.stringify('\uDB33')); +assertEquals('"\\udb34"', JSON.stringify('\uDB34')); +assertEquals('"\\udb35"', JSON.stringify('\uDB35')); +assertEquals('"\\udb36"', JSON.stringify('\uDB36')); +assertEquals('"\\udb37"', JSON.stringify('\uDB37')); +assertEquals('"\\udb38"', JSON.stringify('\uDB38')); +assertEquals('"\\udb39"', JSON.stringify('\uDB39')); +assertEquals('"\\udb3a"', JSON.stringify('\uDB3A')); +assertEquals('"\\udb3b"', JSON.stringify('\uDB3B')); +assertEquals('"\\udb3c"', JSON.stringify('\uDB3C')); +assertEquals('"\\udb3d"', JSON.stringify('\uDB3D')); +assertEquals('"\\udb3e"', JSON.stringify('\uDB3E')); +assertEquals('"\\udb3f"', JSON.stringify('\uDB3F')); +assertEquals('"\\udb40"', JSON.stringify('\uDB40')); +assertEquals('"\\udb41"', JSON.stringify('\uDB41')); +assertEquals('"\\udb42"', JSON.stringify('\uDB42')); +assertEquals('"\\udb43"', JSON.stringify('\uDB43')); +assertEquals('"\\udb44"', JSON.stringify('\uDB44')); +assertEquals('"\\udb45"', JSON.stringify('\uDB45')); +assertEquals('"\\udb46"', JSON.stringify('\uDB46')); +assertEquals('"\\udb47"', JSON.stringify('\uDB47')); +assertEquals('"\\udb48"', JSON.stringify('\uDB48')); +assertEquals('"\\udb49"', JSON.stringify('\uDB49')); +assertEquals('"\\udb4a"', JSON.stringify('\uDB4A')); +assertEquals('"\\udb4b"', JSON.stringify('\uDB4B')); +assertEquals('"\\udb4c"', JSON.stringify('\uDB4C')); +assertEquals('"\\udb4d"', JSON.stringify('\uDB4D')); +assertEquals('"\\udb4e"', JSON.stringify('\uDB4E')); +assertEquals('"\\udb4f"', JSON.stringify('\uDB4F')); +assertEquals('"\\udb50"', JSON.stringify('\uDB50')); +assertEquals('"\\udb51"', JSON.stringify('\uDB51')); +assertEquals('"\\udb52"', JSON.stringify('\uDB52')); +assertEquals('"\\udb53"', JSON.stringify('\uDB53')); +assertEquals('"\\udb54"', JSON.stringify('\uDB54')); +assertEquals('"\\udb55"', JSON.stringify('\uDB55')); +assertEquals('"\\udb56"', JSON.stringify('\uDB56')); +assertEquals('"\\udb57"', JSON.stringify('\uDB57')); +assertEquals('"\\udb58"', JSON.stringify('\uDB58')); +assertEquals('"\\udb59"', JSON.stringify('\uDB59')); +assertEquals('"\\udb5a"', JSON.stringify('\uDB5A')); +assertEquals('"\\udb5b"', JSON.stringify('\uDB5B')); +assertEquals('"\\udb5c"', JSON.stringify('\uDB5C')); +assertEquals('"\\udb5d"', JSON.stringify('\uDB5D')); +assertEquals('"\\udb5e"', JSON.stringify('\uDB5E')); +assertEquals('"\\udb5f"', JSON.stringify('\uDB5F')); +assertEquals('"\\udb60"', JSON.stringify('\uDB60')); +assertEquals('"\\udb61"', JSON.stringify('\uDB61')); +assertEquals('"\\udb62"', JSON.stringify('\uDB62')); +assertEquals('"\\udb63"', JSON.stringify('\uDB63')); +assertEquals('"\\udb64"', JSON.stringify('\uDB64')); +assertEquals('"\\udb65"', JSON.stringify('\uDB65')); +assertEquals('"\\udb66"', JSON.stringify('\uDB66')); +assertEquals('"\\udb67"', JSON.stringify('\uDB67')); +assertEquals('"\\udb68"', JSON.stringify('\uDB68')); +assertEquals('"\\udb69"', JSON.stringify('\uDB69')); +assertEquals('"\\udb6a"', JSON.stringify('\uDB6A')); +assertEquals('"\\udb6b"', JSON.stringify('\uDB6B')); +assertEquals('"\\udb6c"', JSON.stringify('\uDB6C')); +assertEquals('"\\udb6d"', JSON.stringify('\uDB6D')); +assertEquals('"\\udb6e"', JSON.stringify('\uDB6E')); +assertEquals('"\\udb6f"', JSON.stringify('\uDB6F')); +assertEquals('"\\udb70"', JSON.stringify('\uDB70')); +assertEquals('"\\udb71"', JSON.stringify('\uDB71')); +assertEquals('"\\udb72"', JSON.stringify('\uDB72')); +assertEquals('"\\udb73"', JSON.stringify('\uDB73')); +assertEquals('"\\udb74"', JSON.stringify('\uDB74')); +assertEquals('"\\udb75"', JSON.stringify('\uDB75')); +assertEquals('"\\udb76"', JSON.stringify('\uDB76')); +assertEquals('"\\udb77"', JSON.stringify('\uDB77')); +assertEquals('"\\udb78"', JSON.stringify('\uDB78')); +assertEquals('"\\udb79"', JSON.stringify('\uDB79')); +assertEquals('"\\udb7a"', JSON.stringify('\uDB7A')); +assertEquals('"\\udb7b"', JSON.stringify('\uDB7B')); +assertEquals('"\\udb7c"', JSON.stringify('\uDB7C')); +assertEquals('"\\udb7d"', JSON.stringify('\uDB7D')); +assertEquals('"\\udb7e"', JSON.stringify('\uDB7E')); +assertEquals('"\\udb7f"', JSON.stringify('\uDB7F')); +assertEquals('"\\udb80"', JSON.stringify('\uDB80')); +assertEquals('"\\udb81"', JSON.stringify('\uDB81')); +assertEquals('"\\udb82"', JSON.stringify('\uDB82')); +assertEquals('"\\udb83"', JSON.stringify('\uDB83')); +assertEquals('"\\udb84"', JSON.stringify('\uDB84')); +assertEquals('"\\udb85"', JSON.stringify('\uDB85')); +assertEquals('"\\udb86"', JSON.stringify('\uDB86')); +assertEquals('"\\udb87"', JSON.stringify('\uDB87')); +assertEquals('"\\udb88"', JSON.stringify('\uDB88')); +assertEquals('"\\udb89"', JSON.stringify('\uDB89')); +assertEquals('"\\udb8a"', JSON.stringify('\uDB8A')); +assertEquals('"\\udb8b"', JSON.stringify('\uDB8B')); +assertEquals('"\\udb8c"', JSON.stringify('\uDB8C')); +assertEquals('"\\udb8d"', JSON.stringify('\uDB8D')); +assertEquals('"\\udb8e"', JSON.stringify('\uDB8E')); +assertEquals('"\\udb8f"', JSON.stringify('\uDB8F')); +assertEquals('"\\udb90"', JSON.stringify('\uDB90')); +assertEquals('"\\udb91"', JSON.stringify('\uDB91')); +assertEquals('"\\udb92"', JSON.stringify('\uDB92')); +assertEquals('"\\udb93"', JSON.stringify('\uDB93')); +assertEquals('"\\udb94"', JSON.stringify('\uDB94')); +assertEquals('"\\udb95"', JSON.stringify('\uDB95')); +assertEquals('"\\udb96"', JSON.stringify('\uDB96')); +assertEquals('"\\udb97"', JSON.stringify('\uDB97')); +assertEquals('"\\udb98"', JSON.stringify('\uDB98')); +assertEquals('"\\udb99"', JSON.stringify('\uDB99')); +assertEquals('"\\udb9a"', JSON.stringify('\uDB9A')); +assertEquals('"\\udb9b"', JSON.stringify('\uDB9B')); +assertEquals('"\\udb9c"', JSON.stringify('\uDB9C')); +assertEquals('"\\udb9d"', JSON.stringify('\uDB9D')); +assertEquals('"\\udb9e"', JSON.stringify('\uDB9E')); +assertEquals('"\\udb9f"', JSON.stringify('\uDB9F')); +assertEquals('"\\udba0"', JSON.stringify('\uDBA0')); +assertEquals('"\\udba1"', JSON.stringify('\uDBA1')); +assertEquals('"\\udba2"', JSON.stringify('\uDBA2')); +assertEquals('"\\udba3"', JSON.stringify('\uDBA3')); +assertEquals('"\\udba4"', JSON.stringify('\uDBA4')); +assertEquals('"\\udba5"', JSON.stringify('\uDBA5')); +assertEquals('"\\udba6"', JSON.stringify('\uDBA6')); +assertEquals('"\\udba7"', JSON.stringify('\uDBA7')); +assertEquals('"\\udba8"', JSON.stringify('\uDBA8')); +assertEquals('"\\udba9"', JSON.stringify('\uDBA9')); +assertEquals('"\\udbaa"', JSON.stringify('\uDBAA')); +assertEquals('"\\udbab"', JSON.stringify('\uDBAB')); +assertEquals('"\\udbac"', JSON.stringify('\uDBAC')); +assertEquals('"\\udbad"', JSON.stringify('\uDBAD')); +assertEquals('"\\udbae"', JSON.stringify('\uDBAE')); +assertEquals('"\\udbaf"', JSON.stringify('\uDBAF')); +assertEquals('"\\udbb0"', JSON.stringify('\uDBB0')); +assertEquals('"\\udbb1"', JSON.stringify('\uDBB1')); +assertEquals('"\\udbb2"', JSON.stringify('\uDBB2')); +assertEquals('"\\udbb3"', JSON.stringify('\uDBB3')); +assertEquals('"\\udbb4"', JSON.stringify('\uDBB4')); +assertEquals('"\\udbb5"', JSON.stringify('\uDBB5')); +assertEquals('"\\udbb6"', JSON.stringify('\uDBB6')); +assertEquals('"\\udbb7"', JSON.stringify('\uDBB7')); +assertEquals('"\\udbb8"', JSON.stringify('\uDBB8')); +assertEquals('"\\udbb9"', JSON.stringify('\uDBB9')); +assertEquals('"\\udbba"', JSON.stringify('\uDBBA')); +assertEquals('"\\udbbb"', JSON.stringify('\uDBBB')); +assertEquals('"\\udbbc"', JSON.stringify('\uDBBC')); +assertEquals('"\\udbbd"', JSON.stringify('\uDBBD')); +assertEquals('"\\udbbe"', JSON.stringify('\uDBBE')); +assertEquals('"\\udbbf"', JSON.stringify('\uDBBF')); +assertEquals('"\\udbc0"', JSON.stringify('\uDBC0')); +assertEquals('"\\udbc1"', JSON.stringify('\uDBC1')); +assertEquals('"\\udbc2"', JSON.stringify('\uDBC2')); +assertEquals('"\\udbc3"', JSON.stringify('\uDBC3')); +assertEquals('"\\udbc4"', JSON.stringify('\uDBC4')); +assertEquals('"\\udbc5"', JSON.stringify('\uDBC5')); +assertEquals('"\\udbc6"', JSON.stringify('\uDBC6')); +assertEquals('"\\udbc7"', JSON.stringify('\uDBC7')); +assertEquals('"\\udbc8"', JSON.stringify('\uDBC8')); +assertEquals('"\\udbc9"', JSON.stringify('\uDBC9')); +assertEquals('"\\udbca"', JSON.stringify('\uDBCA')); +assertEquals('"\\udbcb"', JSON.stringify('\uDBCB')); +assertEquals('"\\udbcc"', JSON.stringify('\uDBCC')); +assertEquals('"\\udbcd"', JSON.stringify('\uDBCD')); +assertEquals('"\\udbce"', JSON.stringify('\uDBCE')); +assertEquals('"\\udbcf"', JSON.stringify('\uDBCF')); +assertEquals('"\\udbd0"', JSON.stringify('\uDBD0')); +assertEquals('"\\udbd1"', JSON.stringify('\uDBD1')); +assertEquals('"\\udbd2"', JSON.stringify('\uDBD2')); +assertEquals('"\\udbd3"', JSON.stringify('\uDBD3')); +assertEquals('"\\udbd4"', JSON.stringify('\uDBD4')); +assertEquals('"\\udbd5"', JSON.stringify('\uDBD5')); +assertEquals('"\\udbd6"', JSON.stringify('\uDBD6')); +assertEquals('"\\udbd7"', JSON.stringify('\uDBD7')); +assertEquals('"\\udbd8"', JSON.stringify('\uDBD8')); +assertEquals('"\\udbd9"', JSON.stringify('\uDBD9')); +assertEquals('"\\udbda"', JSON.stringify('\uDBDA')); +assertEquals('"\\udbdb"', JSON.stringify('\uDBDB')); +assertEquals('"\\udbdc"', JSON.stringify('\uDBDC')); +assertEquals('"\\udbdd"', JSON.stringify('\uDBDD')); +assertEquals('"\\udbde"', JSON.stringify('\uDBDE')); +assertEquals('"\\udbdf"', JSON.stringify('\uDBDF')); +assertEquals('"\\udbe0"', JSON.stringify('\uDBE0')); +assertEquals('"\\udbe1"', JSON.stringify('\uDBE1')); +assertEquals('"\\udbe2"', JSON.stringify('\uDBE2')); +assertEquals('"\\udbe3"', JSON.stringify('\uDBE3')); +assertEquals('"\\udbe4"', JSON.stringify('\uDBE4')); +assertEquals('"\\udbe5"', JSON.stringify('\uDBE5')); +assertEquals('"\\udbe6"', JSON.stringify('\uDBE6')); +assertEquals('"\\udbe7"', JSON.stringify('\uDBE7')); +assertEquals('"\\udbe8"', JSON.stringify('\uDBE8')); +assertEquals('"\\udbe9"', JSON.stringify('\uDBE9')); +assertEquals('"\\udbea"', JSON.stringify('\uDBEA')); +assertEquals('"\\udbeb"', JSON.stringify('\uDBEB')); +assertEquals('"\\udbec"', JSON.stringify('\uDBEC')); +assertEquals('"\\udbed"', JSON.stringify('\uDBED')); +assertEquals('"\\udbee"', JSON.stringify('\uDBEE')); +assertEquals('"\\udbef"', JSON.stringify('\uDBEF')); +assertEquals('"\\udbf0"', JSON.stringify('\uDBF0')); +assertEquals('"\\udbf1"', JSON.stringify('\uDBF1')); +assertEquals('"\\udbf2"', JSON.stringify('\uDBF2')); +assertEquals('"\\udbf3"', JSON.stringify('\uDBF3')); +assertEquals('"\\udbf4"', JSON.stringify('\uDBF4')); +assertEquals('"\\udbf5"', JSON.stringify('\uDBF5')); +assertEquals('"\\udbf6"', JSON.stringify('\uDBF6')); +assertEquals('"\\udbf7"', JSON.stringify('\uDBF7')); +assertEquals('"\\udbf8"', JSON.stringify('\uDBF8')); +assertEquals('"\\udbf9"', JSON.stringify('\uDBF9')); +assertEquals('"\\udbfa"', JSON.stringify('\uDBFA')); +assertEquals('"\\udbfb"', JSON.stringify('\uDBFB')); +assertEquals('"\\udbfc"', JSON.stringify('\uDBFC')); +assertEquals('"\\udbfd"', JSON.stringify('\uDBFD')); +assertEquals('"\\udbfe"', JSON.stringify('\uDBFE')); +assertEquals('"\\udbff"', JSON.stringify('\uDBFF')); +assertEquals('"\\udc00"', JSON.stringify('\uDC00')); +assertEquals('"\\udc01"', JSON.stringify('\uDC01')); +assertEquals('"\\udc02"', JSON.stringify('\uDC02')); +assertEquals('"\\udc03"', JSON.stringify('\uDC03')); +assertEquals('"\\udc04"', JSON.stringify('\uDC04')); +assertEquals('"\\udc05"', JSON.stringify('\uDC05')); +assertEquals('"\\udc06"', JSON.stringify('\uDC06')); +assertEquals('"\\udc07"', JSON.stringify('\uDC07')); +assertEquals('"\\udc08"', JSON.stringify('\uDC08')); +assertEquals('"\\udc09"', JSON.stringify('\uDC09')); +assertEquals('"\\udc0a"', JSON.stringify('\uDC0A')); +assertEquals('"\\udc0b"', JSON.stringify('\uDC0B')); +assertEquals('"\\udc0c"', JSON.stringify('\uDC0C')); +assertEquals('"\\udc0d"', JSON.stringify('\uDC0D')); +assertEquals('"\\udc0e"', JSON.stringify('\uDC0E')); +assertEquals('"\\udc0f"', JSON.stringify('\uDC0F')); +assertEquals('"\\udc10"', JSON.stringify('\uDC10')); +assertEquals('"\\udc11"', JSON.stringify('\uDC11')); +assertEquals('"\\udc12"', JSON.stringify('\uDC12')); +assertEquals('"\\udc13"', JSON.stringify('\uDC13')); +assertEquals('"\\udc14"', JSON.stringify('\uDC14')); +assertEquals('"\\udc15"', JSON.stringify('\uDC15')); +assertEquals('"\\udc16"', JSON.stringify('\uDC16')); +assertEquals('"\\udc17"', JSON.stringify('\uDC17')); +assertEquals('"\\udc18"', JSON.stringify('\uDC18')); +assertEquals('"\\udc19"', JSON.stringify('\uDC19')); +assertEquals('"\\udc1a"', JSON.stringify('\uDC1A')); +assertEquals('"\\udc1b"', JSON.stringify('\uDC1B')); +assertEquals('"\\udc1c"', JSON.stringify('\uDC1C')); +assertEquals('"\\udc1d"', JSON.stringify('\uDC1D')); +assertEquals('"\\udc1e"', JSON.stringify('\uDC1E')); +assertEquals('"\\udc1f"', JSON.stringify('\uDC1F')); +assertEquals('"\\udc20"', JSON.stringify('\uDC20')); +assertEquals('"\\udc21"', JSON.stringify('\uDC21')); +assertEquals('"\\udc22"', JSON.stringify('\uDC22')); +assertEquals('"\\udc23"', JSON.stringify('\uDC23')); +assertEquals('"\\udc24"', JSON.stringify('\uDC24')); +assertEquals('"\\udc25"', JSON.stringify('\uDC25')); +assertEquals('"\\udc26"', JSON.stringify('\uDC26')); +assertEquals('"\\udc27"', JSON.stringify('\uDC27')); +assertEquals('"\\udc28"', JSON.stringify('\uDC28')); +assertEquals('"\\udc29"', JSON.stringify('\uDC29')); +assertEquals('"\\udc2a"', JSON.stringify('\uDC2A')); +assertEquals('"\\udc2b"', JSON.stringify('\uDC2B')); +assertEquals('"\\udc2c"', JSON.stringify('\uDC2C')); +assertEquals('"\\udc2d"', JSON.stringify('\uDC2D')); +assertEquals('"\\udc2e"', JSON.stringify('\uDC2E')); +assertEquals('"\\udc2f"', JSON.stringify('\uDC2F')); +assertEquals('"\\udc30"', JSON.stringify('\uDC30')); +assertEquals('"\\udc31"', JSON.stringify('\uDC31')); +assertEquals('"\\udc32"', JSON.stringify('\uDC32')); +assertEquals('"\\udc33"', JSON.stringify('\uDC33')); +assertEquals('"\\udc34"', JSON.stringify('\uDC34')); +assertEquals('"\\udc35"', JSON.stringify('\uDC35')); +assertEquals('"\\udc36"', JSON.stringify('\uDC36')); +assertEquals('"\\udc37"', JSON.stringify('\uDC37')); +assertEquals('"\\udc38"', JSON.stringify('\uDC38')); +assertEquals('"\\udc39"', JSON.stringify('\uDC39')); +assertEquals('"\\udc3a"', JSON.stringify('\uDC3A')); +assertEquals('"\\udc3b"', JSON.stringify('\uDC3B')); +assertEquals('"\\udc3c"', JSON.stringify('\uDC3C')); +assertEquals('"\\udc3d"', JSON.stringify('\uDC3D')); +assertEquals('"\\udc3e"', JSON.stringify('\uDC3E')); +assertEquals('"\\udc3f"', JSON.stringify('\uDC3F')); +assertEquals('"\\udc40"', JSON.stringify('\uDC40')); +assertEquals('"\\udc41"', JSON.stringify('\uDC41')); +assertEquals('"\\udc42"', JSON.stringify('\uDC42')); +assertEquals('"\\udc43"', JSON.stringify('\uDC43')); +assertEquals('"\\udc44"', JSON.stringify('\uDC44')); +assertEquals('"\\udc45"', JSON.stringify('\uDC45')); +assertEquals('"\\udc46"', JSON.stringify('\uDC46')); +assertEquals('"\\udc47"', JSON.stringify('\uDC47')); +assertEquals('"\\udc48"', JSON.stringify('\uDC48')); +assertEquals('"\\udc49"', JSON.stringify('\uDC49')); +assertEquals('"\\udc4a"', JSON.stringify('\uDC4A')); +assertEquals('"\\udc4b"', JSON.stringify('\uDC4B')); +assertEquals('"\\udc4c"', JSON.stringify('\uDC4C')); +assertEquals('"\\udc4d"', JSON.stringify('\uDC4D')); +assertEquals('"\\udc4e"', JSON.stringify('\uDC4E')); +assertEquals('"\\udc4f"', JSON.stringify('\uDC4F')); +assertEquals('"\\udc50"', JSON.stringify('\uDC50')); +assertEquals('"\\udc51"', JSON.stringify('\uDC51')); +assertEquals('"\\udc52"', JSON.stringify('\uDC52')); +assertEquals('"\\udc53"', JSON.stringify('\uDC53')); +assertEquals('"\\udc54"', JSON.stringify('\uDC54')); +assertEquals('"\\udc55"', JSON.stringify('\uDC55')); +assertEquals('"\\udc56"', JSON.stringify('\uDC56')); +assertEquals('"\\udc57"', JSON.stringify('\uDC57')); +assertEquals('"\\udc58"', JSON.stringify('\uDC58')); +assertEquals('"\\udc59"', JSON.stringify('\uDC59')); +assertEquals('"\\udc5a"', JSON.stringify('\uDC5A')); +assertEquals('"\\udc5b"', JSON.stringify('\uDC5B')); +assertEquals('"\\udc5c"', JSON.stringify('\uDC5C')); +assertEquals('"\\udc5d"', JSON.stringify('\uDC5D')); +assertEquals('"\\udc5e"', JSON.stringify('\uDC5E')); +assertEquals('"\\udc5f"', JSON.stringify('\uDC5F')); +assertEquals('"\\udc60"', JSON.stringify('\uDC60')); +assertEquals('"\\udc61"', JSON.stringify('\uDC61')); +assertEquals('"\\udc62"', JSON.stringify('\uDC62')); +assertEquals('"\\udc63"', JSON.stringify('\uDC63')); +assertEquals('"\\udc64"', JSON.stringify('\uDC64')); +assertEquals('"\\udc65"', JSON.stringify('\uDC65')); +assertEquals('"\\udc66"', JSON.stringify('\uDC66')); +assertEquals('"\\udc67"', JSON.stringify('\uDC67')); +assertEquals('"\\udc68"', JSON.stringify('\uDC68')); +assertEquals('"\\udc69"', JSON.stringify('\uDC69')); +assertEquals('"\\udc6a"', JSON.stringify('\uDC6A')); +assertEquals('"\\udc6b"', JSON.stringify('\uDC6B')); +assertEquals('"\\udc6c"', JSON.stringify('\uDC6C')); +assertEquals('"\\udc6d"', JSON.stringify('\uDC6D')); +assertEquals('"\\udc6e"', JSON.stringify('\uDC6E')); +assertEquals('"\\udc6f"', JSON.stringify('\uDC6F')); +assertEquals('"\\udc70"', JSON.stringify('\uDC70')); +assertEquals('"\\udc71"', JSON.stringify('\uDC71')); +assertEquals('"\\udc72"', JSON.stringify('\uDC72')); +assertEquals('"\\udc73"', JSON.stringify('\uDC73')); +assertEquals('"\\udc74"', JSON.stringify('\uDC74')); +assertEquals('"\\udc75"', JSON.stringify('\uDC75')); +assertEquals('"\\udc76"', JSON.stringify('\uDC76')); +assertEquals('"\\udc77"', JSON.stringify('\uDC77')); +assertEquals('"\\udc78"', JSON.stringify('\uDC78')); +assertEquals('"\\udc79"', JSON.stringify('\uDC79')); +assertEquals('"\\udc7a"', JSON.stringify('\uDC7A')); +assertEquals('"\\udc7b"', JSON.stringify('\uDC7B')); +assertEquals('"\\udc7c"', JSON.stringify('\uDC7C')); +assertEquals('"\\udc7d"', JSON.stringify('\uDC7D')); +assertEquals('"\\udc7e"', JSON.stringify('\uDC7E')); +assertEquals('"\\udc7f"', JSON.stringify('\uDC7F')); +assertEquals('"\\udc80"', JSON.stringify('\uDC80')); +assertEquals('"\\udc81"', JSON.stringify('\uDC81')); +assertEquals('"\\udc82"', JSON.stringify('\uDC82')); +assertEquals('"\\udc83"', JSON.stringify('\uDC83')); +assertEquals('"\\udc84"', JSON.stringify('\uDC84')); +assertEquals('"\\udc85"', JSON.stringify('\uDC85')); +assertEquals('"\\udc86"', JSON.stringify('\uDC86')); +assertEquals('"\\udc87"', JSON.stringify('\uDC87')); +assertEquals('"\\udc88"', JSON.stringify('\uDC88')); +assertEquals('"\\udc89"', JSON.stringify('\uDC89')); +assertEquals('"\\udc8a"', JSON.stringify('\uDC8A')); +assertEquals('"\\udc8b"', JSON.stringify('\uDC8B')); +assertEquals('"\\udc8c"', JSON.stringify('\uDC8C')); +assertEquals('"\\udc8d"', JSON.stringify('\uDC8D')); +assertEquals('"\\udc8e"', JSON.stringify('\uDC8E')); +assertEquals('"\\udc8f"', JSON.stringify('\uDC8F')); +assertEquals('"\\udc90"', JSON.stringify('\uDC90')); +assertEquals('"\\udc91"', JSON.stringify('\uDC91')); +assertEquals('"\\udc92"', JSON.stringify('\uDC92')); +assertEquals('"\\udc93"', JSON.stringify('\uDC93')); +assertEquals('"\\udc94"', JSON.stringify('\uDC94')); +assertEquals('"\\udc95"', JSON.stringify('\uDC95')); +assertEquals('"\\udc96"', JSON.stringify('\uDC96')); +assertEquals('"\\udc97"', JSON.stringify('\uDC97')); +assertEquals('"\\udc98"', JSON.stringify('\uDC98')); +assertEquals('"\\udc99"', JSON.stringify('\uDC99')); +assertEquals('"\\udc9a"', JSON.stringify('\uDC9A')); +assertEquals('"\\udc9b"', JSON.stringify('\uDC9B')); +assertEquals('"\\udc9c"', JSON.stringify('\uDC9C')); +assertEquals('"\\udc9d"', JSON.stringify('\uDC9D')); +assertEquals('"\\udc9e"', JSON.stringify('\uDC9E')); +assertEquals('"\\udc9f"', JSON.stringify('\uDC9F')); +assertEquals('"\\udca0"', JSON.stringify('\uDCA0')); +assertEquals('"\\udca1"', JSON.stringify('\uDCA1')); +assertEquals('"\\udca2"', JSON.stringify('\uDCA2')); +assertEquals('"\\udca3"', JSON.stringify('\uDCA3')); +assertEquals('"\\udca4"', JSON.stringify('\uDCA4')); +assertEquals('"\\udca5"', JSON.stringify('\uDCA5')); +assertEquals('"\\udca6"', JSON.stringify('\uDCA6')); +assertEquals('"\\udca7"', JSON.stringify('\uDCA7')); +assertEquals('"\\udca8"', JSON.stringify('\uDCA8')); +assertEquals('"\\udca9"', JSON.stringify('\uDCA9')); +assertEquals('"\\udcaa"', JSON.stringify('\uDCAA')); +assertEquals('"\\udcab"', JSON.stringify('\uDCAB')); +assertEquals('"\\udcac"', JSON.stringify('\uDCAC')); +assertEquals('"\\udcad"', JSON.stringify('\uDCAD')); +assertEquals('"\\udcae"', JSON.stringify('\uDCAE')); +assertEquals('"\\udcaf"', JSON.stringify('\uDCAF')); +assertEquals('"\\udcb0"', JSON.stringify('\uDCB0')); +assertEquals('"\\udcb1"', JSON.stringify('\uDCB1')); +assertEquals('"\\udcb2"', JSON.stringify('\uDCB2')); +assertEquals('"\\udcb3"', JSON.stringify('\uDCB3')); +assertEquals('"\\udcb4"', JSON.stringify('\uDCB4')); +assertEquals('"\\udcb5"', JSON.stringify('\uDCB5')); +assertEquals('"\\udcb6"', JSON.stringify('\uDCB6')); +assertEquals('"\\udcb7"', JSON.stringify('\uDCB7')); +assertEquals('"\\udcb8"', JSON.stringify('\uDCB8')); +assertEquals('"\\udcb9"', JSON.stringify('\uDCB9')); +assertEquals('"\\udcba"', JSON.stringify('\uDCBA')); +assertEquals('"\\udcbb"', JSON.stringify('\uDCBB')); +assertEquals('"\\udcbc"', JSON.stringify('\uDCBC')); +assertEquals('"\\udcbd"', JSON.stringify('\uDCBD')); +assertEquals('"\\udcbe"', JSON.stringify('\uDCBE')); +assertEquals('"\\udcbf"', JSON.stringify('\uDCBF')); +assertEquals('"\\udcc0"', JSON.stringify('\uDCC0')); +assertEquals('"\\udcc1"', JSON.stringify('\uDCC1')); +assertEquals('"\\udcc2"', JSON.stringify('\uDCC2')); +assertEquals('"\\udcc3"', JSON.stringify('\uDCC3')); +assertEquals('"\\udcc4"', JSON.stringify('\uDCC4')); +assertEquals('"\\udcc5"', JSON.stringify('\uDCC5')); +assertEquals('"\\udcc6"', JSON.stringify('\uDCC6')); +assertEquals('"\\udcc7"', JSON.stringify('\uDCC7')); +assertEquals('"\\udcc8"', JSON.stringify('\uDCC8')); +assertEquals('"\\udcc9"', JSON.stringify('\uDCC9')); +assertEquals('"\\udcca"', JSON.stringify('\uDCCA')); +assertEquals('"\\udccb"', JSON.stringify('\uDCCB')); +assertEquals('"\\udccc"', JSON.stringify('\uDCCC')); +assertEquals('"\\udccd"', JSON.stringify('\uDCCD')); +assertEquals('"\\udcce"', JSON.stringify('\uDCCE')); +assertEquals('"\\udccf"', JSON.stringify('\uDCCF')); +assertEquals('"\\udcd0"', JSON.stringify('\uDCD0')); +assertEquals('"\\udcd1"', JSON.stringify('\uDCD1')); +assertEquals('"\\udcd2"', JSON.stringify('\uDCD2')); +assertEquals('"\\udcd3"', JSON.stringify('\uDCD3')); +assertEquals('"\\udcd4"', JSON.stringify('\uDCD4')); +assertEquals('"\\udcd5"', JSON.stringify('\uDCD5')); +assertEquals('"\\udcd6"', JSON.stringify('\uDCD6')); +assertEquals('"\\udcd7"', JSON.stringify('\uDCD7')); +assertEquals('"\\udcd8"', JSON.stringify('\uDCD8')); +assertEquals('"\\udcd9"', JSON.stringify('\uDCD9')); +assertEquals('"\\udcda"', JSON.stringify('\uDCDA')); +assertEquals('"\\udcdb"', JSON.stringify('\uDCDB')); +assertEquals('"\\udcdc"', JSON.stringify('\uDCDC')); +assertEquals('"\\udcdd"', JSON.stringify('\uDCDD')); +assertEquals('"\\udcde"', JSON.stringify('\uDCDE')); +assertEquals('"\\udcdf"', JSON.stringify('\uDCDF')); +assertEquals('"\\udce0"', JSON.stringify('\uDCE0')); +assertEquals('"\\udce1"', JSON.stringify('\uDCE1')); +assertEquals('"\\udce2"', JSON.stringify('\uDCE2')); +assertEquals('"\\udce3"', JSON.stringify('\uDCE3')); +assertEquals('"\\udce4"', JSON.stringify('\uDCE4')); +assertEquals('"\\udce5"', JSON.stringify('\uDCE5')); +assertEquals('"\\udce6"', JSON.stringify('\uDCE6')); +assertEquals('"\\udce7"', JSON.stringify('\uDCE7')); +assertEquals('"\\udce8"', JSON.stringify('\uDCE8')); +assertEquals('"\\udce9"', JSON.stringify('\uDCE9')); +assertEquals('"\\udcea"', JSON.stringify('\uDCEA')); +assertEquals('"\\udceb"', JSON.stringify('\uDCEB')); +assertEquals('"\\udcec"', JSON.stringify('\uDCEC')); +assertEquals('"\\udced"', JSON.stringify('\uDCED')); +assertEquals('"\\udcee"', JSON.stringify('\uDCEE')); +assertEquals('"\\udcef"', JSON.stringify('\uDCEF')); +assertEquals('"\\udcf0"', JSON.stringify('\uDCF0')); +assertEquals('"\\udcf1"', JSON.stringify('\uDCF1')); +assertEquals('"\\udcf2"', JSON.stringify('\uDCF2')); +assertEquals('"\\udcf3"', JSON.stringify('\uDCF3')); +assertEquals('"\\udcf4"', JSON.stringify('\uDCF4')); +assertEquals('"\\udcf5"', JSON.stringify('\uDCF5')); +assertEquals('"\\udcf6"', JSON.stringify('\uDCF6')); +assertEquals('"\\udcf7"', JSON.stringify('\uDCF7')); +assertEquals('"\\udcf8"', JSON.stringify('\uDCF8')); +assertEquals('"\\udcf9"', JSON.stringify('\uDCF9')); +assertEquals('"\\udcfa"', JSON.stringify('\uDCFA')); +assertEquals('"\\udcfb"', JSON.stringify('\uDCFB')); +assertEquals('"\\udcfc"', JSON.stringify('\uDCFC')); +assertEquals('"\\udcfd"', JSON.stringify('\uDCFD')); +assertEquals('"\\udcfe"', JSON.stringify('\uDCFE')); +assertEquals('"\\udcff"', JSON.stringify('\uDCFF')); +assertEquals('"\\udd00"', JSON.stringify('\uDD00')); +assertEquals('"\\udd01"', JSON.stringify('\uDD01')); +assertEquals('"\\udd02"', JSON.stringify('\uDD02')); +assertEquals('"\\udd03"', JSON.stringify('\uDD03')); +assertEquals('"\\udd04"', JSON.stringify('\uDD04')); +assertEquals('"\\udd05"', JSON.stringify('\uDD05')); +assertEquals('"\\udd06"', JSON.stringify('\uDD06')); +assertEquals('"\\udd07"', JSON.stringify('\uDD07')); +assertEquals('"\\udd08"', JSON.stringify('\uDD08')); +assertEquals('"\\udd09"', JSON.stringify('\uDD09')); +assertEquals('"\\udd0a"', JSON.stringify('\uDD0A')); +assertEquals('"\\udd0b"', JSON.stringify('\uDD0B')); +assertEquals('"\\udd0c"', JSON.stringify('\uDD0C')); +assertEquals('"\\udd0d"', JSON.stringify('\uDD0D')); +assertEquals('"\\udd0e"', JSON.stringify('\uDD0E')); +assertEquals('"\\udd0f"', JSON.stringify('\uDD0F')); +assertEquals('"\\udd10"', JSON.stringify('\uDD10')); +assertEquals('"\\udd11"', JSON.stringify('\uDD11')); +assertEquals('"\\udd12"', JSON.stringify('\uDD12')); +assertEquals('"\\udd13"', JSON.stringify('\uDD13')); +assertEquals('"\\udd14"', JSON.stringify('\uDD14')); +assertEquals('"\\udd15"', JSON.stringify('\uDD15')); +assertEquals('"\\udd16"', JSON.stringify('\uDD16')); +assertEquals('"\\udd17"', JSON.stringify('\uDD17')); +assertEquals('"\\udd18"', JSON.stringify('\uDD18')); +assertEquals('"\\udd19"', JSON.stringify('\uDD19')); +assertEquals('"\\udd1a"', JSON.stringify('\uDD1A')); +assertEquals('"\\udd1b"', JSON.stringify('\uDD1B')); +assertEquals('"\\udd1c"', JSON.stringify('\uDD1C')); +assertEquals('"\\udd1d"', JSON.stringify('\uDD1D')); +assertEquals('"\\udd1e"', JSON.stringify('\uDD1E')); +assertEquals('"\\udd1f"', JSON.stringify('\uDD1F')); +assertEquals('"\\udd20"', JSON.stringify('\uDD20')); +assertEquals('"\\udd21"', JSON.stringify('\uDD21')); +assertEquals('"\\udd22"', JSON.stringify('\uDD22')); +assertEquals('"\\udd23"', JSON.stringify('\uDD23')); +assertEquals('"\\udd24"', JSON.stringify('\uDD24')); +assertEquals('"\\udd25"', JSON.stringify('\uDD25')); +assertEquals('"\\udd26"', JSON.stringify('\uDD26')); +assertEquals('"\\udd27"', JSON.stringify('\uDD27')); +assertEquals('"\\udd28"', JSON.stringify('\uDD28')); +assertEquals('"\\udd29"', JSON.stringify('\uDD29')); +assertEquals('"\\udd2a"', JSON.stringify('\uDD2A')); +assertEquals('"\\udd2b"', JSON.stringify('\uDD2B')); +assertEquals('"\\udd2c"', JSON.stringify('\uDD2C')); +assertEquals('"\\udd2d"', JSON.stringify('\uDD2D')); +assertEquals('"\\udd2e"', JSON.stringify('\uDD2E')); +assertEquals('"\\udd2f"', JSON.stringify('\uDD2F')); +assertEquals('"\\udd30"', JSON.stringify('\uDD30')); +assertEquals('"\\udd31"', JSON.stringify('\uDD31')); +assertEquals('"\\udd32"', JSON.stringify('\uDD32')); +assertEquals('"\\udd33"', JSON.stringify('\uDD33')); +assertEquals('"\\udd34"', JSON.stringify('\uDD34')); +assertEquals('"\\udd35"', JSON.stringify('\uDD35')); +assertEquals('"\\udd36"', JSON.stringify('\uDD36')); +assertEquals('"\\udd37"', JSON.stringify('\uDD37')); +assertEquals('"\\udd38"', JSON.stringify('\uDD38')); +assertEquals('"\\udd39"', JSON.stringify('\uDD39')); +assertEquals('"\\udd3a"', JSON.stringify('\uDD3A')); +assertEquals('"\\udd3b"', JSON.stringify('\uDD3B')); +assertEquals('"\\udd3c"', JSON.stringify('\uDD3C')); +assertEquals('"\\udd3d"', JSON.stringify('\uDD3D')); +assertEquals('"\\udd3e"', JSON.stringify('\uDD3E')); +assertEquals('"\\udd3f"', JSON.stringify('\uDD3F')); +assertEquals('"\\udd40"', JSON.stringify('\uDD40')); +assertEquals('"\\udd41"', JSON.stringify('\uDD41')); +assertEquals('"\\udd42"', JSON.stringify('\uDD42')); +assertEquals('"\\udd43"', JSON.stringify('\uDD43')); +assertEquals('"\\udd44"', JSON.stringify('\uDD44')); +assertEquals('"\\udd45"', JSON.stringify('\uDD45')); +assertEquals('"\\udd46"', JSON.stringify('\uDD46')); +assertEquals('"\\udd47"', JSON.stringify('\uDD47')); +assertEquals('"\\udd48"', JSON.stringify('\uDD48')); +assertEquals('"\\udd49"', JSON.stringify('\uDD49')); +assertEquals('"\\udd4a"', JSON.stringify('\uDD4A')); +assertEquals('"\\udd4b"', JSON.stringify('\uDD4B')); +assertEquals('"\\udd4c"', JSON.stringify('\uDD4C')); +assertEquals('"\\udd4d"', JSON.stringify('\uDD4D')); +assertEquals('"\\udd4e"', JSON.stringify('\uDD4E')); +assertEquals('"\\udd4f"', JSON.stringify('\uDD4F')); +assertEquals('"\\udd50"', JSON.stringify('\uDD50')); +assertEquals('"\\udd51"', JSON.stringify('\uDD51')); +assertEquals('"\\udd52"', JSON.stringify('\uDD52')); +assertEquals('"\\udd53"', JSON.stringify('\uDD53')); +assertEquals('"\\udd54"', JSON.stringify('\uDD54')); +assertEquals('"\\udd55"', JSON.stringify('\uDD55')); +assertEquals('"\\udd56"', JSON.stringify('\uDD56')); +assertEquals('"\\udd57"', JSON.stringify('\uDD57')); +assertEquals('"\\udd58"', JSON.stringify('\uDD58')); +assertEquals('"\\udd59"', JSON.stringify('\uDD59')); +assertEquals('"\\udd5a"', JSON.stringify('\uDD5A')); +assertEquals('"\\udd5b"', JSON.stringify('\uDD5B')); +assertEquals('"\\udd5c"', JSON.stringify('\uDD5C')); +assertEquals('"\\udd5d"', JSON.stringify('\uDD5D')); +assertEquals('"\\udd5e"', JSON.stringify('\uDD5E')); +assertEquals('"\\udd5f"', JSON.stringify('\uDD5F')); +assertEquals('"\\udd60"', JSON.stringify('\uDD60')); +assertEquals('"\\udd61"', JSON.stringify('\uDD61')); +assertEquals('"\\udd62"', JSON.stringify('\uDD62')); +assertEquals('"\\udd63"', JSON.stringify('\uDD63')); +assertEquals('"\\udd64"', JSON.stringify('\uDD64')); +assertEquals('"\\udd65"', JSON.stringify('\uDD65')); +assertEquals('"\\udd66"', JSON.stringify('\uDD66')); +assertEquals('"\\udd67"', JSON.stringify('\uDD67')); +assertEquals('"\\udd68"', JSON.stringify('\uDD68')); +assertEquals('"\\udd69"', JSON.stringify('\uDD69')); +assertEquals('"\\udd6a"', JSON.stringify('\uDD6A')); +assertEquals('"\\udd6b"', JSON.stringify('\uDD6B')); +assertEquals('"\\udd6c"', JSON.stringify('\uDD6C')); +assertEquals('"\\udd6d"', JSON.stringify('\uDD6D')); +assertEquals('"\\udd6e"', JSON.stringify('\uDD6E')); +assertEquals('"\\udd6f"', JSON.stringify('\uDD6F')); +assertEquals('"\\udd70"', JSON.stringify('\uDD70')); +assertEquals('"\\udd71"', JSON.stringify('\uDD71')); +assertEquals('"\\udd72"', JSON.stringify('\uDD72')); +assertEquals('"\\udd73"', JSON.stringify('\uDD73')); +assertEquals('"\\udd74"', JSON.stringify('\uDD74')); +assertEquals('"\\udd75"', JSON.stringify('\uDD75')); +assertEquals('"\\udd76"', JSON.stringify('\uDD76')); +assertEquals('"\\udd77"', JSON.stringify('\uDD77')); +assertEquals('"\\udd78"', JSON.stringify('\uDD78')); +assertEquals('"\\udd79"', JSON.stringify('\uDD79')); +assertEquals('"\\udd7a"', JSON.stringify('\uDD7A')); +assertEquals('"\\udd7b"', JSON.stringify('\uDD7B')); +assertEquals('"\\udd7c"', JSON.stringify('\uDD7C')); +assertEquals('"\\udd7d"', JSON.stringify('\uDD7D')); +assertEquals('"\\udd7e"', JSON.stringify('\uDD7E')); +assertEquals('"\\udd7f"', JSON.stringify('\uDD7F')); +assertEquals('"\\udd80"', JSON.stringify('\uDD80')); +assertEquals('"\\udd81"', JSON.stringify('\uDD81')); +assertEquals('"\\udd82"', JSON.stringify('\uDD82')); +assertEquals('"\\udd83"', JSON.stringify('\uDD83')); +assertEquals('"\\udd84"', JSON.stringify('\uDD84')); +assertEquals('"\\udd85"', JSON.stringify('\uDD85')); +assertEquals('"\\udd86"', JSON.stringify('\uDD86')); +assertEquals('"\\udd87"', JSON.stringify('\uDD87')); +assertEquals('"\\udd88"', JSON.stringify('\uDD88')); +assertEquals('"\\udd89"', JSON.stringify('\uDD89')); +assertEquals('"\\udd8a"', JSON.stringify('\uDD8A')); +assertEquals('"\\udd8b"', JSON.stringify('\uDD8B')); +assertEquals('"\\udd8c"', JSON.stringify('\uDD8C')); +assertEquals('"\\udd8d"', JSON.stringify('\uDD8D')); +assertEquals('"\\udd8e"', JSON.stringify('\uDD8E')); +assertEquals('"\\udd8f"', JSON.stringify('\uDD8F')); +assertEquals('"\\udd90"', JSON.stringify('\uDD90')); +assertEquals('"\\udd91"', JSON.stringify('\uDD91')); +assertEquals('"\\udd92"', JSON.stringify('\uDD92')); +assertEquals('"\\udd93"', JSON.stringify('\uDD93')); +assertEquals('"\\udd94"', JSON.stringify('\uDD94')); +assertEquals('"\\udd95"', JSON.stringify('\uDD95')); +assertEquals('"\\udd96"', JSON.stringify('\uDD96')); +assertEquals('"\\udd97"', JSON.stringify('\uDD97')); +assertEquals('"\\udd98"', JSON.stringify('\uDD98')); +assertEquals('"\\udd99"', JSON.stringify('\uDD99')); +assertEquals('"\\udd9a"', JSON.stringify('\uDD9A')); +assertEquals('"\\udd9b"', JSON.stringify('\uDD9B')); +assertEquals('"\\udd9c"', JSON.stringify('\uDD9C')); +assertEquals('"\\udd9d"', JSON.stringify('\uDD9D')); +assertEquals('"\\udd9e"', JSON.stringify('\uDD9E')); +assertEquals('"\\udd9f"', JSON.stringify('\uDD9F')); +assertEquals('"\\udda0"', JSON.stringify('\uDDA0')); +assertEquals('"\\udda1"', JSON.stringify('\uDDA1')); +assertEquals('"\\udda2"', JSON.stringify('\uDDA2')); +assertEquals('"\\udda3"', JSON.stringify('\uDDA3')); +assertEquals('"\\udda4"', JSON.stringify('\uDDA4')); +assertEquals('"\\udda5"', JSON.stringify('\uDDA5')); +assertEquals('"\\udda6"', JSON.stringify('\uDDA6')); +assertEquals('"\\udda7"', JSON.stringify('\uDDA7')); +assertEquals('"\\udda8"', JSON.stringify('\uDDA8')); +assertEquals('"\\udda9"', JSON.stringify('\uDDA9')); +assertEquals('"\\uddaa"', JSON.stringify('\uDDAA')); +assertEquals('"\\uddab"', JSON.stringify('\uDDAB')); +assertEquals('"\\uddac"', JSON.stringify('\uDDAC')); +assertEquals('"\\uddad"', JSON.stringify('\uDDAD')); +assertEquals('"\\uddae"', JSON.stringify('\uDDAE')); +assertEquals('"\\uddaf"', JSON.stringify('\uDDAF')); +assertEquals('"\\uddb0"', JSON.stringify('\uDDB0')); +assertEquals('"\\uddb1"', JSON.stringify('\uDDB1')); +assertEquals('"\\uddb2"', JSON.stringify('\uDDB2')); +assertEquals('"\\uddb3"', JSON.stringify('\uDDB3')); +assertEquals('"\\uddb4"', JSON.stringify('\uDDB4')); +assertEquals('"\\uddb5"', JSON.stringify('\uDDB5')); +assertEquals('"\\uddb6"', JSON.stringify('\uDDB6')); +assertEquals('"\\uddb7"', JSON.stringify('\uDDB7')); +assertEquals('"\\uddb8"', JSON.stringify('\uDDB8')); +assertEquals('"\\uddb9"', JSON.stringify('\uDDB9')); +assertEquals('"\\uddba"', JSON.stringify('\uDDBA')); +assertEquals('"\\uddbb"', JSON.stringify('\uDDBB')); +assertEquals('"\\uddbc"', JSON.stringify('\uDDBC')); +assertEquals('"\\uddbd"', JSON.stringify('\uDDBD')); +assertEquals('"\\uddbe"', JSON.stringify('\uDDBE')); +assertEquals('"\\uddbf"', JSON.stringify('\uDDBF')); +assertEquals('"\\uddc0"', JSON.stringify('\uDDC0')); +assertEquals('"\\uddc1"', JSON.stringify('\uDDC1')); +assertEquals('"\\uddc2"', JSON.stringify('\uDDC2')); +assertEquals('"\\uddc3"', JSON.stringify('\uDDC3')); +assertEquals('"\\uddc4"', JSON.stringify('\uDDC4')); +assertEquals('"\\uddc5"', JSON.stringify('\uDDC5')); +assertEquals('"\\uddc6"', JSON.stringify('\uDDC6')); +assertEquals('"\\uddc7"', JSON.stringify('\uDDC7')); +assertEquals('"\\uddc8"', JSON.stringify('\uDDC8')); +assertEquals('"\\uddc9"', JSON.stringify('\uDDC9')); +assertEquals('"\\uddca"', JSON.stringify('\uDDCA')); +assertEquals('"\\uddcb"', JSON.stringify('\uDDCB')); +assertEquals('"\\uddcc"', JSON.stringify('\uDDCC')); +assertEquals('"\\uddcd"', JSON.stringify('\uDDCD')); +assertEquals('"\\uddce"', JSON.stringify('\uDDCE')); +assertEquals('"\\uddcf"', JSON.stringify('\uDDCF')); +assertEquals('"\\uddd0"', JSON.stringify('\uDDD0')); +assertEquals('"\\uddd1"', JSON.stringify('\uDDD1')); +assertEquals('"\\uddd2"', JSON.stringify('\uDDD2')); +assertEquals('"\\uddd3"', JSON.stringify('\uDDD3')); +assertEquals('"\\uddd4"', JSON.stringify('\uDDD4')); +assertEquals('"\\uddd5"', JSON.stringify('\uDDD5')); +assertEquals('"\\uddd6"', JSON.stringify('\uDDD6')); +assertEquals('"\\uddd7"', JSON.stringify('\uDDD7')); +assertEquals('"\\uddd8"', JSON.stringify('\uDDD8')); +assertEquals('"\\uddd9"', JSON.stringify('\uDDD9')); +assertEquals('"\\uddda"', JSON.stringify('\uDDDA')); +assertEquals('"\\udddb"', JSON.stringify('\uDDDB')); +assertEquals('"\\udddc"', JSON.stringify('\uDDDC')); +assertEquals('"\\udddd"', JSON.stringify('\uDDDD')); +assertEquals('"\\uddde"', JSON.stringify('\uDDDE')); +assertEquals('"\\udddf"', JSON.stringify('\uDDDF')); +assertEquals('"\\udde0"', JSON.stringify('\uDDE0')); +assertEquals('"\\udde1"', JSON.stringify('\uDDE1')); +assertEquals('"\\udde2"', JSON.stringify('\uDDE2')); +assertEquals('"\\udde3"', JSON.stringify('\uDDE3')); +assertEquals('"\\udde4"', JSON.stringify('\uDDE4')); +assertEquals('"\\udde5"', JSON.stringify('\uDDE5')); +assertEquals('"\\udde6"', JSON.stringify('\uDDE6')); +assertEquals('"\\udde7"', JSON.stringify('\uDDE7')); +assertEquals('"\\udde8"', JSON.stringify('\uDDE8')); +assertEquals('"\\udde9"', JSON.stringify('\uDDE9')); +assertEquals('"\\uddea"', JSON.stringify('\uDDEA')); +assertEquals('"\\uddeb"', JSON.stringify('\uDDEB')); +assertEquals('"\\uddec"', JSON.stringify('\uDDEC')); +assertEquals('"\\udded"', JSON.stringify('\uDDED')); +assertEquals('"\\uddee"', JSON.stringify('\uDDEE')); +assertEquals('"\\uddef"', JSON.stringify('\uDDEF')); +assertEquals('"\\uddf0"', JSON.stringify('\uDDF0')); +assertEquals('"\\uddf1"', JSON.stringify('\uDDF1')); +assertEquals('"\\uddf2"', JSON.stringify('\uDDF2')); +assertEquals('"\\uddf3"', JSON.stringify('\uDDF3')); +assertEquals('"\\uddf4"', JSON.stringify('\uDDF4')); +assertEquals('"\\uddf5"', JSON.stringify('\uDDF5')); +assertEquals('"\\uddf6"', JSON.stringify('\uDDF6')); +assertEquals('"\\uddf7"', JSON.stringify('\uDDF7')); +assertEquals('"\\uddf8"', JSON.stringify('\uDDF8')); +assertEquals('"\\uddf9"', JSON.stringify('\uDDF9')); +assertEquals('"\\uddfa"', JSON.stringify('\uDDFA')); +assertEquals('"\\uddfb"', JSON.stringify('\uDDFB')); +assertEquals('"\\uddfc"', JSON.stringify('\uDDFC')); +assertEquals('"\\uddfd"', JSON.stringify('\uDDFD')); +assertEquals('"\\uddfe"', JSON.stringify('\uDDFE')); +assertEquals('"\\uddff"', JSON.stringify('\uDDFF')); +assertEquals('"\\ude00"', JSON.stringify('\uDE00')); +assertEquals('"\\ude01"', JSON.stringify('\uDE01')); +assertEquals('"\\ude02"', JSON.stringify('\uDE02')); +assertEquals('"\\ude03"', JSON.stringify('\uDE03')); +assertEquals('"\\ude04"', JSON.stringify('\uDE04')); +assertEquals('"\\ude05"', JSON.stringify('\uDE05')); +assertEquals('"\\ude06"', JSON.stringify('\uDE06')); +assertEquals('"\\ude07"', JSON.stringify('\uDE07')); +assertEquals('"\\ude08"', JSON.stringify('\uDE08')); +assertEquals('"\\ude09"', JSON.stringify('\uDE09')); +assertEquals('"\\ude0a"', JSON.stringify('\uDE0A')); +assertEquals('"\\ude0b"', JSON.stringify('\uDE0B')); +assertEquals('"\\ude0c"', JSON.stringify('\uDE0C')); +assertEquals('"\\ude0d"', JSON.stringify('\uDE0D')); +assertEquals('"\\ude0e"', JSON.stringify('\uDE0E')); +assertEquals('"\\ude0f"', JSON.stringify('\uDE0F')); +assertEquals('"\\ude10"', JSON.stringify('\uDE10')); +assertEquals('"\\ude11"', JSON.stringify('\uDE11')); +assertEquals('"\\ude12"', JSON.stringify('\uDE12')); +assertEquals('"\\ude13"', JSON.stringify('\uDE13')); +assertEquals('"\\ude14"', JSON.stringify('\uDE14')); +assertEquals('"\\ude15"', JSON.stringify('\uDE15')); +assertEquals('"\\ude16"', JSON.stringify('\uDE16')); +assertEquals('"\\ude17"', JSON.stringify('\uDE17')); +assertEquals('"\\ude18"', JSON.stringify('\uDE18')); +assertEquals('"\\ude19"', JSON.stringify('\uDE19')); +assertEquals('"\\ude1a"', JSON.stringify('\uDE1A')); +assertEquals('"\\ude1b"', JSON.stringify('\uDE1B')); +assertEquals('"\\ude1c"', JSON.stringify('\uDE1C')); +assertEquals('"\\ude1d"', JSON.stringify('\uDE1D')); +assertEquals('"\\ude1e"', JSON.stringify('\uDE1E')); +assertEquals('"\\ude1f"', JSON.stringify('\uDE1F')); +assertEquals('"\\ude20"', JSON.stringify('\uDE20')); +assertEquals('"\\ude21"', JSON.stringify('\uDE21')); +assertEquals('"\\ude22"', JSON.stringify('\uDE22')); +assertEquals('"\\ude23"', JSON.stringify('\uDE23')); +assertEquals('"\\ude24"', JSON.stringify('\uDE24')); +assertEquals('"\\ude25"', JSON.stringify('\uDE25')); +assertEquals('"\\ude26"', JSON.stringify('\uDE26')); +assertEquals('"\\ude27"', JSON.stringify('\uDE27')); +assertEquals('"\\ude28"', JSON.stringify('\uDE28')); +assertEquals('"\\ude29"', JSON.stringify('\uDE29')); +assertEquals('"\\ude2a"', JSON.stringify('\uDE2A')); +assertEquals('"\\ude2b"', JSON.stringify('\uDE2B')); +assertEquals('"\\ude2c"', JSON.stringify('\uDE2C')); +assertEquals('"\\ude2d"', JSON.stringify('\uDE2D')); +assertEquals('"\\ude2e"', JSON.stringify('\uDE2E')); +assertEquals('"\\ude2f"', JSON.stringify('\uDE2F')); +assertEquals('"\\ude30"', JSON.stringify('\uDE30')); +assertEquals('"\\ude31"', JSON.stringify('\uDE31')); +assertEquals('"\\ude32"', JSON.stringify('\uDE32')); +assertEquals('"\\ude33"', JSON.stringify('\uDE33')); +assertEquals('"\\ude34"', JSON.stringify('\uDE34')); +assertEquals('"\\ude35"', JSON.stringify('\uDE35')); +assertEquals('"\\ude36"', JSON.stringify('\uDE36')); +assertEquals('"\\ude37"', JSON.stringify('\uDE37')); +assertEquals('"\\ude38"', JSON.stringify('\uDE38')); +assertEquals('"\\ude39"', JSON.stringify('\uDE39')); +assertEquals('"\\ude3a"', JSON.stringify('\uDE3A')); +assertEquals('"\\ude3b"', JSON.stringify('\uDE3B')); +assertEquals('"\\ude3c"', JSON.stringify('\uDE3C')); +assertEquals('"\\ude3d"', JSON.stringify('\uDE3D')); +assertEquals('"\\ude3e"', JSON.stringify('\uDE3E')); +assertEquals('"\\ude3f"', JSON.stringify('\uDE3F')); +assertEquals('"\\ude40"', JSON.stringify('\uDE40')); +assertEquals('"\\ude41"', JSON.stringify('\uDE41')); +assertEquals('"\\ude42"', JSON.stringify('\uDE42')); +assertEquals('"\\ude43"', JSON.stringify('\uDE43')); +assertEquals('"\\ude44"', JSON.stringify('\uDE44')); +assertEquals('"\\ude45"', JSON.stringify('\uDE45')); +assertEquals('"\\ude46"', JSON.stringify('\uDE46')); +assertEquals('"\\ude47"', JSON.stringify('\uDE47')); +assertEquals('"\\ude48"', JSON.stringify('\uDE48')); +assertEquals('"\\ude49"', JSON.stringify('\uDE49')); +assertEquals('"\\ude4a"', JSON.stringify('\uDE4A')); +assertEquals('"\\ude4b"', JSON.stringify('\uDE4B')); +assertEquals('"\\ude4c"', JSON.stringify('\uDE4C')); +assertEquals('"\\ude4d"', JSON.stringify('\uDE4D')); +assertEquals('"\\ude4e"', JSON.stringify('\uDE4E')); +assertEquals('"\\ude4f"', JSON.stringify('\uDE4F')); +assertEquals('"\\ude50"', JSON.stringify('\uDE50')); +assertEquals('"\\ude51"', JSON.stringify('\uDE51')); +assertEquals('"\\ude52"', JSON.stringify('\uDE52')); +assertEquals('"\\ude53"', JSON.stringify('\uDE53')); +assertEquals('"\\ude54"', JSON.stringify('\uDE54')); +assertEquals('"\\ude55"', JSON.stringify('\uDE55')); +assertEquals('"\\ude56"', JSON.stringify('\uDE56')); +assertEquals('"\\ude57"', JSON.stringify('\uDE57')); +assertEquals('"\\ude58"', JSON.stringify('\uDE58')); +assertEquals('"\\ude59"', JSON.stringify('\uDE59')); +assertEquals('"\\ude5a"', JSON.stringify('\uDE5A')); +assertEquals('"\\ude5b"', JSON.stringify('\uDE5B')); +assertEquals('"\\ude5c"', JSON.stringify('\uDE5C')); +assertEquals('"\\ude5d"', JSON.stringify('\uDE5D')); +assertEquals('"\\ude5e"', JSON.stringify('\uDE5E')); +assertEquals('"\\ude5f"', JSON.stringify('\uDE5F')); +assertEquals('"\\ude60"', JSON.stringify('\uDE60')); +assertEquals('"\\ude61"', JSON.stringify('\uDE61')); +assertEquals('"\\ude62"', JSON.stringify('\uDE62')); +assertEquals('"\\ude63"', JSON.stringify('\uDE63')); +assertEquals('"\\ude64"', JSON.stringify('\uDE64')); +assertEquals('"\\ude65"', JSON.stringify('\uDE65')); +assertEquals('"\\ude66"', JSON.stringify('\uDE66')); +assertEquals('"\\ude67"', JSON.stringify('\uDE67')); +assertEquals('"\\ude68"', JSON.stringify('\uDE68')); +assertEquals('"\\ude69"', JSON.stringify('\uDE69')); +assertEquals('"\\ude6a"', JSON.stringify('\uDE6A')); +assertEquals('"\\ude6b"', JSON.stringify('\uDE6B')); +assertEquals('"\\ude6c"', JSON.stringify('\uDE6C')); +assertEquals('"\\ude6d"', JSON.stringify('\uDE6D')); +assertEquals('"\\ude6e"', JSON.stringify('\uDE6E')); +assertEquals('"\\ude6f"', JSON.stringify('\uDE6F')); +assertEquals('"\\ude70"', JSON.stringify('\uDE70')); +assertEquals('"\\ude71"', JSON.stringify('\uDE71')); +assertEquals('"\\ude72"', JSON.stringify('\uDE72')); +assertEquals('"\\ude73"', JSON.stringify('\uDE73')); +assertEquals('"\\ude74"', JSON.stringify('\uDE74')); +assertEquals('"\\ude75"', JSON.stringify('\uDE75')); +assertEquals('"\\ude76"', JSON.stringify('\uDE76')); +assertEquals('"\\ude77"', JSON.stringify('\uDE77')); +assertEquals('"\\ude78"', JSON.stringify('\uDE78')); +assertEquals('"\\ude79"', JSON.stringify('\uDE79')); +assertEquals('"\\ude7a"', JSON.stringify('\uDE7A')); +assertEquals('"\\ude7b"', JSON.stringify('\uDE7B')); +assertEquals('"\\ude7c"', JSON.stringify('\uDE7C')); +assertEquals('"\\ude7d"', JSON.stringify('\uDE7D')); +assertEquals('"\\ude7e"', JSON.stringify('\uDE7E')); +assertEquals('"\\ude7f"', JSON.stringify('\uDE7F')); +assertEquals('"\\ude80"', JSON.stringify('\uDE80')); +assertEquals('"\\ude81"', JSON.stringify('\uDE81')); +assertEquals('"\\ude82"', JSON.stringify('\uDE82')); +assertEquals('"\\ude83"', JSON.stringify('\uDE83')); +assertEquals('"\\ude84"', JSON.stringify('\uDE84')); +assertEquals('"\\ude85"', JSON.stringify('\uDE85')); +assertEquals('"\\ude86"', JSON.stringify('\uDE86')); +assertEquals('"\\ude87"', JSON.stringify('\uDE87')); +assertEquals('"\\ude88"', JSON.stringify('\uDE88')); +assertEquals('"\\ude89"', JSON.stringify('\uDE89')); +assertEquals('"\\ude8a"', JSON.stringify('\uDE8A')); +assertEquals('"\\ude8b"', JSON.stringify('\uDE8B')); +assertEquals('"\\ude8c"', JSON.stringify('\uDE8C')); +assertEquals('"\\ude8d"', JSON.stringify('\uDE8D')); +assertEquals('"\\ude8e"', JSON.stringify('\uDE8E')); +assertEquals('"\\ude8f"', JSON.stringify('\uDE8F')); +assertEquals('"\\ude90"', JSON.stringify('\uDE90')); +assertEquals('"\\ude91"', JSON.stringify('\uDE91')); +assertEquals('"\\ude92"', JSON.stringify('\uDE92')); +assertEquals('"\\ude93"', JSON.stringify('\uDE93')); +assertEquals('"\\ude94"', JSON.stringify('\uDE94')); +assertEquals('"\\ude95"', JSON.stringify('\uDE95')); +assertEquals('"\\ude96"', JSON.stringify('\uDE96')); +assertEquals('"\\ude97"', JSON.stringify('\uDE97')); +assertEquals('"\\ude98"', JSON.stringify('\uDE98')); +assertEquals('"\\ude99"', JSON.stringify('\uDE99')); +assertEquals('"\\ude9a"', JSON.stringify('\uDE9A')); +assertEquals('"\\ude9b"', JSON.stringify('\uDE9B')); +assertEquals('"\\ude9c"', JSON.stringify('\uDE9C')); +assertEquals('"\\ude9d"', JSON.stringify('\uDE9D')); +assertEquals('"\\ude9e"', JSON.stringify('\uDE9E')); +assertEquals('"\\ude9f"', JSON.stringify('\uDE9F')); +assertEquals('"\\udea0"', JSON.stringify('\uDEA0')); +assertEquals('"\\udea1"', JSON.stringify('\uDEA1')); +assertEquals('"\\udea2"', JSON.stringify('\uDEA2')); +assertEquals('"\\udea3"', JSON.stringify('\uDEA3')); +assertEquals('"\\udea4"', JSON.stringify('\uDEA4')); +assertEquals('"\\udea5"', JSON.stringify('\uDEA5')); +assertEquals('"\\udea6"', JSON.stringify('\uDEA6')); +assertEquals('"\\udea7"', JSON.stringify('\uDEA7')); +assertEquals('"\\udea8"', JSON.stringify('\uDEA8')); +assertEquals('"\\udea9"', JSON.stringify('\uDEA9')); +assertEquals('"\\udeaa"', JSON.stringify('\uDEAA')); +assertEquals('"\\udeab"', JSON.stringify('\uDEAB')); +assertEquals('"\\udeac"', JSON.stringify('\uDEAC')); +assertEquals('"\\udead"', JSON.stringify('\uDEAD')); +assertEquals('"\\udeae"', JSON.stringify('\uDEAE')); +assertEquals('"\\udeaf"', JSON.stringify('\uDEAF')); +assertEquals('"\\udeb0"', JSON.stringify('\uDEB0')); +assertEquals('"\\udeb1"', JSON.stringify('\uDEB1')); +assertEquals('"\\udeb2"', JSON.stringify('\uDEB2')); +assertEquals('"\\udeb3"', JSON.stringify('\uDEB3')); +assertEquals('"\\udeb4"', JSON.stringify('\uDEB4')); +assertEquals('"\\udeb5"', JSON.stringify('\uDEB5')); +assertEquals('"\\udeb6"', JSON.stringify('\uDEB6')); +assertEquals('"\\udeb7"', JSON.stringify('\uDEB7')); +assertEquals('"\\udeb8"', JSON.stringify('\uDEB8')); +assertEquals('"\\udeb9"', JSON.stringify('\uDEB9')); +assertEquals('"\\udeba"', JSON.stringify('\uDEBA')); +assertEquals('"\\udebb"', JSON.stringify('\uDEBB')); +assertEquals('"\\udebc"', JSON.stringify('\uDEBC')); +assertEquals('"\\udebd"', JSON.stringify('\uDEBD')); +assertEquals('"\\udebe"', JSON.stringify('\uDEBE')); +assertEquals('"\\udebf"', JSON.stringify('\uDEBF')); +assertEquals('"\\udec0"', JSON.stringify('\uDEC0')); +assertEquals('"\\udec1"', JSON.stringify('\uDEC1')); +assertEquals('"\\udec2"', JSON.stringify('\uDEC2')); +assertEquals('"\\udec3"', JSON.stringify('\uDEC3')); +assertEquals('"\\udec4"', JSON.stringify('\uDEC4')); +assertEquals('"\\udec5"', JSON.stringify('\uDEC5')); +assertEquals('"\\udec6"', JSON.stringify('\uDEC6')); +assertEquals('"\\udec7"', JSON.stringify('\uDEC7')); +assertEquals('"\\udec8"', JSON.stringify('\uDEC8')); +assertEquals('"\\udec9"', JSON.stringify('\uDEC9')); +assertEquals('"\\udeca"', JSON.stringify('\uDECA')); +assertEquals('"\\udecb"', JSON.stringify('\uDECB')); +assertEquals('"\\udecc"', JSON.stringify('\uDECC')); +assertEquals('"\\udecd"', JSON.stringify('\uDECD')); +assertEquals('"\\udece"', JSON.stringify('\uDECE')); +assertEquals('"\\udecf"', JSON.stringify('\uDECF')); +assertEquals('"\\uded0"', JSON.stringify('\uDED0')); +assertEquals('"\\uded1"', JSON.stringify('\uDED1')); +assertEquals('"\\uded2"', JSON.stringify('\uDED2')); +assertEquals('"\\uded3"', JSON.stringify('\uDED3')); +assertEquals('"\\uded4"', JSON.stringify('\uDED4')); +assertEquals('"\\uded5"', JSON.stringify('\uDED5')); +assertEquals('"\\uded6"', JSON.stringify('\uDED6')); +assertEquals('"\\uded7"', JSON.stringify('\uDED7')); +assertEquals('"\\uded8"', JSON.stringify('\uDED8')); +assertEquals('"\\uded9"', JSON.stringify('\uDED9')); +assertEquals('"\\udeda"', JSON.stringify('\uDEDA')); +assertEquals('"\\udedb"', JSON.stringify('\uDEDB')); +assertEquals('"\\udedc"', JSON.stringify('\uDEDC')); +assertEquals('"\\udedd"', JSON.stringify('\uDEDD')); +assertEquals('"\\udede"', JSON.stringify('\uDEDE')); +assertEquals('"\\udedf"', JSON.stringify('\uDEDF')); +assertEquals('"\\udee0"', JSON.stringify('\uDEE0')); +assertEquals('"\\udee1"', JSON.stringify('\uDEE1')); +assertEquals('"\\udee2"', JSON.stringify('\uDEE2')); +assertEquals('"\\udee3"', JSON.stringify('\uDEE3')); +assertEquals('"\\udee4"', JSON.stringify('\uDEE4')); +assertEquals('"\\udee5"', JSON.stringify('\uDEE5')); +assertEquals('"\\udee6"', JSON.stringify('\uDEE6')); +assertEquals('"\\udee7"', JSON.stringify('\uDEE7')); +assertEquals('"\\udee8"', JSON.stringify('\uDEE8')); +assertEquals('"\\udee9"', JSON.stringify('\uDEE9')); +assertEquals('"\\udeea"', JSON.stringify('\uDEEA')); +assertEquals('"\\udeeb"', JSON.stringify('\uDEEB')); +assertEquals('"\\udeec"', JSON.stringify('\uDEEC')); +assertEquals('"\\udeed"', JSON.stringify('\uDEED')); +assertEquals('"\\udeee"', JSON.stringify('\uDEEE')); +assertEquals('"\\udeef"', JSON.stringify('\uDEEF')); +assertEquals('"\\udef0"', JSON.stringify('\uDEF0')); +assertEquals('"\\udef1"', JSON.stringify('\uDEF1')); +assertEquals('"\\udef2"', JSON.stringify('\uDEF2')); +assertEquals('"\\udef3"', JSON.stringify('\uDEF3')); +assertEquals('"\\udef4"', JSON.stringify('\uDEF4')); +assertEquals('"\\udef5"', JSON.stringify('\uDEF5')); +assertEquals('"\\udef6"', JSON.stringify('\uDEF6')); +assertEquals('"\\udef7"', JSON.stringify('\uDEF7')); +assertEquals('"\\udef8"', JSON.stringify('\uDEF8')); +assertEquals('"\\udef9"', JSON.stringify('\uDEF9')); +assertEquals('"\\udefa"', JSON.stringify('\uDEFA')); +assertEquals('"\\udefb"', JSON.stringify('\uDEFB')); +assertEquals('"\\udefc"', JSON.stringify('\uDEFC')); +assertEquals('"\\udefd"', JSON.stringify('\uDEFD')); +assertEquals('"\\udefe"', JSON.stringify('\uDEFE')); +assertEquals('"\\udeff"', JSON.stringify('\uDEFF')); +assertEquals('"\\udf00"', JSON.stringify('\uDF00')); +assertEquals('"\\udf01"', JSON.stringify('\uDF01')); +assertEquals('"\\udf02"', JSON.stringify('\uDF02')); +assertEquals('"\\udf03"', JSON.stringify('\uDF03')); +assertEquals('"\\udf04"', JSON.stringify('\uDF04')); +assertEquals('"\\udf05"', JSON.stringify('\uDF05')); +assertEquals('"\\udf06"', JSON.stringify('\uDF06')); +assertEquals('"\\udf07"', JSON.stringify('\uDF07')); +assertEquals('"\\udf08"', JSON.stringify('\uDF08')); +assertEquals('"\\udf09"', JSON.stringify('\uDF09')); +assertEquals('"\\udf0a"', JSON.stringify('\uDF0A')); +assertEquals('"\\udf0b"', JSON.stringify('\uDF0B')); +assertEquals('"\\udf0c"', JSON.stringify('\uDF0C')); +assertEquals('"\\udf0d"', JSON.stringify('\uDF0D')); +assertEquals('"\\udf0e"', JSON.stringify('\uDF0E')); +assertEquals('"\\udf0f"', JSON.stringify('\uDF0F')); +assertEquals('"\\udf10"', JSON.stringify('\uDF10')); +assertEquals('"\\udf11"', JSON.stringify('\uDF11')); +assertEquals('"\\udf12"', JSON.stringify('\uDF12')); +assertEquals('"\\udf13"', JSON.stringify('\uDF13')); +assertEquals('"\\udf14"', JSON.stringify('\uDF14')); +assertEquals('"\\udf15"', JSON.stringify('\uDF15')); +assertEquals('"\\udf16"', JSON.stringify('\uDF16')); +assertEquals('"\\udf17"', JSON.stringify('\uDF17')); +assertEquals('"\\udf18"', JSON.stringify('\uDF18')); +assertEquals('"\\udf19"', JSON.stringify('\uDF19')); +assertEquals('"\\udf1a"', JSON.stringify('\uDF1A')); +assertEquals('"\\udf1b"', JSON.stringify('\uDF1B')); +assertEquals('"\\udf1c"', JSON.stringify('\uDF1C')); +assertEquals('"\\udf1d"', JSON.stringify('\uDF1D')); +assertEquals('"\\udf1e"', JSON.stringify('\uDF1E')); +assertEquals('"\\udf1f"', JSON.stringify('\uDF1F')); +assertEquals('"\\udf20"', JSON.stringify('\uDF20')); +assertEquals('"\\udf21"', JSON.stringify('\uDF21')); +assertEquals('"\\udf22"', JSON.stringify('\uDF22')); +assertEquals('"\\udf23"', JSON.stringify('\uDF23')); +assertEquals('"\\udf24"', JSON.stringify('\uDF24')); +assertEquals('"\\udf25"', JSON.stringify('\uDF25')); +assertEquals('"\\udf26"', JSON.stringify('\uDF26')); +assertEquals('"\\udf27"', JSON.stringify('\uDF27')); +assertEquals('"\\udf28"', JSON.stringify('\uDF28')); +assertEquals('"\\udf29"', JSON.stringify('\uDF29')); +assertEquals('"\\udf2a"', JSON.stringify('\uDF2A')); +assertEquals('"\\udf2b"', JSON.stringify('\uDF2B')); +assertEquals('"\\udf2c"', JSON.stringify('\uDF2C')); +assertEquals('"\\udf2d"', JSON.stringify('\uDF2D')); +assertEquals('"\\udf2e"', JSON.stringify('\uDF2E')); +assertEquals('"\\udf2f"', JSON.stringify('\uDF2F')); +assertEquals('"\\udf30"', JSON.stringify('\uDF30')); +assertEquals('"\\udf31"', JSON.stringify('\uDF31')); +assertEquals('"\\udf32"', JSON.stringify('\uDF32')); +assertEquals('"\\udf33"', JSON.stringify('\uDF33')); +assertEquals('"\\udf34"', JSON.stringify('\uDF34')); +assertEquals('"\\udf35"', JSON.stringify('\uDF35')); +assertEquals('"\\udf36"', JSON.stringify('\uDF36')); +assertEquals('"\\udf37"', JSON.stringify('\uDF37')); +assertEquals('"\\udf38"', JSON.stringify('\uDF38')); +assertEquals('"\\udf39"', JSON.stringify('\uDF39')); +assertEquals('"\\udf3a"', JSON.stringify('\uDF3A')); +assertEquals('"\\udf3b"', JSON.stringify('\uDF3B')); +assertEquals('"\\udf3c"', JSON.stringify('\uDF3C')); +assertEquals('"\\udf3d"', JSON.stringify('\uDF3D')); +assertEquals('"\\udf3e"', JSON.stringify('\uDF3E')); +assertEquals('"\\udf3f"', JSON.stringify('\uDF3F')); +assertEquals('"\\udf40"', JSON.stringify('\uDF40')); +assertEquals('"\\udf41"', JSON.stringify('\uDF41')); +assertEquals('"\\udf42"', JSON.stringify('\uDF42')); +assertEquals('"\\udf43"', JSON.stringify('\uDF43')); +assertEquals('"\\udf44"', JSON.stringify('\uDF44')); +assertEquals('"\\udf45"', JSON.stringify('\uDF45')); +assertEquals('"\\udf46"', JSON.stringify('\uDF46')); +assertEquals('"\\udf47"', JSON.stringify('\uDF47')); +assertEquals('"\\udf48"', JSON.stringify('\uDF48')); +assertEquals('"\\udf49"', JSON.stringify('\uDF49')); +assertEquals('"\\udf4a"', JSON.stringify('\uDF4A')); +assertEquals('"\\udf4b"', JSON.stringify('\uDF4B')); +assertEquals('"\\udf4c"', JSON.stringify('\uDF4C')); +assertEquals('"\\udf4d"', JSON.stringify('\uDF4D')); +assertEquals('"\\udf4e"', JSON.stringify('\uDF4E')); +assertEquals('"\\udf4f"', JSON.stringify('\uDF4F')); +assertEquals('"\\udf50"', JSON.stringify('\uDF50')); +assertEquals('"\\udf51"', JSON.stringify('\uDF51')); +assertEquals('"\\udf52"', JSON.stringify('\uDF52')); +assertEquals('"\\udf53"', JSON.stringify('\uDF53')); +assertEquals('"\\udf54"', JSON.stringify('\uDF54')); +assertEquals('"\\udf55"', JSON.stringify('\uDF55')); +assertEquals('"\\udf56"', JSON.stringify('\uDF56')); +assertEquals('"\\udf57"', JSON.stringify('\uDF57')); +assertEquals('"\\udf58"', JSON.stringify('\uDF58')); +assertEquals('"\\udf59"', JSON.stringify('\uDF59')); +assertEquals('"\\udf5a"', JSON.stringify('\uDF5A')); +assertEquals('"\\udf5b"', JSON.stringify('\uDF5B')); +assertEquals('"\\udf5c"', JSON.stringify('\uDF5C')); +assertEquals('"\\udf5d"', JSON.stringify('\uDF5D')); +assertEquals('"\\udf5e"', JSON.stringify('\uDF5E')); +assertEquals('"\\udf5f"', JSON.stringify('\uDF5F')); +assertEquals('"\\udf60"', JSON.stringify('\uDF60')); +assertEquals('"\\udf61"', JSON.stringify('\uDF61')); +assertEquals('"\\udf62"', JSON.stringify('\uDF62')); +assertEquals('"\\udf63"', JSON.stringify('\uDF63')); +assertEquals('"\\udf64"', JSON.stringify('\uDF64')); +assertEquals('"\\udf65"', JSON.stringify('\uDF65')); +assertEquals('"\\udf66"', JSON.stringify('\uDF66')); +assertEquals('"\\udf67"', JSON.stringify('\uDF67')); +assertEquals('"\\udf68"', JSON.stringify('\uDF68')); +assertEquals('"\\udf69"', JSON.stringify('\uDF69')); +assertEquals('"\\udf6a"', JSON.stringify('\uDF6A')); +assertEquals('"\\udf6b"', JSON.stringify('\uDF6B')); +assertEquals('"\\udf6c"', JSON.stringify('\uDF6C')); +assertEquals('"\\udf6d"', JSON.stringify('\uDF6D')); +assertEquals('"\\udf6e"', JSON.stringify('\uDF6E')); +assertEquals('"\\udf6f"', JSON.stringify('\uDF6F')); +assertEquals('"\\udf70"', JSON.stringify('\uDF70')); +assertEquals('"\\udf71"', JSON.stringify('\uDF71')); +assertEquals('"\\udf72"', JSON.stringify('\uDF72')); +assertEquals('"\\udf73"', JSON.stringify('\uDF73')); +assertEquals('"\\udf74"', JSON.stringify('\uDF74')); +assertEquals('"\\udf75"', JSON.stringify('\uDF75')); +assertEquals('"\\udf76"', JSON.stringify('\uDF76')); +assertEquals('"\\udf77"', JSON.stringify('\uDF77')); +assertEquals('"\\udf78"', JSON.stringify('\uDF78')); +assertEquals('"\\udf79"', JSON.stringify('\uDF79')); +assertEquals('"\\udf7a"', JSON.stringify('\uDF7A')); +assertEquals('"\\udf7b"', JSON.stringify('\uDF7B')); +assertEquals('"\\udf7c"', JSON.stringify('\uDF7C')); +assertEquals('"\\udf7d"', JSON.stringify('\uDF7D')); +assertEquals('"\\udf7e"', JSON.stringify('\uDF7E')); +assertEquals('"\\udf7f"', JSON.stringify('\uDF7F')); +assertEquals('"\\udf80"', JSON.stringify('\uDF80')); +assertEquals('"\\udf81"', JSON.stringify('\uDF81')); +assertEquals('"\\udf82"', JSON.stringify('\uDF82')); +assertEquals('"\\udf83"', JSON.stringify('\uDF83')); +assertEquals('"\\udf84"', JSON.stringify('\uDF84')); +assertEquals('"\\udf85"', JSON.stringify('\uDF85')); +assertEquals('"\\udf86"', JSON.stringify('\uDF86')); +assertEquals('"\\udf87"', JSON.stringify('\uDF87')); +assertEquals('"\\udf88"', JSON.stringify('\uDF88')); +assertEquals('"\\udf89"', JSON.stringify('\uDF89')); +assertEquals('"\\udf8a"', JSON.stringify('\uDF8A')); +assertEquals('"\\udf8b"', JSON.stringify('\uDF8B')); +assertEquals('"\\udf8c"', JSON.stringify('\uDF8C')); +assertEquals('"\\udf8d"', JSON.stringify('\uDF8D')); +assertEquals('"\\udf8e"', JSON.stringify('\uDF8E')); +assertEquals('"\\udf8f"', JSON.stringify('\uDF8F')); +assertEquals('"\\udf90"', JSON.stringify('\uDF90')); +assertEquals('"\\udf91"', JSON.stringify('\uDF91')); +assertEquals('"\\udf92"', JSON.stringify('\uDF92')); +assertEquals('"\\udf93"', JSON.stringify('\uDF93')); +assertEquals('"\\udf94"', JSON.stringify('\uDF94')); +assertEquals('"\\udf95"', JSON.stringify('\uDF95')); +assertEquals('"\\udf96"', JSON.stringify('\uDF96')); +assertEquals('"\\udf97"', JSON.stringify('\uDF97')); +assertEquals('"\\udf98"', JSON.stringify('\uDF98')); +assertEquals('"\\udf99"', JSON.stringify('\uDF99')); +assertEquals('"\\udf9a"', JSON.stringify('\uDF9A')); +assertEquals('"\\udf9b"', JSON.stringify('\uDF9B')); +assertEquals('"\\udf9c"', JSON.stringify('\uDF9C')); +assertEquals('"\\udf9d"', JSON.stringify('\uDF9D')); +assertEquals('"\\udf9e"', JSON.stringify('\uDF9E')); +assertEquals('"\\udf9f"', JSON.stringify('\uDF9F')); +assertEquals('"\\udfa0"', JSON.stringify('\uDFA0')); +assertEquals('"\\udfa1"', JSON.stringify('\uDFA1')); +assertEquals('"\\udfa2"', JSON.stringify('\uDFA2')); +assertEquals('"\\udfa3"', JSON.stringify('\uDFA3')); +assertEquals('"\\udfa4"', JSON.stringify('\uDFA4')); +assertEquals('"\\udfa5"', JSON.stringify('\uDFA5')); +assertEquals('"\\udfa6"', JSON.stringify('\uDFA6')); +assertEquals('"\\udfa7"', JSON.stringify('\uDFA7')); +assertEquals('"\\udfa8"', JSON.stringify('\uDFA8')); +assertEquals('"\\udfa9"', JSON.stringify('\uDFA9')); +assertEquals('"\\udfaa"', JSON.stringify('\uDFAA')); +assertEquals('"\\udfab"', JSON.stringify('\uDFAB')); +assertEquals('"\\udfac"', JSON.stringify('\uDFAC')); +assertEquals('"\\udfad"', JSON.stringify('\uDFAD')); +assertEquals('"\\udfae"', JSON.stringify('\uDFAE')); +assertEquals('"\\udfaf"', JSON.stringify('\uDFAF')); +assertEquals('"\\udfb0"', JSON.stringify('\uDFB0')); +assertEquals('"\\udfb1"', JSON.stringify('\uDFB1')); +assertEquals('"\\udfb2"', JSON.stringify('\uDFB2')); +assertEquals('"\\udfb3"', JSON.stringify('\uDFB3')); +assertEquals('"\\udfb4"', JSON.stringify('\uDFB4')); +assertEquals('"\\udfb5"', JSON.stringify('\uDFB5')); +assertEquals('"\\udfb6"', JSON.stringify('\uDFB6')); +assertEquals('"\\udfb7"', JSON.stringify('\uDFB7')); +assertEquals('"\\udfb8"', JSON.stringify('\uDFB8')); +assertEquals('"\\udfb9"', JSON.stringify('\uDFB9')); +assertEquals('"\\udfba"', JSON.stringify('\uDFBA')); +assertEquals('"\\udfbb"', JSON.stringify('\uDFBB')); +assertEquals('"\\udfbc"', JSON.stringify('\uDFBC')); +assertEquals('"\\udfbd"', JSON.stringify('\uDFBD')); +assertEquals('"\\udfbe"', JSON.stringify('\uDFBE')); +assertEquals('"\\udfbf"', JSON.stringify('\uDFBF')); +assertEquals('"\\udfc0"', JSON.stringify('\uDFC0')); +assertEquals('"\\udfc1"', JSON.stringify('\uDFC1')); +assertEquals('"\\udfc2"', JSON.stringify('\uDFC2')); +assertEquals('"\\udfc3"', JSON.stringify('\uDFC3')); +assertEquals('"\\udfc4"', JSON.stringify('\uDFC4')); +assertEquals('"\\udfc5"', JSON.stringify('\uDFC5')); +assertEquals('"\\udfc6"', JSON.stringify('\uDFC6')); +assertEquals('"\\udfc7"', JSON.stringify('\uDFC7')); +assertEquals('"\\udfc8"', JSON.stringify('\uDFC8')); +assertEquals('"\\udfc9"', JSON.stringify('\uDFC9')); +assertEquals('"\\udfca"', JSON.stringify('\uDFCA')); +assertEquals('"\\udfcb"', JSON.stringify('\uDFCB')); +assertEquals('"\\udfcc"', JSON.stringify('\uDFCC')); +assertEquals('"\\udfcd"', JSON.stringify('\uDFCD')); +assertEquals('"\\udfce"', JSON.stringify('\uDFCE')); +assertEquals('"\\udfcf"', JSON.stringify('\uDFCF')); +assertEquals('"\\udfd0"', JSON.stringify('\uDFD0')); +assertEquals('"\\udfd1"', JSON.stringify('\uDFD1')); +assertEquals('"\\udfd2"', JSON.stringify('\uDFD2')); +assertEquals('"\\udfd3"', JSON.stringify('\uDFD3')); +assertEquals('"\\udfd4"', JSON.stringify('\uDFD4')); +assertEquals('"\\udfd5"', JSON.stringify('\uDFD5')); +assertEquals('"\\udfd6"', JSON.stringify('\uDFD6')); +assertEquals('"\\udfd7"', JSON.stringify('\uDFD7')); +assertEquals('"\\udfd8"', JSON.stringify('\uDFD8')); +assertEquals('"\\udfd9"', JSON.stringify('\uDFD9')); +assertEquals('"\\udfda"', JSON.stringify('\uDFDA')); +assertEquals('"\\udfdb"', JSON.stringify('\uDFDB')); +assertEquals('"\\udfdc"', JSON.stringify('\uDFDC')); +assertEquals('"\\udfdd"', JSON.stringify('\uDFDD')); +assertEquals('"\\udfde"', JSON.stringify('\uDFDE')); +assertEquals('"\\udfdf"', JSON.stringify('\uDFDF')); +assertEquals('"\\udfe0"', JSON.stringify('\uDFE0')); +assertEquals('"\\udfe1"', JSON.stringify('\uDFE1')); +assertEquals('"\\udfe2"', JSON.stringify('\uDFE2')); +assertEquals('"\\udfe3"', JSON.stringify('\uDFE3')); +assertEquals('"\\udfe4"', JSON.stringify('\uDFE4')); +assertEquals('"\\udfe5"', JSON.stringify('\uDFE5')); +assertEquals('"\\udfe6"', JSON.stringify('\uDFE6')); +assertEquals('"\\udfe7"', JSON.stringify('\uDFE7')); +assertEquals('"\\udfe8"', JSON.stringify('\uDFE8')); +assertEquals('"\\udfe9"', JSON.stringify('\uDFE9')); +assertEquals('"\\udfea"', JSON.stringify('\uDFEA')); +assertEquals('"\\udfeb"', JSON.stringify('\uDFEB')); +assertEquals('"\\udfec"', JSON.stringify('\uDFEC')); +assertEquals('"\\udfed"', JSON.stringify('\uDFED')); +assertEquals('"\\udfee"', JSON.stringify('\uDFEE')); +assertEquals('"\\udfef"', JSON.stringify('\uDFEF')); +assertEquals('"\\udff0"', JSON.stringify('\uDFF0')); +assertEquals('"\\udff1"', JSON.stringify('\uDFF1')); +assertEquals('"\\udff2"', JSON.stringify('\uDFF2')); +assertEquals('"\\udff3"', JSON.stringify('\uDFF3')); +assertEquals('"\\udff4"', JSON.stringify('\uDFF4')); +assertEquals('"\\udff5"', JSON.stringify('\uDFF5')); +assertEquals('"\\udff6"', JSON.stringify('\uDFF6')); +assertEquals('"\\udff7"', JSON.stringify('\uDFF7')); +assertEquals('"\\udff8"', JSON.stringify('\uDFF8')); +assertEquals('"\\udff9"', JSON.stringify('\uDFF9')); +assertEquals('"\\udffa"', JSON.stringify('\uDFFA')); +assertEquals('"\\udffb"', JSON.stringify('\uDFFB')); +assertEquals('"\\udffc"', JSON.stringify('\uDFFC')); +assertEquals('"\\udffd"', JSON.stringify('\uDFFD')); +assertEquals('"\\udffe"', JSON.stringify('\uDFFE')); +assertEquals('"\\udfff"', JSON.stringify('\uDFFF')); + +// A random selection of code points from U+E000 to U+FFFF. +assertEquals('"\uE000"', JSON.stringify('\uE000')); +assertEquals('"\uE00B"', JSON.stringify('\uE00B')); +assertEquals('"\uE0CC"', JSON.stringify('\uE0CC')); +assertEquals('"\uE0FD"', JSON.stringify('\uE0FD')); +assertEquals('"\uE19E"', JSON.stringify('\uE19E')); +assertEquals('"\uE1B1"', JSON.stringify('\uE1B1')); +assertEquals('"\uE24F"', JSON.stringify('\uE24F')); +assertEquals('"\uE262"', JSON.stringify('\uE262')); +assertEquals('"\uE2C9"', JSON.stringify('\uE2C9')); +assertEquals('"\uE2DF"', JSON.stringify('\uE2DF')); +assertEquals('"\uE389"', JSON.stringify('\uE389')); +assertEquals('"\uE413"', JSON.stringify('\uE413')); +assertEquals('"\uE546"', JSON.stringify('\uE546')); +assertEquals('"\uE5E4"', JSON.stringify('\uE5E4')); +assertEquals('"\uE66B"', JSON.stringify('\uE66B')); +assertEquals('"\uE73D"', JSON.stringify('\uE73D')); +assertEquals('"\uE74F"', JSON.stringify('\uE74F')); +assertEquals('"\uE759"', JSON.stringify('\uE759')); +assertEquals('"\uE795"', JSON.stringify('\uE795')); +assertEquals('"\uE836"', JSON.stringify('\uE836')); +assertEquals('"\uE85D"', JSON.stringify('\uE85D')); +assertEquals('"\uE909"', JSON.stringify('\uE909')); +assertEquals('"\uE990"', JSON.stringify('\uE990')); +assertEquals('"\uE99F"', JSON.stringify('\uE99F')); +assertEquals('"\uE9AC"', JSON.stringify('\uE9AC')); +assertEquals('"\uE9C2"', JSON.stringify('\uE9C2')); +assertEquals('"\uEB11"', JSON.stringify('\uEB11')); +assertEquals('"\uED33"', JSON.stringify('\uED33')); +assertEquals('"\uED7D"', JSON.stringify('\uED7D')); +assertEquals('"\uEDA9"', JSON.stringify('\uEDA9')); +assertEquals('"\uEDFB"', JSON.stringify('\uEDFB')); +assertEquals('"\uEE09"', JSON.stringify('\uEE09')); +assertEquals('"\uEE0D"', JSON.stringify('\uEE0D')); +assertEquals('"\uEE34"', JSON.stringify('\uEE34')); +assertEquals('"\uEE37"', JSON.stringify('\uEE37')); +assertEquals('"\uEE38"', JSON.stringify('\uEE38')); +assertEquals('"\uEF80"', JSON.stringify('\uEF80')); +assertEquals('"\uEFE2"', JSON.stringify('\uEFE2')); +assertEquals('"\uF02C"', JSON.stringify('\uF02C')); +assertEquals('"\uF09A"', JSON.stringify('\uF09A')); +assertEquals('"\uF0C1"', JSON.stringify('\uF0C1')); +assertEquals('"\uF12C"', JSON.stringify('\uF12C')); +assertEquals('"\uF250"', JSON.stringify('\uF250')); +assertEquals('"\uF2A3"', JSON.stringify('\uF2A3')); +assertEquals('"\uF340"', JSON.stringify('\uF340')); +assertEquals('"\uF3C9"', JSON.stringify('\uF3C9')); +assertEquals('"\uF3F5"', JSON.stringify('\uF3F5')); +assertEquals('"\uF41B"', JSON.stringify('\uF41B')); +assertEquals('"\uF420"', JSON.stringify('\uF420')); +assertEquals('"\uF440"', JSON.stringify('\uF440')); +assertEquals('"\uF4AE"', JSON.stringify('\uF4AE')); +assertEquals('"\uF4B0"', JSON.stringify('\uF4B0')); +assertEquals('"\uF50D"', JSON.stringify('\uF50D')); +assertEquals('"\uF55D"', JSON.stringify('\uF55D')); +assertEquals('"\uF55E"', JSON.stringify('\uF55E')); +assertEquals('"\uF5CD"', JSON.stringify('\uF5CD')); +assertEquals('"\uF657"', JSON.stringify('\uF657')); +assertEquals('"\uF66D"', JSON.stringify('\uF66D')); +assertEquals('"\uF68F"', JSON.stringify('\uF68F')); +assertEquals('"\uF6A6"', JSON.stringify('\uF6A6')); +assertEquals('"\uF6AA"', JSON.stringify('\uF6AA')); +assertEquals('"\uF6EB"', JSON.stringify('\uF6EB')); +assertEquals('"\uF79A"', JSON.stringify('\uF79A')); +assertEquals('"\uF7E7"', JSON.stringify('\uF7E7')); +assertEquals('"\uF7E8"', JSON.stringify('\uF7E8')); +assertEquals('"\uF834"', JSON.stringify('\uF834')); +assertEquals('"\uF88B"', JSON.stringify('\uF88B')); +assertEquals('"\uF8D5"', JSON.stringify('\uF8D5')); +assertEquals('"\uF8F1"', JSON.stringify('\uF8F1')); +assertEquals('"\uF905"', JSON.stringify('\uF905')); +assertEquals('"\uF927"', JSON.stringify('\uF927')); +assertEquals('"\uF943"', JSON.stringify('\uF943')); +assertEquals('"\uF949"', JSON.stringify('\uF949')); +assertEquals('"\uF9A1"', JSON.stringify('\uF9A1')); +assertEquals('"\uF9C7"', JSON.stringify('\uF9C7')); +assertEquals('"\uFA0F"', JSON.stringify('\uFA0F')); +assertEquals('"\uFA20"', JSON.stringify('\uFA20')); +assertEquals('"\uFAA7"', JSON.stringify('\uFAA7')); +assertEquals('"\uFBCD"', JSON.stringify('\uFBCD')); +assertEquals('"\uFBF7"', JSON.stringify('\uFBF7')); +assertEquals('"\uFC40"', JSON.stringify('\uFC40')); +assertEquals('"\uFC4B"', JSON.stringify('\uFC4B')); +assertEquals('"\uFC51"', JSON.stringify('\uFC51')); +assertEquals('"\uFC5E"', JSON.stringify('\uFC5E')); +assertEquals('"\uFC67"', JSON.stringify('\uFC67')); +assertEquals('"\uFC8B"', JSON.stringify('\uFC8B')); +assertEquals('"\uFE32"', JSON.stringify('\uFE32')); +assertEquals('"\uFFC4"', JSON.stringify('\uFFC4')); +assertEquals('"\uFFFD"', JSON.stringify('\uFFFD')); +assertEquals('"\uFFFE"', JSON.stringify('\uFFFE')); +assertEquals('"\uFFFF"', JSON.stringify('\uFFFF')); + +// A random selection of astral symbols, i.e. surrogate pairs, i.e. +// code points from U+010000 to U+10FFFF. +assertEquals('"\u{10000}"', JSON.stringify('\u{10000}')); +assertEquals('"\u{11DE7}"', JSON.stringify('\u{11DE7}')); +assertEquals('"\u{15997}"', JSON.stringify('\u{15997}')); +assertEquals('"\u{187B0}"', JSON.stringify('\u{187B0}')); +assertEquals('"\u{190B2}"', JSON.stringify('\u{190B2}')); +assertEquals('"\u{1BF79}"', JSON.stringify('\u{1BF79}')); +assertEquals('"\u{1C624}"', JSON.stringify('\u{1C624}')); +assertEquals('"\u{1D9F4}"', JSON.stringify('\u{1D9F4}')); +assertEquals('"\u{24149}"', JSON.stringify('\u{24149}')); +assertEquals('"\u{2521C}"', JSON.stringify('\u{2521C}')); +assertEquals('"\u{2762D}"', JSON.stringify('\u{2762D}')); +assertEquals('"\u{2930B}"', JSON.stringify('\u{2930B}')); +assertEquals('"\u{29EC4}"', JSON.stringify('\u{29EC4}')); +assertEquals('"\u{29F9A}"', JSON.stringify('\u{29F9A}')); +assertEquals('"\u{2A27D}"', JSON.stringify('\u{2A27D}')); +assertEquals('"\u{2B363}"', JSON.stringify('\u{2B363}')); +assertEquals('"\u{2C037}"', JSON.stringify('\u{2C037}')); +assertEquals('"\u{2FAE0}"', JSON.stringify('\u{2FAE0}')); +assertEquals('"\u{2FFCF}"', JSON.stringify('\u{2FFCF}')); +assertEquals('"\u{32C1C}"', JSON.stringify('\u{32C1C}')); +assertEquals('"\u{33DA8}"', JSON.stringify('\u{33DA8}')); +assertEquals('"\u{3DCA4}"', JSON.stringify('\u{3DCA4}')); +assertEquals('"\u{44FA0}"', JSON.stringify('\u{44FA0}')); +assertEquals('"\u{45618}"', JSON.stringify('\u{45618}')); +assertEquals('"\u{47395}"', JSON.stringify('\u{47395}')); +assertEquals('"\u{4752C}"', JSON.stringify('\u{4752C}')); +assertEquals('"\u{483FE}"', JSON.stringify('\u{483FE}')); +assertEquals('"\u{49D35}"', JSON.stringify('\u{49D35}')); +assertEquals('"\u{4CE3B}"', JSON.stringify('\u{4CE3B}')); +assertEquals('"\u{55196}"', JSON.stringify('\u{55196}')); +assertEquals('"\u{58B3E}"', JSON.stringify('\u{58B3E}')); +assertEquals('"\u{5AA47}"', JSON.stringify('\u{5AA47}')); +assertEquals('"\u{5C4B8}"', JSON.stringify('\u{5C4B8}')); +assertEquals('"\u{5DD1B}"', JSON.stringify('\u{5DD1B}')); +assertEquals('"\u{5FDCB}"', JSON.stringify('\u{5FDCB}')); +assertEquals('"\u{611BA}"', JSON.stringify('\u{611BA}')); +assertEquals('"\u{66433}"', JSON.stringify('\u{66433}')); +assertEquals('"\u{690D7}"', JSON.stringify('\u{690D7}')); +assertEquals('"\u{6F617}"', JSON.stringify('\u{6F617}')); +assertEquals('"\u{711E4}"', JSON.stringify('\u{711E4}')); +assertEquals('"\u{758D2}"', JSON.stringify('\u{758D2}')); +assertEquals('"\u{780AC}"', JSON.stringify('\u{780AC}')); +assertEquals('"\u{7AE5F}"', JSON.stringify('\u{7AE5F}')); +assertEquals('"\u{7C2FB}"', JSON.stringify('\u{7C2FB}')); +assertEquals('"\u{7D25F}"', JSON.stringify('\u{7D25F}')); +assertEquals('"\u{8027A}"', JSON.stringify('\u{8027A}')); +assertEquals('"\u{84817}"', JSON.stringify('\u{84817}')); +assertEquals('"\u{8B070}"', JSON.stringify('\u{8B070}')); +assertEquals('"\u{8B390}"', JSON.stringify('\u{8B390}')); +assertEquals('"\u{8BC03}"', JSON.stringify('\u{8BC03}')); +assertEquals('"\u{8BE63}"', JSON.stringify('\u{8BE63}')); +assertEquals('"\u{8F12A}"', JSON.stringify('\u{8F12A}')); +assertEquals('"\u{9345D}"', JSON.stringify('\u{9345D}')); +assertEquals('"\u{937A9}"', JSON.stringify('\u{937A9}')); +assertEquals('"\u{94596}"', JSON.stringify('\u{94596}')); +assertEquals('"\u{967BB}"', JSON.stringify('\u{967BB}')); +assertEquals('"\u{A19D1}"', JSON.stringify('\u{A19D1}')); +assertEquals('"\u{A4FC5}"', JSON.stringify('\u{A4FC5}')); +assertEquals('"\u{AC9CF}"', JSON.stringify('\u{AC9CF}')); +assertEquals('"\u{B1366}"', JSON.stringify('\u{B1366}')); +assertEquals('"\u{B3D32}"', JSON.stringify('\u{B3D32}')); +assertEquals('"\u{B74BA}"', JSON.stringify('\u{B74BA}')); +assertEquals('"\u{B8FB0}"', JSON.stringify('\u{B8FB0}')); +assertEquals('"\u{BA0A5}"', JSON.stringify('\u{BA0A5}')); +assertEquals('"\u{BB48E}"', JSON.stringify('\u{BB48E}')); +assertEquals('"\u{C0B60}"', JSON.stringify('\u{C0B60}')); +assertEquals('"\u{C2D34}"', JSON.stringify('\u{C2D34}')); +assertEquals('"\u{C6C75}"', JSON.stringify('\u{C6C75}')); +assertEquals('"\u{C9F26}"', JSON.stringify('\u{C9F26}')); +assertEquals('"\u{CDBD0}"', JSON.stringify('\u{CDBD0}')); +assertEquals('"\u{D1E28}"', JSON.stringify('\u{D1E28}')); +assertEquals('"\u{D4A80}"', JSON.stringify('\u{D4A80}')); +assertEquals('"\u{D947F}"', JSON.stringify('\u{D947F}')); +assertEquals('"\u{D9B8A}"', JSON.stringify('\u{D9B8A}')); +assertEquals('"\u{DA203}"', JSON.stringify('\u{DA203}')); +assertEquals('"\u{DEFD3}"', JSON.stringify('\u{DEFD3}')); +assertEquals('"\u{E4F7C}"', JSON.stringify('\u{E4F7C}')); +assertEquals('"\u{E6BB3}"', JSON.stringify('\u{E6BB3}')); +assertEquals('"\u{E972D}"', JSON.stringify('\u{E972D}')); +assertEquals('"\u{EB335}"', JSON.stringify('\u{EB335}')); +assertEquals('"\u{ED3F8}"', JSON.stringify('\u{ED3F8}')); +assertEquals('"\u{ED940}"', JSON.stringify('\u{ED940}')); +assertEquals('"\u{EF6F8}"', JSON.stringify('\u{EF6F8}')); +assertEquals('"\u{F1F57}"', JSON.stringify('\u{F1F57}')); +assertEquals('"\u{F33B5}"', JSON.stringify('\u{F33B5}')); +assertEquals('"\u{F4D2A}"', JSON.stringify('\u{F4D2A}')); +assertEquals('"\u{F70BA}"', JSON.stringify('\u{F70BA}')); +assertEquals('"\u{F899F}"', JSON.stringify('\u{F899F}')); +assertEquals('"\u{1034BF}"', JSON.stringify('\u{1034BF}')); +assertEquals('"\u{107ACF}"', JSON.stringify('\u{107ACF}')); +assertEquals('"\u{10881F}"', JSON.stringify('\u{10881F}')); +assertEquals('"\u{1098A5}"', JSON.stringify('\u{1098A5}')); +assertEquals('"\u{10ABD1}"', JSON.stringify('\u{10ABD1}')); +assertEquals('"\u{10B5C5}"', JSON.stringify('\u{10B5C5}')); +assertEquals('"\u{10CC79}"', JSON.stringify('\u{10CC79}')); +assertEquals('"\u{10CD19}"', JSON.stringify('\u{10CD19}')); +assertEquals('"\u{10FFFF}"', JSON.stringify('\u{10FFFF}')); diff --git a/deps/v8/test/mjsunit/ignition/regress-616064.js b/deps/v8/test/mjsunit/ignition/regress-616064.js index 805de41ac5..f14679a422 100644 --- a/deps/v8/test/mjsunit/ignition/regress-616064.js +++ b/deps/v8/test/mjsunit/ignition/regress-616064.js @@ -13,7 +13,7 @@ function foo() { return Worker.__f_0(-2147483648, __f_0); }; - var __v_9 = new Worker(''); + var __v_9 = new Worker('', {type: 'string'}); __f_1 = {s: Math.s, __f_1: true}; } } diff --git a/deps/v8/test/mjsunit/json.js b/deps/v8/test/mjsunit/json.js index 102f777c74..04754577ff 100644 --- a/deps/v8/test/mjsunit/json.js +++ b/deps/v8/test/mjsunit/json.js @@ -375,32 +375,30 @@ var o = { toString: function() { return "42"; } }; assertEquals(42, JSON.parse(o)); -for (var i = 0; i < 65536; i++) { +for (var i = 0x0000; i <= 0xFFFF; i++) { var string = String.fromCharCode(i); var encoded = JSON.stringify(string); - var expected = "uninitialized"; + var expected = 'uninitialized'; // Following the ES5 specification of the abstraction function Quote. if (string == '"' || string == '\\') { // Step 2.a expected = '\\' + string; - } else if ("\b\t\n\r\f".indexOf(string) >= 0) { + } else if ("\b\t\n\r\f".includes(string)) { // Step 2.b if (string == '\b') expected = '\\b'; else if (string == '\t') expected = '\\t'; else if (string == '\n') expected = '\\n'; else if (string == '\f') expected = '\\f'; else if (string == '\r') expected = '\\r'; - } else if (i < 32) { + } else if (i < 0x20) { // Step 2.c - if (i < 16) { - expected = "\\u000" + i.toString(16); - } else { - expected = "\\u00" + i.toString(16); - } + expected = '\\u' + i.toString(16).padStart(4, '0'); + // TODO(mathias): Add i >= 0xD800 && i <= 0xDFFF case once + // --harmony-json-stringify is enabled by default. } else { expected = string; } - assertEquals('"' + expected + '"', encoded, "Codepoint " + i); + assertEquals('"' + expected + '"', encoded, "code point " + i); } diff --git a/deps/v8/test/mjsunit/lexicographic-compare.js b/deps/v8/test/mjsunit/lexicographic-compare.js deleted file mode 100644 index b87dd1c1ef..0000000000 --- a/deps/v8/test/mjsunit/lexicographic-compare.js +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright 2018 the V8 project authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -// Flags: --allow-natives-syntax - -(function () { - - assertFalse(%IsSmi(2147483648), 'Update test for >32 bit Smi'); - - // Collect a list of interesting Smis. - const seen = {}; - const smis = []; - function add(x) { - if (x | 0 == x) { - x = x | 0; // Canonicalizes to Smi if 32-bit signed and fits in Smi. - } - if (%_IsSmi(x) && !seen[x]) { - seen[x] = 1; - smis.push(x); - } - } - function addSigned(x) { - add(x); - add(-x); - } - - var BIGGER_THAN_ANY_SMI = 10 * 1000 * 1000 * 1000; - for (var xb = 1; xb <= BIGGER_THAN_ANY_SMI; xb *= 10) { - for (var xf = 0; xf <= 9; xf++) { - for (var xo = -1; xo <= 1; xo++) { - addSigned(xb * xf + xo); - } - } - } - - console.log("A") - - for (var yb = 1; yb <= BIGGER_THAN_ANY_SMI; yb *= 2) { - for (var yo = -2; yo <= 2; yo++) { - addSigned(yb + yo); - } - } - - function test(x,y) { - const lex = %SmiLexicographicCompare(x, y); - const expected = (x == y) ? 0 : (("" + x) < ("" + y) ? -1 : 1); - return lex == expected; - } - - console.log(smis.length); - - for (var i = 0; i < smis.length; i++) { - for (var j = 0; j < smis.length; j++) { - const x = smis[i]; - const y = smis[j]; - assertTrue(test(x, y), x + " < " + y);; - } - } - - console.log("C") -})(); diff --git a/deps/v8/test/mjsunit/mjsunit.js b/deps/v8/test/mjsunit/mjsunit.js index a458e0cd10..59923a4247 100644 --- a/deps/v8/test/mjsunit/mjsunit.js +++ b/deps/v8/test/mjsunit/mjsunit.js @@ -64,6 +64,9 @@ var assertNotSame; // and the properties of non-Array objects). var assertEquals; +// Deep equality predicate used by assertEquals. +var deepEquals; + // Expected and found values are not identical primitive values or functions // or similarly structured objects (checking internal properties // of, e.g., Number and Date objects, the elements of arrays @@ -183,6 +186,9 @@ var isTurboFanned; // Monkey-patchable all-purpose failure handler. var failWithMessage; +// Returns the formatted failure text. Used by test-async.js. +var formatFailureText; + // Returns a pretty-printed string representation of the passed value. var prettyPrinted; @@ -297,7 +303,7 @@ var prettyPrinted; throw new MjsUnitAssertionError(message); } - function formatFailureText(expectedText, found, name_opt) { + formatFailureText = function(expectedText, found, name_opt) { var message = "Fail" + "ure"; if (name_opt) { // Fix this when we ditch the old test runner. @@ -335,7 +341,7 @@ var prettyPrinted; } - function deepEquals(a, b) { + deepEquals = function deepEquals(a, b) { if (a === b) { // Check for -0. if (a === 0) return (1 / a) === (1 / b); diff --git a/deps/v8/test/mjsunit/mjsunit.status b/deps/v8/test/mjsunit/mjsunit.status index 4d54808b46..16a17189e0 100644 --- a/deps/v8/test/mjsunit/mjsunit.status +++ b/deps/v8/test/mjsunit/mjsunit.status @@ -55,8 +55,6 @@ # Issue 5495: enable the test when the constant field tracking in enabled. 'const-field-tracking': [SKIP], - # Issue 7872: flaky OOM - 'regress/wasm/regress-827806': [SKIP], ############################################################################## # Too slow in debug mode with --stress-opt mode. 'regress/regress-create-exception': [PASS, ['mode == debug', SKIP]], @@ -168,12 +166,15 @@ 'regress/regress-605470': [PASS, SLOW], 'regress/regress-655573': [PASS, SLOW], 'regress/regress-1200351': [PASS, SLOW], + 'regress/wasm/regress-810973': [PASS, SLOW], 'string-replace-gc': [PASS, SLOW], 'wasm/asm-wasm-f32': [PASS, SLOW], 'wasm/asm-wasm-f64': [PASS, SLOW], 'wasm/embenchen/*': [PASS, SLOW], 'wasm/grow-memory': [PASS, SLOW], 'wasm/unreachable-validation': [PASS, SLOW], + 'wasm/compare-exchange-stress': [PASS, SLOW, NO_VARIANTS], + 'wasm/compare-exchange64-stress': [PASS, SLOW, NO_VARIANTS], # case-insensitive unicode regexp relies on case mapping provided by ICU. 'es6/unicode-regexp-ignore-case': [PASS, ['no_i18n == True', FAIL]], @@ -215,14 +216,14 @@ # Allocates a huge string and then flattens it, very slow in debug mode. 'regress/regress-752764': [PASS, ['mode == debug', SLOW]], - # https://crbug.com/v8/7682 - 'regress/regress-v8-7682': [FAIL], - # https://crbug.com/v8/7697 'array-literal-feedback': [PASS, FAIL], # https://crbug.com/v8/7775 'allocation-site-info': [SKIP], + + # BUG(v8:8169) + 'external-backing-store-gc': [SKIP], }], # ALWAYS ['novfp3 == True', { @@ -277,7 +278,6 @@ # TODO(mstarzinger): Takes too long with TF. 'array-sort': [PASS, NO_VARIANTS], - 'lexicographic-compare': [PASS, NO_VARIANTS], 'regress/regress-91008': [PASS, NO_VARIANTS], 'regress/regress-transcendental': [PASS, ['arch == arm64', NO_VARIANTS]], 'compiler/osr-regress-max-locals': [PASS, NO_VARIANTS], @@ -320,9 +320,6 @@ 'asm/sqlite3/*': [SKIP], # TODO(mips-team): Fix Wasm for big-endian. 'wasm/*': [SKIP], - # TODO(mips-team): Fix SEGV on regress-864509.js on big endian - # (https://crbug.com/v8/7953). - 'regress/wasm/regress-864509': [SKIP], }], # 'byteorder == big' ############################################################################## @@ -370,12 +367,10 @@ 'compiler/osr-with-args': [PASS, SLOW], 'generated-transition-stub': [PASS, SLOW], 'json2': [PASS, SLOW], - 'lexicographic-compare': [PASS, SLOW], 'math-floor-of-div-nosudiv': [PASS, SLOW], 'math-floor-of-div': [PASS, SLOW], 'messages': [PASS, SLOW], 'packed-elements': [PASS, SLOW], - 'regress/regress-2185': [PASS, SLOW], 'regress/regress-2790': [PASS, SLOW], 'regress/regress-331444': [PASS, SLOW], 'regress/regress-490': [PASS, SLOW], @@ -397,7 +392,6 @@ # Pass but take too long with the simulator in debug mode. 'array-sort': [PASS, SLOW], - 'lexicographic-compare': [PASS, SLOW], 'packed-elements': [SKIP], 'regexp-global': [SKIP], 'math-floor-of-div': [PASS, SLOW], @@ -466,6 +460,9 @@ # BUG(v8:7042). Uses a lot of memory. 'regress/regress-678917': [SKIP], + # BUG(v8:8103). Uses a lot of memory. + 'regress/regress-852258': [SKIP], + # BUG(v8:6924). The test uses a lot of memory. 'regress/wasm/regress-694433': [SKIP], 'es6/typedarray': [PASS, NO_VARIANTS], @@ -506,7 +503,6 @@ # Slow tests. 'array-sort': [PASS, SLOW], 'compiler/osr-with-args': [PASS, SLOW], - 'lexicographic-compare': [PASS, SLOW], 'packed-elements': [PASS, SLOW], 'regress/regress-2790': [PASS, SLOW], 'regress/regress-91008': [PASS, SLOW], @@ -651,6 +647,8 @@ 'regress/regress-748069': [FAIL], 'regress/regress-752764': [FAIL], 'regress/regress-779407': [FAIL], + # Flaky OOM: + 'regress/regress-852258': [SKIP], }], # 'system == android' ############################################################################## @@ -660,6 +658,13 @@ }], # 'system == macos' ############################################################################## +['isolates', { + # Slow tests. + 'es6/typedarray-of': [PASS, SLOW], + 'regress/regress-crbug-854299': [PASS, SLOW], +}], # 'isolates' + +############################################################################## ['deopt_fuzzer == True', { # Skip tests that are not suitable for deoptimization fuzzing. @@ -708,6 +713,7 @@ 'keyed-load-with-symbol-key': [PASS, FAIL], 'object-seal': [PASS, FAIL], 'regress/regress-3709': [PASS, FAIL], + 'regress/regress-6948': [PASS, FAIL], 'regress/regress-7510': [PASS, FAIL], 'regress/regress-trap-allocation-memento': [PASS, FAIL], 'regress/regress-unlink-closures-on-deopt': [PASS, FAIL], @@ -792,26 +798,32 @@ # Slow on arm64 simulator: https://crbug.com/v8/7783 'string-replace-gc': [PASS, ['arch == arm64 and simulator_run', SKIP]], + + # Too memory hungry on Odroid devices. + 'regress/regress-678917': [PASS, ['arch == arm and not simulator_run', SKIP]], + + # https://crbug.com/v8/8164 + 'wasm/compare-exchange-stress': [SKIP], }], # variant == stress ############################################################################## +['variant == stress and (arch == arm or arch == arm64) and simulator_run', { + # Slow tests: https://crbug.com/v8/7783 + 'generated-transition-stub': [SKIP], + 'wasm/grow-memory': [SKIP], +}], # variant == stress and (arch == arm or arch == arm64) and simulator_run + +############################################################################## ['variant == nooptimization and (arch == arm or arch == arm64) and simulator_run', { # Slow tests: https://crbug.com/v8/7783 - 'lexicographic-compare': [SKIP], 'md5': [SKIP], - 'regress/regress-2185': [SKIP], + 'packed-elements': [SKIP], 'wasm/asm-wasm-f32': [SKIP], 'wasm/asm-wasm-f64': [SKIP], 'wasm/grow-memory': [SKIP], }], # variant == nooptimization and (arch == arm or arch == arm64) and simulator_run ############################################################################## -['(arch == arm or arch == arm64) and simulator_run', { - # Slow tests: https://crbug.com/v8/7783 - 'regress/regress-2185': [SKIP], -}], # (arch == arm or arch == arm64) and simulator_run - -############################################################################## ['(arch == arm or arch == arm64)', { # Flaky tests: https://crbug.com/v8/8090 'regress/regress-752764': [SKIP], diff --git a/deps/v8/test/mjsunit/regress/regress-319722-ArrayBuffer.js b/deps/v8/test/mjsunit/regress/regress-319722-ArrayBuffer.js index 9a24fc5c7c..4a48a61ab3 100644 --- a/deps/v8/test/mjsunit/regress/regress-319722-ArrayBuffer.js +++ b/deps/v8/test/mjsunit/regress/regress-319722-ArrayBuffer.js @@ -26,7 +26,7 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Flags: --nostress-opt --allow-natives-syntax --mock-arraybuffer-allocator -var maxSize = %_MaxSmi() + 1; +var maxSize = %MaxSmi() + 1; var ab; // Allocate the largest ArrayBuffer we can on this architecture. diff --git a/deps/v8/test/mjsunit/regress/regress-319722-TypedArrays.js b/deps/v8/test/mjsunit/regress/regress-319722-TypedArrays.js index e497aecbe0..0445e2d2cf 100644 --- a/deps/v8/test/mjsunit/regress/regress-319722-TypedArrays.js +++ b/deps/v8/test/mjsunit/regress/regress-319722-TypedArrays.js @@ -27,7 +27,7 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Flags: --nostress-opt --allow-natives-syntax -var maxSize = %_MaxSmi() + 1; +var maxSize = %MaxSmi() + 1; function TestArray(constr) { assertThrows(function() { new constr(maxSize); diff --git a/deps/v8/test/mjsunit/regress/regress-3255.js b/deps/v8/test/mjsunit/regress/regress-3255.js index 0e77435374..0c5ee4ff00 100644 --- a/deps/v8/test/mjsunit/regress/regress-3255.js +++ b/deps/v8/test/mjsunit/regress/regress-3255.js @@ -16,4 +16,4 @@ f(str, 0); f(str, 0); // This is just to trigger elements validation, object already broken. -%SetProperty(str, 1, 'y', 0); +%SetKeyedProperty(str, 1, 'y', 0); diff --git a/deps/v8/test/mjsunit/regress/regress-4271.js b/deps/v8/test/mjsunit/regress/regress-4271.js index bc18771e72..5b724b01b6 100644 --- a/deps/v8/test/mjsunit/regress/regress-4271.js +++ b/deps/v8/test/mjsunit/regress/regress-4271.js @@ -17,7 +17,7 @@ if (this.Worker) { }); // Don't throw for real worker - var worker = new Worker(''); + var worker = new Worker('', {type: 'string'}); worker.getMessage(); worker.postMessage({}); worker.terminate(); diff --git a/deps/v8/test/mjsunit/regress/regress-4279.js b/deps/v8/test/mjsunit/regress/regress-4279.js index 64ef967d89..ddc272793e 100644 --- a/deps/v8/test/mjsunit/regress/regress-4279.js +++ b/deps/v8/test/mjsunit/regress/regress-4279.js @@ -4,7 +4,7 @@ if (this.Worker && this.quit) { try { - new Function(new Worker("55")); + new Function(new Worker("55"), {type: 'string'}); } catch(err) {} quit(); diff --git a/deps/v8/test/mjsunit/regress/regress-707066.js b/deps/v8/test/mjsunit/regress/regress-707066.js index b33b585ebd..b5d70c2e6b 100644 --- a/deps/v8/test/mjsunit/regress/regress-707066.js +++ b/deps/v8/test/mjsunit/regress/regress-707066.js @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // -// Flags: --harmony-function-tostring - // There was a bug in CreateDynamicFunction where a stack overflow // situation caused an assertion failure. diff --git a/deps/v8/test/mjsunit/regress/regress-8133-1.js b/deps/v8/test/mjsunit/regress/regress-8133-1.js new file mode 100644 index 0000000000..8f3cc734a6 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-8133-1.js @@ -0,0 +1,16 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +const arr = [1, , 3]; + +function mapper(x) { + Array.prototype[1] = 2; + return x + 1; +} + +// This iterates over arr using the iterator protocol, which turns the hole into +// undefined. The mapper function then gets called in a separate iteration over +// the acquired elements, where it increments undefined, which produces NaN and +// gets converted to 0. +assertArrayEquals([2, 0, 4], Uint16Array.from(arr, mapper)); diff --git a/deps/v8/test/mjsunit/regress/regress-8133-2.js b/deps/v8/test/mjsunit/regress/regress-8133-2.js new file mode 100644 index 0000000000..e163e3c784 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-8133-2.js @@ -0,0 +1,17 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +const arr = [1, , 3]; + +function mapper(x) { + Array.prototype[1] = 2; + return x + 1; +} + +// We force a direct iteration (using the array length, not the iterator +// protocol). The mapper function gets called during this iteration, not in a +// separate one. Hence when index 1 is read, 2 is retrieved from the prototype +// and incremented to 3. +Array.prototype[Symbol.iterator] = undefined; +assertArrayEquals([2, 3, 4], Uint16Array.from(arr, mapper)); diff --git a/deps/v8/test/mjsunit/regress/regress-821368.js b/deps/v8/test/mjsunit/regress/regress-821368.js index b41261d7c9..8f8a01b3f7 100644 --- a/deps/v8/test/mjsunit/regress/regress-821368.js +++ b/deps/v8/test/mjsunit/regress/regress-821368.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -const worker = new Worker("onmessage = function(){}"); +const worker = new Worker("onmessage = function(){}", {type: 'string'}); const buffer = new ArrayBuffer(); worker.postMessage(buffer, [buffer]); try { diff --git a/deps/v8/test/mjsunit/regress/regress-8237.js b/deps/v8/test/mjsunit/regress/regress-8237.js new file mode 100644 index 0000000000..c3abd17e8a --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-8237.js @@ -0,0 +1,57 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --no-always-opt +// Files: test/mjsunit/code-coverage-utils.js + +%DebugToggleBlockCoverage(true); + +TestCoverage( +"Repro for the bug", +` +function lib (n) { // 0000 + if (n >= 0) { // 0050 + if (n < 0) { // 0100 + return; // 0150 + } // 0200 + } else if (foo()) { // 0250 + } // 0300 +} // 0350 +function foo () { // 0400 + console.log('foo') // 0450 + return false // 0500 +} // 0550 +lib(1) // 0600 +`, +[{"start":0,"end":649,"count":1}, +{"start":0,"end":351,"count":1}, +{"start":115,"end":205,"count":0}, +{"start":253,"end":303,"count":0}, +{"start":400,"end":551,"count":0}] +); + +TestCoverage( +"Variant with omitted brackets", +` +function lib (n) { // 0000 + if (n >= 0) { // 0050 + if (n < 0) // 0100 + return; // 0150 + } // 0200 + else if (foo()); // 0250 +} // 0300 +function foo () { // 0350 + console.log('foo') // 0400 + return false // 0450 +} // 0500 +lib(1) // 0550 +`, +[{"start":0,"end":599,"count":1}, +{"start":0,"end":301,"count":1}, +{"start":156,"end":163,"count":0}, +{"start":203,"end":268,"count":0}, +{"start":350,"end":501,"count":0}] +); + +%DebugToggleBlockCoverage(false); diff --git a/deps/v8/test/mjsunit/regress/regress-8265.js b/deps/v8/test/mjsunit/regress/regress-8265.js new file mode 100644 index 0000000000..ffe6191c9f --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-8265.js @@ -0,0 +1,12 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --random-seed=1 + +for (let i = 0; i < 54; ++i) Math.random(); +let sum = 0; +for (let i = 0; i < 10; ++i) + sum += Math.floor(Math.random() * 50); + +assertNotEquals(0, sum); diff --git a/deps/v8/test/mjsunit/regress/regress-8449.js b/deps/v8/test/mjsunit/regress/regress-8449.js new file mode 100644 index 0000000000..32fa82aa6e --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-8449.js @@ -0,0 +1,25 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +{ + const x = [, 1]; + x.__proto__ = [42]; + const y = [...x]; + assertEquals([42, 1], y); + assertTrue(y.hasOwnProperty(0)); +} + +{ + const x = [, 1]; + x.__proto__ = [42]; + assertEquals(42, x[Symbol.iterator]().next().value); +} + +{ + const array_prototype = [].__proto__; + array_prototype[0] = 42; + const x = [, 1]; + assertEquals(42, x[Symbol.iterator]().next().value); + delete array_prototype[0]; +} diff --git a/deps/v8/test/mjsunit/regress/regress-883059.js b/deps/v8/test/mjsunit/regress/regress-883059.js new file mode 100644 index 0000000000..ed70feddb4 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-883059.js @@ -0,0 +1,7 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --random-seed=-1595876594 --disable-in-process-stack-traces --no-lazy + +var __v_47 = ({[__v_46]: __f_52}) => { var __v_46 = 'b'; return __f_52; }; diff --git a/deps/v8/test/mjsunit/regress/regress-889722.js b/deps/v8/test/mjsunit/regress/regress-889722.js new file mode 100644 index 0000000000..c883dbe489 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-889722.js @@ -0,0 +1,11 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +function getRandomProperty(v, rand) { + var properties = Object.getOwnPropertyNames(v); + return properties[rand % properties.length]; +} +r = Realm.create(); +o = Realm.eval(r, "() => { return Realm.global(-10) instanceof Object }"); +o.__p_211203344 = o[getRandomProperty(o, 211203344)]; diff --git a/deps/v8/test/mjsunit/regress/regress-890553.js b/deps/v8/test/mjsunit/regress/regress-890553.js new file mode 100644 index 0000000000..33f13e8f26 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-890553.js @@ -0,0 +1,11 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +"use strict"; +var s = "function __f_9(func, testName) {" + + "var __v_0 = function __f_10(__v_14, __v_14) {" + + " return __v_16;" + + "}; " + +"}" +assertThrows(function() { eval(s); }); diff --git a/deps/v8/test/mjsunit/regress/regress-2185.js b/deps/v8/test/mjsunit/regress/regress-892858.js index 9b91066f33..ec921e3d43 100644 --- a/deps/v8/test/mjsunit/regress/regress-2185.js +++ b/deps/v8/test/mjsunit/regress/regress-892858.js @@ -1,4 +1,4 @@ -// Copyright 2012 the V8 project authors. All rights reserved. +// Copyright 2018 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: @@ -25,14 +25,8 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --noenable-slow-asserts - -var a = []; - -for (var i = 0; i < 2; i++) { - for (var j = 0; j < 30000; j++) { - a.push(j); - } +async function foo() { + await Promise.resolve(42); } -a.sort(function(a, b) { return a - b; } ); +foo(); diff --git a/deps/v8/test/mjsunit/regress/regress-arrow-single-expression-eval.js b/deps/v8/test/mjsunit/regress/regress-arrow-single-expression-eval.js new file mode 100644 index 0000000000..83a9ca1a56 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-arrow-single-expression-eval.js @@ -0,0 +1,5 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +((x=1) => eval("var x = 10"))(); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-380671.js b/deps/v8/test/mjsunit/regress/regress-crbug-380671.js deleted file mode 100644 index e2909e0a43..0000000000 --- a/deps/v8/test/mjsunit/regress/regress-crbug-380671.js +++ /dev/null @@ -1,14 +0,0 @@ -// Copyright 2015 the V8 project authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -// Flags: --mock-arraybuffer-allocator --expose-gc - -var buffer = new ArrayBuffer(0xc0000000); -assertEquals(0xc0000000, buffer.byteLength); -// We call the GC here to free up the large array buffer. Otherwise, the -// mock allocator would allow us to allocate more than the physical memory -// available on 32bit platforms, leaving the internal counters in an invalid -// state. -buffer = null; -gc(); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-503578.js b/deps/v8/test/mjsunit/regress/regress-crbug-503578.js index 1274d91ffe..59c33da20e 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-503578.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-503578.js @@ -8,7 +8,7 @@ if (this.Worker) { var __v_5 = new Uint32Array(__v_1); return __v_5; } - var __v_6 = new Worker('onmessage = function() {}'); + var __v_6 = new Worker('onmessage = function() {}', {type: 'string'}); var __v_3 = __f_0(16); __v_6.postMessage(__v_3); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-503698.js b/deps/v8/test/mjsunit/regress/regress-crbug-503698.js index 415d1bc81b..c817bede29 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-503698.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-503698.js @@ -5,5 +5,5 @@ // Flags: --invoke-weak-callbacks if (this.Worker) { - var __v_6 = new Worker(''); + var __v_6 = new Worker('', {type: 'string'}); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-503968.js b/deps/v8/test/mjsunit/regress/regress-crbug-503968.js index 78d1c7b98a..0552163144 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-503968.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-503968.js @@ -8,6 +8,6 @@ if (this.Worker) { this.l = [new __f_0, new __f_0]; } __v_6 = new __f_1; - var __v_9 = new Worker(''); + var __v_9 = new Worker('', {type: 'string'}); __v_9.postMessage(__v_6); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-503991.js b/deps/v8/test/mjsunit/regress/regress-crbug-503991.js index 6a3b0de759..7b96e92677 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-503991.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-503991.js @@ -4,6 +4,6 @@ if (this.Worker) { __v_3 = ""; - var __v_6 = new Worker(''); + var __v_6 = new Worker('', {type: 'string'}); __v_6.postMessage(__v_3); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-504136.js b/deps/v8/test/mjsunit/regress/regress-crbug-504136.js index 4ed6843544..25b11e0fec 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-504136.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-504136.js @@ -3,7 +3,7 @@ // found in the LICENSE file. if (this.Worker) { - var __v_10 = new Worker(''); + var __v_10 = new Worker('', {type: 'string'}); __v_10.terminate(); __v_10.getMessage(); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-504727.js b/deps/v8/test/mjsunit/regress/regress-crbug-504727.js index 16d8ff16cd..a295a1bd35 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-504727.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-504727.js @@ -5,5 +5,5 @@ // Flags: --no-test if (this.Worker) { - var __v_2 = new Worker(''); + var __v_2 = new Worker('', {type: 'string'}); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-504729.js b/deps/v8/test/mjsunit/regress/regress-crbug-504729.js index 435cafee87..8b1f8b0899 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-504729.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-504729.js @@ -5,5 +5,5 @@ if (this.Worker) { Function.prototype.toString = "foo"; function __f_7() {} - assertThrows(function() { var __v_5 = new Worker(__f_7.toString()); }); + assertThrows(function() { var __v_5 = new Worker(__f_7.toString(), {type: 'string'}) }); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-505778.js b/deps/v8/test/mjsunit/regress/regress-crbug-505778.js index 74d96ab094..3d87ba6982 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-505778.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-505778.js @@ -3,6 +3,6 @@ // found in the LICENSE file. if (this.Worker) { - var __v_7 = new Worker('onmessage = function() {}'); + var __v_7 = new Worker('onmessage = function() {}', {type: 'string'}); __v_7.postMessage(""); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-506549.js b/deps/v8/test/mjsunit/regress/regress-crbug-506549.js index 40e162caf5..219fd10cb7 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-506549.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-506549.js @@ -5,6 +5,6 @@ if (this.Worker) { var __v_5 = {}; __v_5.__defineGetter__('byteLength', function() {foo();}); - var __v_8 = new Worker('onmessage = function() {};'); + var __v_8 = new Worker('onmessage = function() {};', {type: 'string'}); assertThrows(function() { __v_8.postMessage(__v_5); }); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-511880.js b/deps/v8/test/mjsunit/regress/regress-crbug-511880.js index f9b05ff7bc..5dceb2a733 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-511880.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-511880.js @@ -4,10 +4,10 @@ if (this.Worker) { var __v_8 = - `var __v_9 = new Worker('postMessage(42)'); + `var __v_9 = new Worker('postMessage(42)', {type: 'string'}); onmessage = function(parentMsg) { __v_9.postMessage(parentMsg); };`; - var __v_9 = new Worker(__v_8); + var __v_9 = new Worker(__v_8, {type: 'string'}); __v_9.postMessage(9); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-514081.js b/deps/v8/test/mjsunit/regress/regress-crbug-514081.js index ee3ed81300..3d99b4586b 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-514081.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-514081.js @@ -3,7 +3,7 @@ // found in the LICENSE file. if (this.Worker) { - var __v_7 = new Worker('onmessage = function() {};'); + var __v_7 = new Worker('onmessage = function() {};', {type: 'string'}); var e; var ab = new ArrayBuffer(2 * 1000 * 1000); try { diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-518747.js b/deps/v8/test/mjsunit/regress/regress-crbug-518747.js index f1787c4c4b..2a4058d401 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-518747.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-518747.js @@ -4,6 +4,6 @@ if (this.Worker) { Worker.prototype = 12; - var __v_6 = new Worker(''); + var __v_6 = new Worker('', {type: 'string'}); __v_6.postMessage([]); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-522496.js b/deps/v8/test/mjsunit/regress/regress-crbug-522496.js index e47e0a0677..4dea5a89ac 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-522496.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-522496.js @@ -3,7 +3,7 @@ // found in the LICENSE file. if (this.Worker) { - var worker = new Worker("onmessage = function(){}"); + var worker = new Worker("onmessage = function(){}", {type: 'string'}); var buf = new ArrayBuffer(); worker.postMessage(buf, [buf]); } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-687063.js b/deps/v8/test/mjsunit/regress/regress-crbug-687063.js new file mode 100644 index 0000000000..8c579331fb --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-687063.js @@ -0,0 +1,31 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Collect the actual properties looked up on the Proxy. +const actual = []; + +// Perform a relational comparison with a Proxy on the right hand +// side and a Symbol which cannot be turned into a Number on the +// left hand side. +function foo() { + actual.length = 0; + const lhs = Symbol(); + const rhs = new Proxy({}, { + get: function(target, property, receiver) { + actual.push(property); + return undefined; + } + }); + return lhs < rhs; +} + +assertThrows(foo, TypeError); +assertEquals([Symbol.toPrimitive, 'valueOf', 'toString'], actual); +assertThrows(foo, TypeError); +assertEquals([Symbol.toPrimitive, 'valueOf', 'toString'], actual); +%OptimizeFunctionOnNextCall(foo); +assertThrows(foo, TypeError); +assertEquals([Symbol.toPrimitive, 'valueOf', 'toString'], actual); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-722871.js b/deps/v8/test/mjsunit/regress/regress-crbug-722871.js index c5b7958f49..e71f083be6 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-722871.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-722871.js @@ -7,7 +7,7 @@ let workers = []; let runningWorkers = 0; function startWorker(script) { - let worker = new Worker(script); + let worker = new Worker(script, {type: 'string'}); worker.done = false; worker.idx = workers.length; workers.push(worker); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-876443.js b/deps/v8/test/mjsunit/regress/regress-crbug-876443.js new file mode 100644 index 0000000000..33ffa020f3 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-876443.js @@ -0,0 +1,9 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Flags: + +var a = [5.65]; +a.splice(0); +var b = a.splice(-4, 9, 10); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-878845.js b/deps/v8/test/mjsunit/regress/regress-crbug-878845.js new file mode 100644 index 0000000000..2913f9e849 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-878845.js @@ -0,0 +1,11 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +let arr = [, 0.1]; + +Array.prototype.lastIndexOf.call(arr, 100, { + valueOf() { + arr.length = 0; + } +}); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-879560.js b/deps/v8/test/mjsunit/regress/regress-crbug-879560.js new file mode 100644 index 0000000000..a17deadfcd --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-879560.js @@ -0,0 +1,14 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +function foo() { + var x = 1; + x = undefined; + while (x--) ; +} +foo(); +%OptimizeFunctionOnNextCall(foo); +foo(); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-879898.js b/deps/v8/test/mjsunit/regress/regress-crbug-879898.js new file mode 100644 index 0000000000..c97001ae5c --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-879898.js @@ -0,0 +1,12 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +function foo() { + return Symbol.toPrimitive++; +} +assertThrows(foo); +%OptimizeFunctionOnNextCall(foo); +assertThrows(foo); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-880207.js b/deps/v8/test/mjsunit/regress/regress-crbug-880207.js new file mode 100644 index 0000000000..09796a9ff4 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-880207.js @@ -0,0 +1,37 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +(function TestOptimizedFastExpm1MinusZero() { + function foo() { + return Object.is(Math.expm1(-0), -0); + } + + assertTrue(foo()); + %OptimizeFunctionOnNextCall(foo); + assertTrue(foo()); +})(); + +(function TestOptimizedExpm1MinusZeroSlowPath() { + function f(x) { + return Object.is(Math.expm1(x), -0); + } + + function g() { + return f(-0); + } + + f(0); + // Compile function optimistically for numbers (with fast inlined + // path for Math.expm1). + %OptimizeFunctionOnNextCall(f); + // Invalidate the optimistic assumption, deopting and marking non-number + // input feedback in the call IC. + f("0"); + // Optimize again, now with non-lowered call to Math.expm1. + assertTrue(g()); + %OptimizeFunctionOnNextCall(g); + assertTrue(g()); +})(); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-882233-1.js b/deps/v8/test/mjsunit/regress/regress-crbug-882233-1.js new file mode 100644 index 0000000000..197660a683 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-882233-1.js @@ -0,0 +1,17 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Intended to test bug [882233] on CSA fast-path. + +let array = []; +Object.defineProperty(array, 'length', {writable: false}); + +assertEquals(array.length, 0); +assertThrows(() => array.shift(), TypeError); + +let object = { length: 0 }; +Object.defineProperty(object, 'length', {writable: false}); + +assertEquals(object.length, 0); +assertThrows(() => Array.prototype.shift.call(object)); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-882233-2.js b/deps/v8/test/mjsunit/regress/regress-crbug-882233-2.js new file mode 100644 index 0000000000..565e5fbc23 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-882233-2.js @@ -0,0 +1,32 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt + +// Intended to test bug [882233] on TF inlined (js-call-reducer) path. + +function shift_array() { + let array = []; + Object.defineProperty(array, 'length', {writable : false}); + return array.shift(); +} + +assertThrows(shift_array); +assertThrows(shift_array); +%OptimizeFunctionOnNextCall(shift_array); +assertThrows(shift_array); +assertOptimized(shift_array); + + +function shift_object() { + let object = { length: 0 }; + Object.defineProperty(object, 'length', {writable : false}); + return object.shift(); +} + +assertThrows(shift_object); +assertThrows(shift_object); +%OptimizeFunctionOnNextCall(shift_object); +assertThrows(shift_object); +assertOptimized(shift_object); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-884933.js b/deps/v8/test/mjsunit/regress/regress-crbug-884933.js new file mode 100644 index 0000000000..447d303bbf --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-884933.js @@ -0,0 +1,85 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Test Uint8 -> Word64 conversions. +(function() { + function bar(x, y) { + return x + y; + } + + bar(0.1, 0.2); + bar(0.1, 0.2); + + function foo(dv) { + return bar(dv.getUint8(0, true), 0xFFFFFFFF); + } + + const dv = new DataView(new ArrayBuffer(8)); + assertEquals(0xFFFFFFFF, foo(dv)); + assertEquals(0xFFFFFFFF, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0xFFFFFFFF, foo(dv)); +})(); + +// Test Int8 -> Word64 conversions. +(function() { + function bar(x, y) { + return x + y; + } + + bar(0.1, 0.2); + bar(0.1, 0.2); + + function foo(dv) { + return bar(dv.getInt8(0, true), 0xFFFFFFFF); + } + + const dv = new DataView(new ArrayBuffer(8)); + assertEquals(0xFFFFFFFF, foo(dv)); + assertEquals(0xFFFFFFFF, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0xFFFFFFFF, foo(dv)); +})(); + +// Test Uint16 -> Word64 conversions. +(function() { + function bar(x, y) { + return x + y; + } + + bar(0.1, 0.2); + bar(0.1, 0.2); + + function foo(dv) { + return bar(dv.getUint16(0, true), 0xFFFFFFFF); + } + + const dv = new DataView(new ArrayBuffer(8)); + assertEquals(0xFFFFFFFF, foo(dv)); + assertEquals(0xFFFFFFFF, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0xFFFFFFFF, foo(dv)); +})(); + +// Test Int16 -> Word64 conversions. +(function() { + function bar(x, y) { + return x + y; + } + + bar(0.1, 0.2); + bar(0.1, 0.2); + + function foo(dv) { + return bar(dv.getInt16(0, true), 0xFFFFFFFF); + } + + const dv = new DataView(new ArrayBuffer(8)); + assertEquals(0xFFFFFFFF, foo(dv)); + assertEquals(0xFFFFFFFF, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0xFFFFFFFF, foo(dv)); +})(); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-885404.js b/deps/v8/test/mjsunit/regress/regress-crbug-885404.js new file mode 100644 index 0000000000..534b883a01 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-885404.js @@ -0,0 +1,11 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --verify-heap --expose-gc + +var ab = new ArrayBuffer(2); +try { new Int32Array(ab); } catch (e) { } +assertEquals(2, ab.byteLength); +gc(); +assertEquals(2, ab.byteLength); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-887891.js b/deps/v8/test/mjsunit/regress/regress-crbug-887891.js new file mode 100644 index 0000000000..0e72ab263a --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-887891.js @@ -0,0 +1,10 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --verify-heap + +const l = 1000000000; +const a = []; +function foo() { var x = new Int32Array(l); } +try { foo(); } catch (e) { } diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-888825.js b/deps/v8/test/mjsunit/regress/regress-crbug-888825.js new file mode 100644 index 0000000000..9aa52d62e1 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-888825.js @@ -0,0 +1,5 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +eval("((a=function g() { function g() {}}) => {})();"); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-890243.js b/deps/v8/test/mjsunit/regress/regress-crbug-890243.js new file mode 100644 index 0000000000..0d889b2787 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-890243.js @@ -0,0 +1,27 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// We need a SpeculativeNumberAdd with Number feedback. +function bar(x) { return x + x; } +bar(0.1); + +// We also need an indirection via an object field such +// that only after escape analysis TurboFan can figure +// out that the value `y` is actually a Number in the +// safe integer range. +function baz(y) { return {y}; } +baz(null); baz(0); + +// Now we can put all of that together to get a kRepBit +// use of a kWord64 value (on 64-bit architectures). +function foo(o) { + return !baz(bar(o.x)).y; +} + +assertFalse(foo({x:1})); +assertFalse(foo({x:1})); +%OptimizeFunctionOnNextCall(foo); +assertFalse(foo({x:1})); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-891627.js b/deps/v8/test/mjsunit/regress/regress-crbug-891627.js new file mode 100644 index 0000000000..afe4093c96 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-891627.js @@ -0,0 +1,43 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// We need a NumberModulus, so we make sure that we have a +// SpeculativeNumberModulus with Number feedback, and later +// on use it with known Number inputs (via the bitwise or), +// such that JSTypedLowering turns it into the NumberModulus. +function bar(x) { return x % 2; } +bar(0.1); + +// Check that the Word32->Float64 conversion works properly. +(function() { + function foo(x) { + // The NumberEqual identifies 0 and -0. + return bar(x | -1) == 4294967295; + } + + assertFalse(foo(1)); + assertFalse(foo(0)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(1)); + assertFalse(foo(0)); +})(); + +// Check that the Word32->Word32 conversion works properly. +(function() { + function makeFoo(y) { + return function foo(x) { + return bar(x | -1) == y; + } + } + makeFoo(0); // Defeat the function context specialization. + const foo = makeFoo(1); + + assertFalse(foo(1)); + assertFalse(foo(0)); + %OptimizeFunctionOnNextCall(foo); + assertFalse(foo(1)); + assertFalse(foo(0)); +})(); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-892472-1.js b/deps/v8/test/mjsunit/regress/regress-crbug-892472-1.js new file mode 100644 index 0000000000..d6332fd399 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-892472-1.js @@ -0,0 +1,9 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --async-stack-traces + +const a = /x/; +a.exec = RegExp.prototype.test; +assertThrows(() => RegExp.prototype.test.call(a)); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-892472-2.js b/deps/v8/test/mjsunit/regress/regress-crbug-892472-2.js new file mode 100644 index 0000000000..0f9a2c1816 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-892472-2.js @@ -0,0 +1,7 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --async-stack-traces + +assertThrows(_ => '' + {toString: Object.prototype.toLocaleString}); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-897514.js b/deps/v8/test/mjsunit/regress/regress-crbug-897514.js new file mode 100644 index 0000000000..822a6bcf5e --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-897514.js @@ -0,0 +1,26 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +// Create transtion => 'get a'. +let o = {}; +Object.defineProperty(o, 'a', { + enumerable: true, + configurable: true, + get: function() { return 7 } +}); + +function spread(o) { + let result = { ...o }; + %HeapObjectVerify(result); + return result; +} + +for (let i = 0; i<3; i++) { + spread([]); + // Use different transition => 'a'. + spread({ a:0 }); + spread("abc"); +} diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-899524.js b/deps/v8/test/mjsunit/regress/regress-crbug-899524.js new file mode 100644 index 0000000000..32d28c9b09 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-899524.js @@ -0,0 +1,33 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +function empty() { } + +function baz(expected, found) { + var start = ""; + found.length, start + 'x'; + if (expected.length === found.length) { + for (var i = 0; i < expected.length; ++i) { + empty(found[i]); + } + } +} + +baz([1], new (class A extends Array {})); + +(function () { + "use strict"; + function bar() { + baz([1,2], arguments); + } + function foo() { + bar(2147483648,-[]); + } + foo(); + foo(); + %OptimizeFunctionOnNextCall(foo); + foo(); +})(); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-90771.js b/deps/v8/test/mjsunit/regress/regress-crbug-90771.js new file mode 100644 index 0000000000..b541ff8cc2 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-90771.js @@ -0,0 +1,15 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + + +// Flags: --allow-natives-syntax +function target() {}; + +for (let key of Object.getOwnPropertyNames(this)) { + try { + let newTarget = this[key]; + let arg = target; + Reflect.construct(target, arg, newTarget); + } catch {} +} diff --git a/deps/v8/test/mjsunit/regress/regress-v8-7682.js b/deps/v8/test/mjsunit/regress/regress-v8-7682.js index 4f9b2e7d60..86f12f5b74 100644 --- a/deps/v8/test/mjsunit/regress/regress-v8-7682.js +++ b/deps/v8/test/mjsunit/regress/regress-v8-7682.js @@ -18,5 +18,9 @@ class MyArrayLike { const xs = new MyArrayLike(); Array.prototype.sort.call(xs); -assertEquals(1, xs[0]); -assertEquals(2, xs[1]); +// Sort-order is implementation-defined as we actually hit two conditions from +// the spec: +// - "xs" is sparse and IsExtensible(xs) is false (its frozen). +// - "xs" is sparse and the prototype has properties in the sort range. +assertEquals(2, xs[0]); +assertEquals(1, xs[1]); diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-801850.js b/deps/v8/test/mjsunit/regress/wasm/regress-801850.js index ad6ff4c432..b56af694a9 100644 --- a/deps/v8/test/mjsunit/regress/wasm/regress-801850.js +++ b/deps/v8/test/mjsunit/regress/wasm/regress-801850.js @@ -7,5 +7,5 @@ load('test/mjsunit/wasm/wasm-module-builder.js'); var builder = new WasmModuleBuilder(); let module = new WebAssembly.Module(builder.toBuffer()); -var worker = new Worker('onmessage = function() {};'); +var worker = new Worker('onmessage = function() {};', {type: 'string'}); worker.postMessage(module) diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-803427.js b/deps/v8/test/mjsunit/regress/wasm/regress-803427.js index 833b140fd4..d3ab31b4c9 100644 --- a/deps/v8/test/mjsunit/regress/wasm/regress-803427.js +++ b/deps/v8/test/mjsunit/regress/wasm/regress-803427.js @@ -9,5 +9,5 @@ load('test/mjsunit/wasm/wasm-module-builder.js'); var builder = new WasmModuleBuilder(); let module = new WebAssembly.Module(builder.toBuffer()); -var worker = new Worker('onmessage = function() {};'); +var worker = new Worker('onmessage = function() {};', {type: 'string'}); worker.postMessage(module) diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-8059.js b/deps/v8/test/mjsunit/regress/wasm/regress-8059.js index 5c421c4ee4..c30ed152f8 100644 --- a/deps/v8/test/mjsunit/regress/wasm/regress-8059.js +++ b/deps/v8/test/mjsunit/regress/wasm/regress-8059.js @@ -31,7 +31,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js"); Realm.shared = { m:module, s:workerScript }; let realmScript = ` - let worker = new Worker(Realm.shared.s); + let worker = new Worker(Realm.shared.s, {type: 'string'}); worker.postMessage(Realm.shared.m); let message = worker.getMessage(); worker.terminate(); diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-808012.js b/deps/v8/test/mjsunit/regress/wasm/regress-808012.js index 1b91f226a8..ae613ceb54 100644 --- a/deps/v8/test/mjsunit/regress/wasm/regress-808012.js +++ b/deps/v8/test/mjsunit/regress/wasm/regress-808012.js @@ -10,5 +10,5 @@ load('test/mjsunit/wasm/wasm-module-builder.js'); const builder = new WasmModuleBuilder(); builder.addFunction('test', kSig_i_i).addBody([kExprUnreachable]); let module = new WebAssembly.Module(builder.toBuffer()); -var worker = new Worker('onmessage = function() {};'); +var worker = new Worker('onmessage = function() {};', {type: 'string'}); worker.postMessage(module); diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-808848.js b/deps/v8/test/mjsunit/regress/wasm/regress-808848.js index 69423b954d..bcf8469a14 100644 --- a/deps/v8/test/mjsunit/regress/wasm/regress-808848.js +++ b/deps/v8/test/mjsunit/regress/wasm/regress-808848.js @@ -60,7 +60,7 @@ let worker_onmessage = function(msg) { } let workerScript = "onmessage = " + worker_onmessage.toString(); -let worker = new Worker(workerScript); +let worker = new Worker(workerScript, {type: 'string'}); worker.postMessage({serialized_m1, m1_bytes}); // Wait for worker to finish. diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-8094.js b/deps/v8/test/mjsunit/regress/wasm/regress-8094.js new file mode 100644 index 0000000000..a35d583a4a --- /dev/null +++ b/deps/v8/test/mjsunit/regress/wasm/regress-8094.js @@ -0,0 +1,30 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --expose-wasm --experimental-wasm-eh + +load("test/mjsunit/wasm/wasm-constants.js"); +load("test/mjsunit/wasm/wasm-module-builder.js"); + +// Instantiate a throwing module. +var builder = new WasmModuleBuilder(); +builder.addException(kSig_v_v); +builder.addFunction("propel", kSig_v_v) + .addBody([kExprThrow, 0]) + .exportFunc(); +var instance = builder.instantiate(); + +// Catch the exception. +var exception; +try { + instance.exports.propel(); +} catch (e) { + exception = e; +} + +// Check that the exception is an instance of the correct error function and +// that no extraneous properties exist. Setting such properties could be +// observable by JavaScript and could break compatibility. +assertInstanceof(exception, WebAssembly.RuntimeError); +assertArrayEquals(["stack", "message"], Object.getOwnPropertyNames(exception)); diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-8095.js b/deps/v8/test/mjsunit/regress/wasm/regress-8095.js new file mode 100644 index 0000000000..66ffc0d4b7 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/wasm/regress-8095.js @@ -0,0 +1,25 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --expose-wasm --experimental-wasm-eh + +load("test/mjsunit/wasm/wasm-constants.js"); +load("test/mjsunit/wasm/wasm-module-builder.js"); + +// Prepare a special error object to throw. +var error = new Error("my error"); +error.__proto__ = new Proxy(new Error(), { + has(target, property, receiver) { + assertUnreachable(); + } +}); + +// Throw it through a WebAssembly module. +var builder = new WasmModuleBuilder(); +builder.addImport('mod', 'fun', kSig_v_v); +builder.addFunction("funnel", kSig_v_v) + .addBody([kExprCallFunction, 0]) + .exportFunc(); +var instance = builder.instantiate({ mod: {fun: function() { throw error }}}); +assertThrows(instance.exports.funnel, Error); diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-810973.js b/deps/v8/test/mjsunit/regress/wasm/regress-810973.js index 5a776884ee..bd3d902772 100644 --- a/deps/v8/test/mjsunit/regress/wasm/regress-810973.js +++ b/deps/v8/test/mjsunit/regress/wasm/regress-810973.js @@ -12,7 +12,7 @@ function MjsUnitAssertionError() { }; let __v_692 = `(function module() { "use asm";function foo(`; const __v_693 = -3695; +1005; for (let __v_695 = 0; __v_695 < __v_693; ++__v_695) { __v_692 += `arg${__v_695},`; } @@ -28,5 +28,6 @@ for (let __v_697 = 0; __v_697 < __v_693; ++__v_697) { } __v_692 += "1.0)|0;}"; - __v_692 += "return bar})()()"; +__v_692 += "return bar})()()"; + const __v_694 = eval(__v_692); diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-810973b.js b/deps/v8/test/mjsunit/regress/wasm/regress-810973b.js new file mode 100644 index 0000000000..227bf55fc0 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/wasm/regress-810973b.js @@ -0,0 +1,1209 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +(function module() { + "use asm"; + function foo( + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, + a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, + a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, + a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, + a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, + a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, + a62, a63, a64, a65, a66, a67, a68, a69, a70, a71, + a72, a73, a74, a75, a76, a77, a78, a79, a80, a81, + a82, a83, a84, a85, a86, a87, a88, a89, a90, a91, + a92, a93, a94, a95, a96, a97, a98, a99, a100, a101, + a102, a103, a104, a105, a106, a107, a108, a109, a110, + a111, a112, a113, a114, a115, a116, a117, a118, a119, + a120, a121, a122, a123, a124, a125, a126, a127, a128, + a129, a130, a131, a132, a133, a134, a135, a136, a137, + a138, a139, a140, a141, a142, a143, a144, a145, a146, + a147, a148, a149, a150, a151, a152, a153, a154, a155, + a156, a157, a158, a159, a160, a161, a162, a163, a164, + a165, a166, a167, a168, a169, a170, a171, a172, a173, + a174, a175, a176, a177, a178, a179, a180, a181, a182, + a183, a184, a185, a186, a187, a188, a189, a190, a191, + a192, a193, a194, a195, a196, a197, a198, a199, a200, + a201, a202, a203, a204, a205, a206, a207, a208, a209, + a210, a211, a212, a213, a214, a215, a216, a217, a218, + a219, a220, a221, a222, a223, a224, a225, a226, a227, + a228, a229, a230, a231, a232, a233, a234, a235, a236, + a237, a238, a239, a240, a241, a242, a243, a244, a245, + a246, a247, a248, a249, a250, a251, a252, a253, a254, + a255, a256, a257, a258, a259, a260, a261, a262, a263, + a264, a265, a266, a267, a268, a269, a270, a271, a272, + a273, a274, a275, a276, a277, a278, a279, a280, a281, + a282, a283, a284, a285, a286, a287, a288, a289, a290, + a291, a292, a293, a294, a295, a296, a297, a298, a299, + a300, a301, a302, a303, a304, a305, a306, a307, a308, + a309, a310, a311, a312, a313, a314, a315, a316, a317, + a318, a319, a320, a321, a322, a323, a324, a325, a326, + a327, a328, a329, a330, a331, a332, a333, a334, a335, + a336, a337, a338, a339, a340, a341, a342, a343, a344, + a345, a346, a347, a348, a349, a350, a351, a352, a353, + a354, a355, a356, a357, a358, a359, a360, a361, a362, + a363, a364, a365, a366, a367, a368, a369, a370, a371, + a372, a373, a374, a375, a376, a377, a378, a379, a380, + a381, a382, a383, a384, a385, a386, a387, a388, a389, + a390, a391, a392, a393, a394, a395, a396, a397, a398, + a399, a400, a401, a402, a403, a404, a405, a406, a407, + a408, a409, a410, a411, a412, a413, a414, a415, a416, + a417, a418, a419, a420, a421, a422, a423, a424, a425, + a426, a427, a428, a429, a430, a431, a432, a433, a434, + a435, a436, a437, a438, a439, a440, a441, a442, a443, + a444, a445, a446, a447, a448, a449, a450, a451, a452, + a453, a454, a455, a456, a457, a458, a459, a460, a461, + a462, a463, a464, a465, a466, a467, a468, a469, a470, + a471, a472, a473, a474, a475, a476, a477, a478, a479, + a480, a481, a482, a483, a484, a485, a486, a487, a488, + a489, a490, a491, a492, a493, a494, a495, a496, a497, + a498, a499, a500, a501, a502, a503, a504, a505, a506, + a507, a508, a509, a510, a511, a512, a513, a514, a515, + a516, a517, a518, a519, a520, a521, a522, a523, a524, + a525, a526, a527, a528, a529, a530, a531, a532, a533, + a534, a535, a536, a537, a538, a539, a540, a541, a542, + a543, a544, a545, a546, a547, a548, a549, a550, a551, + a552, a553, a554, a555, a556, a557, a558, a559, a560, + a561, a562, a563, a564, a565, a566, a567, a568, a569, + a570, a571, a572, a573, a574, a575, a576, a577, a578, + a579, a580, a581, a582, a583, a584, a585, a586, a587, + a588, a589, a590, a591, a592, a593, a594, a595, a596, + a597, a598, a599, a600, a601, a602, a603, a604, a605, + a606, a607, a608, a609, a610, a611, a612, a613, a614, + a615, a616, a617, a618, a619, a620, a621, a622, a623, + a624, a625, a626, a627, a628, a629, a630, a631, a632, + a633, a634, a635, a636, a637, a638, a639, a640, a641, + a642, a643, a644, a645, a646, a647, a648, a649, a650, + a651, a652, a653, a654, a655, a656, a657, a658, a659, + a660, a661, a662, a663, a664, a665, a666, a667, a668, + a669, a670, a671, a672, a673, a674, a675, a676, a677, + a678, a679, a680, a681, a682, a683, a684, a685, a686, + a687, a688, a689, a690, a691, a692, a693, a694, a695, + a696, a697, a698, a699, a700, a701, a702, a703, a704, + a705, a706, a707, a708, a709, a710, a711, a712, a713, + a714, a715, a716, a717, a718, a719, a720, a721, a722, + a723, a724, a725, a726, a727, a728, a729, a730, a731, + a732, a733, a734, a735, a736, a737, a738, a739, a740, + a741, a742, a743, a744, a745, a746, a747, a748, a749, + a750, a751, a752, a753, a754, a755, a756, a757, a758, + a759, a760, a761, a762, a763, a764, a765, a766, a767, + a768, a769, a770, a771, a772, a773, a774, a775, a776, + a777, a778, a779, a780, a781, a782, a783, a784, a785, + a786, a787, a788, a789, a790, a791, a792, a793, a794, + a795, a796, a797, a798, a799, a800, a801, a802, a803, + a804, a805, a806, a807, a808, a809, a810, a811, a812, + a813, a814, a815, a816, a817, a818, a819, a820, a821, + a822, a823, a824, a825, a826, a827, a828, a829, a830, + a831, a832, a833, a834, a835, a836, a837, a838, a839, + a840, a841, a842, a843, a844, a845, a846, a847, a848, + a849, a850, a851, a852, a853, a854, a855, a856, a857, + a858, a859, a860, a861, a862, a863, a864, a865, a866, + a867, a868, a869, a870, a871, a872, a873, a874, a875, + a876, a877, a878, a879, a880, a881, a882, a883, a884, + a885, a886, a887, a888, a889, a890, a891, a892, a893, + a894, a895, a896, a897, a898, a899, a900, a901, a902, + a903, a904, a905, a906, a907, a908, a909, a910, a911, + a912, a913, a914, a915, a916, a917, a918, a919, a920, + a921, a922, a923, a924, a925, a926, a927, a928, a929, + a930, a931, a932, a933, a934, a935, a936, a937, a938, + a939, a940, a941, a942, a943, a944, a945, a946, a947, + a948, a949, a950, a951, a952, a953, a954, a955, a956, + a957, a958, a959, a960, a961, a962, a963, a964, a965, + a966, a967, a968, a969, a970, a971, a972, a973, a974, + a975, a976, a977, a978, a979, a980, a981, a982, a983, + a984, a985, a986, a987, a988, a989, a990, a991, a992, + a993, a994, a995, a996, a997, a998, a999, a1000, a1001, + a1002, a1003, a1004, a1005) { + a0 = +a0; + a1 = +a1; + a2 = +a2; + a3 = +a3; + a4 = +a4; + a5 = +a5; + a6 = +a6; + a7 = +a7; + a8 = +a8; + a9 = +a9; + a10 = +a10; + a11 = +a11; + a12 = +a12; + a13 = +a13; + a14 = +a14; + a15 = +a15; + a16 = +a16; + a17 = +a17; + a18 = +a18; + a19 = +a19; + a20 = +a20; + a21 = +a21; + a22 = +a22; + a23 = +a23; + a24 = +a24; + a25 = +a25; + a26 = +a26; + a27 = +a27; + a28 = +a28; + a29 = +a29; + a30 = +a30; + a31 = +a31; + a32 = +a32; + a33 = +a33; + a34 = +a34; + a35 = +a35; + a36 = +a36; + a37 = +a37; + a38 = +a38; + a39 = +a39; + a40 = +a40; + a41 = +a41; + a42 = +a42; + a43 = +a43; + a44 = +a44; + a45 = +a45; + a46 = +a46; + a47 = +a47; + a48 = +a48; + a49 = +a49; + a50 = +a50; + a51 = +a51; + a52 = +a52; + a53 = +a53; + a54 = +a54; + a55 = +a55; + a56 = +a56; + a57 = +a57; + a58 = +a58; + a59 = +a59; + a60 = +a60; + a61 = +a61; + a62 = +a62; + a63 = +a63; + a64 = +a64; + a65 = +a65; + a66 = +a66; + a67 = +a67; + a68 = +a68; + a69 = +a69; + a70 = +a70; + a71 = +a71; + a72 = +a72; + a73 = +a73; + a74 = +a74; + a75 = +a75; + a76 = +a76; + a77 = +a77; + a78 = +a78; + a79 = +a79; + a80 = +a80; + a81 = +a81; + a82 = +a82; + a83 = +a83; + a84 = +a84; + a85 = +a85; + a86 = +a86; + a87 = +a87; + a88 = +a88; + a89 = +a89; + a90 = +a90; + a91 = +a91; + a92 = +a92; + a93 = +a93; + a94 = +a94; + a95 = +a95; + a96 = +a96; + a97 = +a97; + a98 = +a98; + a99 = +a99; + a100 = +a100; + a101 = +a101; + a102 = +a102; + a103 = +a103; + a104 = +a104; + a105 = +a105; + a106 = +a106; + a107 = +a107; + a108 = +a108; + a109 = +a109; + a110 = +a110; + a111 = +a111; + a112 = +a112; + a113 = +a113; + a114 = +a114; + a115 = +a115; + a116 = +a116; + a117 = +a117; + a118 = +a118; + a119 = +a119; + a120 = +a120; + a121 = +a121; + a122 = +a122; + a123 = +a123; + a124 = +a124; + a125 = +a125; + a126 = +a126; + a127 = +a127; + a128 = +a128; + a129 = +a129; + a130 = +a130; + a131 = +a131; + a132 = +a132; + a133 = +a133; + a134 = +a134; + a135 = +a135; + a136 = +a136; + a137 = +a137; + a138 = +a138; + a139 = +a139; + a140 = +a140; + a141 = +a141; + a142 = +a142; + a143 = +a143; + a144 = +a144; + a145 = +a145; + a146 = +a146; + a147 = +a147; + a148 = +a148; + a149 = +a149; + a150 = +a150; + a151 = +a151; + a152 = +a152; + a153 = +a153; + a154 = +a154; + a155 = +a155; + a156 = +a156; + a157 = +a157; + a158 = +a158; + a159 = +a159; + a160 = +a160; + a161 = +a161; + a162 = +a162; + a163 = +a163; + a164 = +a164; + a165 = +a165; + a166 = +a166; + a167 = +a167; + a168 = +a168; + a169 = +a169; + a170 = +a170; + a171 = +a171; + a172 = +a172; + a173 = +a173; + a174 = +a174; + a175 = +a175; + a176 = +a176; + a177 = +a177; + a178 = +a178; + a179 = +a179; + a180 = +a180; + a181 = +a181; + a182 = +a182; + a183 = +a183; + a184 = +a184; + a185 = +a185; + a186 = +a186; + a187 = +a187; + a188 = +a188; + a189 = +a189; + a190 = +a190; + a191 = +a191; + a192 = +a192; + a193 = +a193; + a194 = +a194; + a195 = +a195; + a196 = +a196; + a197 = +a197; + a198 = +a198; + a199 = +a199; + a200 = +a200; + a201 = +a201; + a202 = +a202; + a203 = +a203; + a204 = +a204; + a205 = +a205; + a206 = +a206; + a207 = +a207; + a208 = +a208; + a209 = +a209; + a210 = +a210; + a211 = +a211; + a212 = +a212; + a213 = +a213; + a214 = +a214; + a215 = +a215; + a216 = +a216; + a217 = +a217; + a218 = +a218; + a219 = +a219; + a220 = +a220; + a221 = +a221; + a222 = +a222; + a223 = +a223; + a224 = +a224; + a225 = +a225; + a226 = +a226; + a227 = +a227; + a228 = +a228; + a229 = +a229; + a230 = +a230; + a231 = +a231; + a232 = +a232; + a233 = +a233; + a234 = +a234; + a235 = +a235; + a236 = +a236; + a237 = +a237; + a238 = +a238; + a239 = +a239; + a240 = +a240; + a241 = +a241; + a242 = +a242; + a243 = +a243; + a244 = +a244; + a245 = +a245; + a246 = +a246; + a247 = +a247; + a248 = +a248; + a249 = +a249; + a250 = +a250; + a251 = +a251; + a252 = +a252; + a253 = +a253; + a254 = +a254; + a255 = +a255; + a256 = +a256; + a257 = +a257; + a258 = +a258; + a259 = +a259; + a260 = +a260; + a261 = +a261; + a262 = +a262; + a263 = +a263; + a264 = +a264; + a265 = +a265; + a266 = +a266; + a267 = +a267; + a268 = +a268; + a269 = +a269; + a270 = +a270; + a271 = +a271; + a272 = +a272; + a273 = +a273; + a274 = +a274; + a275 = +a275; + a276 = +a276; + a277 = +a277; + a278 = +a278; + a279 = +a279; + a280 = +a280; + a281 = +a281; + a282 = +a282; + a283 = +a283; + a284 = +a284; + a285 = +a285; + a286 = +a286; + a287 = +a287; + a288 = +a288; + a289 = +a289; + a290 = +a290; + a291 = +a291; + a292 = +a292; + a293 = +a293; + a294 = +a294; + a295 = +a295; + a296 = +a296; + a297 = +a297; + a298 = +a298; + a299 = +a299; + a300 = +a300; + a301 = +a301; + a302 = +a302; + a303 = +a303; + a304 = +a304; + a305 = +a305; + a306 = +a306; + a307 = +a307; + a308 = +a308; + a309 = +a309; + a310 = +a310; + a311 = +a311; + a312 = +a312; + a313 = +a313; + a314 = +a314; + a315 = +a315; + a316 = +a316; + a317 = +a317; + a318 = +a318; + a319 = +a319; + a320 = +a320; + a321 = +a321; + a322 = +a322; + a323 = +a323; + a324 = +a324; + a325 = +a325; + a326 = +a326; + a327 = +a327; + a328 = +a328; + a329 = +a329; + a330 = +a330; + a331 = +a331; + a332 = +a332; + a333 = +a333; + a334 = +a334; + a335 = +a335; + a336 = +a336; + a337 = +a337; + a338 = +a338; + a339 = +a339; + a340 = +a340; + a341 = +a341; + a342 = +a342; + a343 = +a343; + a344 = +a344; + a345 = +a345; + a346 = +a346; + a347 = +a347; + a348 = +a348; + a349 = +a349; + a350 = +a350; + a351 = +a351; + a352 = +a352; + a353 = +a353; + a354 = +a354; + a355 = +a355; + a356 = +a356; + a357 = +a357; + a358 = +a358; + a359 = +a359; + a360 = +a360; + a361 = +a361; + a362 = +a362; + a363 = +a363; + a364 = +a364; + a365 = +a365; + a366 = +a366; + a367 = +a367; + a368 = +a368; + a369 = +a369; + a370 = +a370; + a371 = +a371; + a372 = +a372; + a373 = +a373; + a374 = +a374; + a375 = +a375; + a376 = +a376; + a377 = +a377; + a378 = +a378; + a379 = +a379; + a380 = +a380; + a381 = +a381; + a382 = +a382; + a383 = +a383; + a384 = +a384; + a385 = +a385; + a386 = +a386; + a387 = +a387; + a388 = +a388; + a389 = +a389; + a390 = +a390; + a391 = +a391; + a392 = +a392; + a393 = +a393; + a394 = +a394; + a395 = +a395; + a396 = +a396; + a397 = +a397; + a398 = +a398; + a399 = +a399; + a400 = +a400; + a401 = +a401; + a402 = +a402; + a403 = +a403; + a404 = +a404; + a405 = +a405; + a406 = +a406; + a407 = +a407; + a408 = +a408; + a409 = +a409; + a410 = +a410; + a411 = +a411; + a412 = +a412; + a413 = +a413; + a414 = +a414; + a415 = +a415; + a416 = +a416; + a417 = +a417; + a418 = +a418; + a419 = +a419; + a420 = +a420; + a421 = +a421; + a422 = +a422; + a423 = +a423; + a424 = +a424; + a425 = +a425; + a426 = +a426; + a427 = +a427; + a428 = +a428; + a429 = +a429; + a430 = +a430; + a431 = +a431; + a432 = +a432; + a433 = +a433; + a434 = +a434; + a435 = +a435; + a436 = +a436; + a437 = +a437; + a438 = +a438; + a439 = +a439; + a440 = +a440; + a441 = +a441; + a442 = +a442; + a443 = +a443; + a444 = +a444; + a445 = +a445; + a446 = +a446; + a447 = +a447; + a448 = +a448; + a449 = +a449; + a450 = +a450; + a451 = +a451; + a452 = +a452; + a453 = +a453; + a454 = +a454; + a455 = +a455; + a456 = +a456; + a457 = +a457; + a458 = +a458; + a459 = +a459; + a460 = +a460; + a461 = +a461; + a462 = +a462; + a463 = +a463; + a464 = +a464; + a465 = +a465; + a466 = +a466; + a467 = +a467; + a468 = +a468; + a469 = +a469; + a470 = +a470; + a471 = +a471; + a472 = +a472; + a473 = +a473; + a474 = +a474; + a475 = +a475; + a476 = +a476; + a477 = +a477; + a478 = +a478; + a479 = +a479; + a480 = +a480; + a481 = +a481; + a482 = +a482; + a483 = +a483; + a484 = +a484; + a485 = +a485; + a486 = +a486; + a487 = +a487; + a488 = +a488; + a489 = +a489; + a490 = +a490; + a491 = +a491; + a492 = +a492; + a493 = +a493; + a494 = +a494; + a495 = +a495; + a496 = +a496; + a497 = +a497; + a498 = +a498; + a499 = +a499; + a500 = +a500; + a501 = +a501; + a502 = +a502; + a503 = +a503; + a504 = +a504; + a505 = +a505; + a506 = +a506; + a507 = +a507; + a508 = +a508; + a509 = +a509; + a510 = +a510; + a511 = +a511; + a512 = +a512; + a513 = +a513; + a514 = +a514; + a515 = +a515; + a516 = +a516; + a517 = +a517; + a518 = +a518; + a519 = +a519; + a520 = +a520; + a521 = +a521; + a522 = +a522; + a523 = +a523; + a524 = +a524; + a525 = +a525; + a526 = +a526; + a527 = +a527; + a528 = +a528; + a529 = +a529; + a530 = +a530; + a531 = +a531; + a532 = +a532; + a533 = +a533; + a534 = +a534; + a535 = +a535; + a536 = +a536; + a537 = +a537; + a538 = +a538; + a539 = +a539; + a540 = +a540; + a541 = +a541; + a542 = +a542; + a543 = +a543; + a544 = +a544; + a545 = +a545; + a546 = +a546; + a547 = +a547; + a548 = +a548; + a549 = +a549; + a550 = +a550; + a551 = +a551; + a552 = +a552; + a553 = +a553; + a554 = +a554; + a555 = +a555; + a556 = +a556; + a557 = +a557; + a558 = +a558; + a559 = +a559; + a560 = +a560; + a561 = +a561; + a562 = +a562; + a563 = +a563; + a564 = +a564; + a565 = +a565; + a566 = +a566; + a567 = +a567; + a568 = +a568; + a569 = +a569; + a570 = +a570; + a571 = +a571; + a572 = +a572; + a573 = +a573; + a574 = +a574; + a575 = +a575; + a576 = +a576; + a577 = +a577; + a578 = +a578; + a579 = +a579; + a580 = +a580; + a581 = +a581; + a582 = +a582; + a583 = +a583; + a584 = +a584; + a585 = +a585; + a586 = +a586; + a587 = +a587; + a588 = +a588; + a589 = +a589; + a590 = +a590; + a591 = +a591; + a592 = +a592; + a593 = +a593; + a594 = +a594; + a595 = +a595; + a596 = +a596; + a597 = +a597; + a598 = +a598; + a599 = +a599; + a600 = +a600; + a601 = +a601; + a602 = +a602; + a603 = +a603; + a604 = +a604; + a605 = +a605; + a606 = +a606; + a607 = +a607; + a608 = +a608; + a609 = +a609; + a610 = +a610; + a611 = +a611; + a612 = +a612; + a613 = +a613; + a614 = +a614; + a615 = +a615; + a616 = +a616; + a617 = +a617; + a618 = +a618; + a619 = +a619; + a620 = +a620; + a621 = +a621; + a622 = +a622; + a623 = +a623; + a624 = +a624; + a625 = +a625; + a626 = +a626; + a627 = +a627; + a628 = +a628; + a629 = +a629; + a630 = +a630; + a631 = +a631; + a632 = +a632; + a633 = +a633; + a634 = +a634; + a635 = +a635; + a636 = +a636; + a637 = +a637; + a638 = +a638; + a639 = +a639; + a640 = +a640; + a641 = +a641; + a642 = +a642; + a643 = +a643; + a644 = +a644; + a645 = +a645; + a646 = +a646; + a647 = +a647; + a648 = +a648; + a649 = +a649; + a650 = +a650; + a651 = +a651; + a652 = +a652; + a653 = +a653; + a654 = +a654; + a655 = +a655; + a656 = +a656; + a657 = +a657; + a658 = +a658; + a659 = +a659; + a660 = +a660; + a661 = +a661; + a662 = +a662; + a663 = +a663; + a664 = +a664; + a665 = +a665; + a666 = +a666; + a667 = +a667; + a668 = +a668; + a669 = +a669; + a670 = +a670; + a671 = +a671; + a672 = +a672; + a673 = +a673; + a674 = +a674; + a675 = +a675; + a676 = +a676; + a677 = +a677; + a678 = +a678; + a679 = +a679; + a680 = +a680; + a681 = +a681; + a682 = +a682; + a683 = +a683; + a684 = +a684; + a685 = +a685; + a686 = +a686; + a687 = +a687; + a688 = +a688; + a689 = +a689; + a690 = +a690; + a691 = +a691; + a692 = +a692; + a693 = +a693; + a694 = +a694; + a695 = +a695; + a696 = +a696; + a697 = +a697; + a698 = +a698; + a699 = +a699; + a700 = +a700; + a701 = +a701; + a702 = +a702; + a703 = +a703; + a704 = +a704; + a705 = +a705; + a706 = +a706; + a707 = +a707; + a708 = +a708; + a709 = +a709; + a710 = +a710; + a711 = +a711; + a712 = +a712; + a713 = +a713; + a714 = +a714; + a715 = +a715; + a716 = +a716; + a717 = +a717; + a718 = +a718; + a719 = +a719; + a720 = +a720; + a721 = +a721; + a722 = +a722; + a723 = +a723; + a724 = +a724; + a725 = +a725; + a726 = +a726; + a727 = +a727; + a728 = +a728; + a729 = +a729; + a730 = +a730; + a731 = +a731; + a732 = +a732; + a733 = +a733; + a734 = +a734; + a735 = +a735; + a736 = +a736; + a737 = +a737; + a738 = +a738; + a739 = +a739; + a740 = +a740; + a741 = +a741; + a742 = +a742; + a743 = +a743; + a744 = +a744; + a745 = +a745; + a746 = +a746; + a747 = +a747; + a748 = +a748; + a749 = +a749; + a750 = +a750; + a751 = +a751; + a752 = +a752; + a753 = +a753; + a754 = +a754; + a755 = +a755; + a756 = +a756; + a757 = +a757; + a758 = +a758; + a759 = +a759; + a760 = +a760; + a761 = +a761; + a762 = +a762; + a763 = +a763; + a764 = +a764; + a765 = +a765; + a766 = +a766; + a767 = +a767; + a768 = +a768; + a769 = +a769; + a770 = +a770; + a771 = +a771; + a772 = +a772; + a773 = +a773; + a774 = +a774; + a775 = +a775; + a776 = +a776; + a777 = +a777; + a778 = +a778; + a779 = +a779; + a780 = +a780; + a781 = +a781; + a782 = +a782; + a783 = +a783; + a784 = +a784; + a785 = +a785; + a786 = +a786; + a787 = +a787; + a788 = +a788; + a789 = +a789; + a790 = +a790; + a791 = +a791; + a792 = +a792; + a793 = +a793; + a794 = +a794; + a795 = +a795; + a796 = +a796; + a797 = +a797; + a798 = +a798; + a799 = +a799; + a800 = +a800; + a801 = +a801; + a802 = +a802; + a803 = +a803; + a804 = +a804; + a805 = +a805; + a806 = +a806; + a807 = +a807; + a808 = +a808; + a809 = +a809; + a810 = +a810; + a811 = +a811; + a812 = +a812; + a813 = +a813; + a814 = +a814; + a815 = +a815; + a816 = +a816; + a817 = +a817; + a818 = +a818; + a819 = +a819; + a820 = +a820; + a821 = +a821; + a822 = +a822; + a823 = +a823; + a824 = +a824; + a825 = +a825; + a826 = +a826; + a827 = +a827; + a828 = +a828; + a829 = +a829; + a830 = +a830; + a831 = +a831; + a832 = +a832; + a833 = +a833; + a834 = +a834; + a835 = +a835; + a836 = +a836; + a837 = +a837; + a838 = +a838; + a839 = +a839; + a840 = +a840; + a841 = +a841; + a842 = +a842; + a843 = +a843; + a844 = +a844; + a845 = +a845; + a846 = +a846; + a847 = +a847; + a848 = +a848; + a849 = +a849; + a850 = +a850; + a851 = +a851; + a852 = +a852; + a853 = +a853; + a854 = +a854; + a855 = +a855; + a856 = +a856; + a857 = +a857; + a858 = +a858; + a859 = +a859; + a860 = +a860; + a861 = +a861; + a862 = +a862; + a863 = +a863; + a864 = +a864; + a865 = +a865; + a866 = +a866; + a867 = +a867; + a868 = +a868; + a869 = +a869; + a870 = +a870; + a871 = +a871; + a872 = +a872; + a873 = +a873; + a874 = +a874; + a875 = +a875; + a876 = +a876; + a877 = +a877; + a878 = +a878; + a879 = +a879; + a880 = +a880; + a881 = +a881; + a882 = +a882; + a883 = +a883; + a884 = +a884; + a885 = +a885; + a886 = +a886; + a887 = +a887; + a888 = +a888; + a889 = +a889; + a890 = +a890; + a891 = +a891; + a892 = +a892; + a893 = +a893; + a894 = +a894; + a895 = +a895; + a896 = +a896; + a897 = +a897; + a898 = +a898; + a899 = +a899; + a900 = +a900; + a901 = +a901; + a902 = +a902; + a903 = +a903; + a904 = +a904; + a905 = +a905; + a906 = +a906; + a907 = +a907; + a908 = +a908; + a909 = +a909; + a910 = +a910; + a911 = +a911; + a912 = +a912; + a913 = +a913; + a914 = +a914; + a915 = +a915; + a916 = +a916; + a917 = +a917; + a918 = +a918; + a919 = +a919; + a920 = +a920; + a921 = +a921; + a922 = +a922; + a923 = +a923; + a924 = +a924; + a925 = +a925; + a926 = +a926; + a927 = +a927; + a928 = +a928; + a929 = +a929; + a930 = +a930; + a931 = +a931; + a932 = +a932; + a933 = +a933; + a934 = +a934; + a935 = +a935; + a936 = +a936; + a937 = +a937; + a938 = +a938; + a939 = +a939; + a940 = +a940; + a941 = +a941; + a942 = +a942; + a943 = +a943; + a944 = +a944; + a945 = +a945; + a946 = +a946; + a947 = +a947; + a948 = +a948; + a949 = +a949; + a950 = +a950; + a951 = +a951; + a952 = +a952; + a953 = +a953; + a954 = +a954; + a955 = +a955; + a956 = +a956; + a957 = +a957; + a958 = +a958; + a959 = +a959; + a960 = +a960; + a961 = +a961; + a962 = +a962; + a963 = +a963; + a964 = +a964; + a965 = +a965; + a966 = +a966; + a967 = +a967; + a968 = +a968; + a969 = +a969; + a970 = +a970; + a971 = +a971; + a972 = +a972; + a973 = +a973; + a974 = +a974; + a975 = +a975; + a976 = +a976; + a977 = +a977; + a978 = +a978; + a979 = +a979; + a980 = +a980; + a981 = +a981; + a982 = +a982; + a983 = +a983; + a984 = +a984; + a985 = +a985; + a986 = +a986; + a987 = +a987; + a988 = +a988; + a989 = +a989; + a990 = +a990; + a991 = +a991; + a992 = +a992; + a993 = +a993; + a994 = +a994; + a995 = +a995; + a996 = +a996; + a997 = +a997; + a998 = +a998; + a999 = +a999; + a1000 = +a1000; + a1001 = +a1001; + a1002 = +a1002; + a1003 = +a1003; + a1004 = +a1004; + a1005 = +a1005; + return 10; + } + function bar() { + return foo(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 1.0) | + 0; + } + return bar +})()(); diff --git a/deps/v8/test/mjsunit/samevalue.js b/deps/v8/test/mjsunit/samevalue.js index 356e888016..1e5384d73d 100644 --- a/deps/v8/test/mjsunit/samevalue.js +++ b/deps/v8/test/mjsunit/samevalue.js @@ -32,8 +32,11 @@ var obj1 = {x: 10, y: 11, z: "test"}; var obj2 = {x: 10, y: 11, z: "test"}; +// Object.is() uses the SameValue algorithm. var sameValue = Object.is; -var sameValueZero = function(x, y) { return %SameValueZero(x, y); } + +// Set#has() uses the SameValueZero algorithm. +var sameValueZero = (x, y) => new Set([x]).has(y); // Calls SameValue and SameValueZero and checks that their results match. function sameValueBoth(a, b) { diff --git a/deps/v8/test/mjsunit/stack-traces-class-fields.js b/deps/v8/test/mjsunit/stack-traces-class-fields.js new file mode 100644 index 0000000000..84d7e8a843 --- /dev/null +++ b/deps/v8/test/mjsunit/stack-traces-class-fields.js @@ -0,0 +1,246 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Flags: --harmony-class-fields + +// Utility function for testing that the expected strings occur +// in the stack trace produced when running the given function. +function testTrace(name, fun, expected, unexpected) { + var threw = false; + try { + fun(); + } catch (e) { + for (var i = 0; i < expected.length; i++) { + assertTrue( + e.stack.indexOf(expected[i]) != -1, + name + " doesn't contain expected[" + i + "] stack = " + e.stack + ); + } + if (unexpected) { + for (var i = 0; i < unexpected.length; i++) { + assertEquals( + e.stack.indexOf(unexpected[i]), + -1, + name + " contains unexpected[" + i + "]" + ); + } + } + threw = true; + } + assertTrue(threw, name + " didn't throw"); +} + +function thrower() { + FAIL; +} + +function testClassConstruction() { + class X { + static x = thrower(); + } +} + +// ReferenceError: FAIL is not defined +// at thrower +// at <static_fields_initializer> +// at testClassConstruction +// at testTrace +testTrace( + "during class construction", + testClassConstruction, + ["thrower", "<static_fields_initializer>"], + ["anonymous"] +); + +function testClassConstruction2() { + class X { + [thrower()]; + } +} + +// ReferenceError: FAIL is not defined +// at thrower +// at testClassConstruction2 +// at testTrace +testTrace("during class construction2", testClassConstruction2, ["thrower"]); + +function testClassInstantiation() { + class X { + x = thrower(); + } + + new X(); +} + +// ReferenceError: FAIL is not defined +// at thrower +// at X.<instance_fields_initializer> +// at new X +// at testClassInstantiation +// at testTrace +testTrace( + "during class instantiation", + testClassInstantiation, + ["thrower", "X.<instance_fields_initializer>", "new X"], + ["anonymous"] +); + +function testClassInstantiationWithSuper() { + class Base {} + + class X extends Base { + x = thrower(); + } + + new X(); +} + +// ReferenceError: FAIL is not defined +// at thrower +// at X.<instance_fields_initializer> +// at new X +// at testClassInstantiation +// at testTrace +testTrace( + "during class instantiation with super", + testClassInstantiationWithSuper, + ["thrower", "X.<instance_fields_initializer>", "new X"], + ["Base", "anonymous"] +); + +function testClassInstantiationWithSuper2() { + class Base {} + + class X extends Base { + constructor() { + super(); + } + x = thrower(); + } + + new X(); +} + +// ReferenceError: FAIL is not defined +// at thrower +// at X.<instance_fields_initializer> +// at new X +// at testClassInstantiation +// at testTrace +testTrace( + "during class instantiation with super2", + testClassInstantiationWithSuper2, + ["thrower", "X.<instance_fields_initializer>", "new X"], + ["Base", "anonymous"] +); + +function testClassInstantiationWithSuper3() { + class Base { + x = thrower(); + } + + class X extends Base { + constructor() { + super(); + } + } + + new X(); +} + +// ReferenceError: FAIL is not defined +// at thrower +// at X.<instance_fields_initializer> +// at new Base +// at new X +// at testClassInstantiationWithSuper3 +// at testTrace +testTrace( + "during class instantiation with super3", + testClassInstantiationWithSuper3, + ["thrower", "X.<instance_fields_initializer>", "new Base", "new X"], + ["anonymous"] +); + +function testClassFieldCall() { + class X { + x = thrower; + } + + let x = new X(); + x.x(); +} + +// ReferenceError: FAIL is not defined +// at X.thrower [as x] +// at testClassFieldCall +// at testTrace +testTrace( + "during class field call", + testClassFieldCall, + ["X.thrower"], + ["anonymous"] +); + +function testStaticClassFieldCall() { + class X { + static x = thrower; + } + + X.x(); +} + +// ReferenceError: FAIL is not defined +// at Function.thrower [as x] +// at testStaticClassFieldCall +// at testTrace +testTrace( + "during static class field call", + testStaticClassFieldCall, + ["Function.thrower"], + ["anonymous"] +); + +function testClassFieldCallWithFNI() { + class X { + x = function() { + FAIL; + }; + } + + let x = new X(); + x.x(); +} + +// ReferenceError: FAIL is not defined +// at X.x +// at testClassFieldCallWithFNI +// at testTrace +testTrace( + "during class field call with FNI", + testClassFieldCallWithFNI, + ["X.x"], + ["anonymous"] +); + +function testStaticClassFieldCallWithFNI() { + class X { + static x = function() { + FAIL; + }; + } + + X.x(); +} + +// ReferenceError: FAIL is not defined +// at Function.x +// at testStaticClassFieldCallWithFNI +// at testTrace +testTrace( + "during static class field call with FNI", + testStaticClassFieldCallWithFNI, + ["Function.x"], + ["anonymous"] +); diff --git a/deps/v8/test/mjsunit/string-trim.js b/deps/v8/test/mjsunit/string-trim.js index 201a34f1c9..587e7db5db 100644 --- a/deps/v8/test/mjsunit/string-trim.js +++ b/deps/v8/test/mjsunit/string-trim.js @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --harmony-string-trimming - assertEquals('trim', String.prototype.trim.name); assertEquals('trimStart', String.prototype.trimStart.name); assertEquals('trimStart', String.prototype.trimLeft.name); diff --git a/deps/v8/test/mjsunit/test-async.js b/deps/v8/test/mjsunit/test-async.js index f8a11c5238..d4fee9bfb9 100644 --- a/deps/v8/test/mjsunit/test-async.js +++ b/deps/v8/test/mjsunit/test-async.js @@ -53,7 +53,7 @@ var testAsync; equals(expected, found, name_opt) { this.actualAsserts_++; - if (expected !== found) { + if (!deepEquals(expected, found)) { this.fail(prettyPrinted(expected), found, name_opt); } } diff --git a/deps/v8/test/mjsunit/testcfg.py b/deps/v8/test/mjsunit/testcfg.py index d843cfaf02..422210365e 100644 --- a/deps/v8/test/mjsunit/testcfg.py +++ b/deps/v8/test/mjsunit/testcfg.py @@ -41,21 +41,6 @@ SELF_SCRIPT_PATTERN = re.compile(r"//\s+Env: TEST_FILE_NAME") MODULE_PATTERN = re.compile(r"^// MODULE$", flags=re.MULTILINE) NO_HARNESS_PATTERN = re.compile(r"^// NO HARNESS$", flags=re.MULTILINE) -# Patterns for additional resource files on Android. Files that are not covered -# by one of the other patterns below will be specified in the resources section. -RESOURCES_PATTERN = re.compile(r"//\s+Resources:(.*)") -# Pattern to auto-detect files to push on Android for statements like: -# load("path/to/file.js") -LOAD_PATTERN = re.compile( - r"(?:load|readbuffer|read)\((?:'|\")([^'\"]*)(?:'|\")\)") -# Pattern to auto-detect files to push on Android for statements like: -# import "path/to/file.js" -MODULE_RESOURCES_PATTERN_1 = re.compile( - r"(?:import|export)(?:\(| )(?:'|\")([^'\"]*)(?:'|\")") -# Pattern to auto-detect files to push on Android for statements like: -# import foobar from "path/to/file.js" -MODULE_RESOURCES_PATTERN_2 = re.compile( - r"(?:import|export).*from (?:'|\")([^'\"]*)(?:'|\")") # Flags known to misbehave when combining arbitrary mjsunit tests. Can also # be compiled regular expressions. @@ -100,7 +85,7 @@ class TestSuite(testsuite.TestSuite): return SuppressedTestCase -class TestCase(testcase.TestCase): +class TestCase(testcase.D8TestCase): def __init__(self, *args, **kwargs): super(TestCase, self).__init__(*args, **kwargs) @@ -140,47 +125,6 @@ class TestCase(testcase.TestCase): self._files_suffix = files_suffix self._env = self._parse_source_env(source) - def _get_resources_for_file(self, file): - """Returns for a given file a list of absolute paths of files needed by the - given file. - """ - with open(file) as f: - source = f.read() - result = [] - def add_path(path): - result.append(os.path.abspath(path.replace('/', os.path.sep))) - for match in RESOURCES_PATTERN.finditer(source): - # There are several resources per line. Relative to base dir. - for path in match.group(1).strip().split(): - add_path(path) - for match in LOAD_PATTERN.finditer(source): - # Files in load statements are relative to base dir. - add_path(match.group(1)) - for match in MODULE_RESOURCES_PATTERN_1.finditer(source): - # Imported files are side by side with the test case. - add_path(os.path.join( - self.suite.root, os.path.dirname(self.path), match.group(1))) - for match in MODULE_RESOURCES_PATTERN_2.finditer(source): - # Imported files are side by side with the test case. - add_path(os.path.join( - self.suite.root, os.path.dirname(self.path), match.group(1))) - return result - - def _get_resources(self): - """Returns the list of files needed by a test case.""" - result = set() - to_check = [self._get_source_path()] - # Recurse over all files until reaching a fixpoint. - while to_check: - next_resource = to_check.pop() - result.add(next_resource) - for resource in self._get_resources_for_file(next_resource): - # Only add files that exist on disc. The pattens we check for give some - # false positives otherwise. - if resource not in result and os.path.exists(resource): - to_check.append(resource) - return sorted(list(result)) - def _parse_source_env(self, source): env_match = ENV_PATTERN.search(source) env = {} @@ -244,7 +188,7 @@ class TestCombiner(testsuite.TestCombiner): return CombinedTest -class CombinedTest(testcase.TestCase): +class CombinedTest(testcase.D8TestCase): """Behaves like normal mjsunit tests except: 1. Expected outcome is always PASS 2. Instead of one file there is a try-catch wrapper with all combined tests @@ -259,7 +203,7 @@ class CombinedTest(testcase.TestCase): self._statusfile_outcomes = outproc.OUTCOMES_PASS_OR_TIMEOUT self.expected_outcomes = outproc.OUTCOMES_PASS_OR_TIMEOUT - def _get_shell_with_flags(self): + def _get_shell_flags(self): """In addition to standard set of shell flags it appends: --disable-abortjs: %AbortJS can abort the test even inside trycatch-wrapper, so we disable it. @@ -269,15 +213,13 @@ class CombinedTest(testcase.TestCase): --quiet-load: suppress any stdout from load() function used by trycatch-wrapper. """ - shell = 'd8' - shell_flags = [ + return [ '--test', '--disable-abortjs', '--es-staging', '--omit-quit', '--quiet-load', ] - return shell, shell_flags def _get_cmd_params(self): return ( diff --git a/deps/v8/test/mjsunit/typeof.js b/deps/v8/test/mjsunit/typeof.js index 864f1cfdb6..f6c47f8e2e 100644 --- a/deps/v8/test/mjsunit/typeof.js +++ b/deps/v8/test/mjsunit/typeof.js @@ -1,39 +1,42 @@ // Copyright 2008 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +'use strict'; // The type of a regular expression should be 'object', including in // the context of string equality comparisons. +{ + const r = new RegExp; -var r = new RegExp; -assertEquals('object', typeof r); -assertTrue(typeof r == 'object'); -assertFalse(typeof r == 'function'); + assertEquals('object', typeof r); + assertTrue(typeof r == 'object'); + assertFalse(typeof r == 'function'); -function test(x, y) { return x == y; } -assertTrue(test('object', typeof r)); + function equals(x, y) { return x == y; } + assertTrue(equals('object', typeof r)); +} assertFalse(typeof null == "undefined"); + +assertEquals('undefined', typeof undefined); +assertEquals('object', typeof null); +assertEquals('boolean', typeof true); +assertEquals('boolean', typeof false); +assertEquals('number', typeof 42.42); +assertEquals('number', typeof 42); +assertEquals('bigint', typeof 42n); +assertEquals('string', typeof '42'); +assertEquals('symbol', typeof Symbol(42)); +assertEquals('object', typeof {}); +assertEquals('object', typeof []); +assertEquals('object', typeof new Proxy({}, {})); +assertEquals('object', typeof new Proxy([], {})); +assertEquals('function', typeof (_ => 42)); +assertEquals('function', typeof function() {}); +assertEquals('function', typeof function*() {}); +assertEquals('function', typeof async function() {}); +assertEquals('function', typeof async function*() {}); +assertEquals('function', typeof new Proxy(_ => 42, {})); +assertEquals('function', typeof class {}); +assertEquals('function', typeof Object); diff --git a/deps/v8/test/mjsunit/wasm/anyref.js b/deps/v8/test/mjsunit/wasm/anyref.js index 6282b588ac..e6306b6a9e 100644 --- a/deps/v8/test/mjsunit/wasm/anyref.js +++ b/deps/v8/test/mjsunit/wasm/anyref.js @@ -76,7 +76,6 @@ load("test/mjsunit/wasm/wasm-module-builder.js"); .addBody([kExprRefNull]) .exportFunc(); - const instance = builder.instantiate(); assertEquals(null, instance.exports.main()); @@ -98,5 +97,17 @@ load("test/mjsunit/wasm/wasm-module-builder.js"); assertEquals(0, instance.exports.main(undefined)); assertEquals(1, instance.exports.main(null)); assertEquals(0, instance.exports.main(print)); +})(); +(function testAnyRefLocalDefaultValue() { + print(arguments.callee.name); + const builder = new WasmModuleBuilder(); + builder.addFunction('main', kSig_r_v) + .addBody([kExprGetLocal, 0]) + .addLocals({anyref_count: 1}) + .exportFunc(); + + const instance = builder.instantiate(); + + assertEquals(null, instance.exports.main()); })(); diff --git a/deps/v8/test/mjsunit/wasm/atomics.js b/deps/v8/test/mjsunit/wasm/atomics.js index 58d3d950d5..371839ae24 100644 --- a/deps/v8/test/mjsunit/wasm/atomics.js +++ b/deps/v8/test/mjsunit/wasm/atomics.js @@ -432,3 +432,33 @@ function TestStore(func, buffer, value, size) { assertThrows(() => GetAtomicBinOpFunction(kExprI32AtomicSub16U, 3, 0), WebAssembly.CompileError); })(); + +function CmpExchgLoop(opcode, alignment) { + print("TestI64AtomicCompareExchangeLoop" + alignment); + let builder = new WasmModuleBuilder(); + builder.addImportedMemory("m", "imported_mem", 0, 2, "shared"); + builder.addFunction("main", makeSig([kWasmI32], [])) + .addLocals({i64_count: 2}) + .addBody([ + kExprLoop, kWasmStmt, + kExprGetLocal, 0, + kExprGetLocal, 1, + kExprGetLocal, 2, + kAtomicPrefix, opcode, alignment, 0, + kExprGetLocal, 1, + kExprI64Ne, + kExprBrIf, 0, + kExprEnd + ]) + .exportFunc(); + let mem = new WebAssembly.Memory({initial: 2, maximum: 2, shared: true}); + let module = new WebAssembly.Module(builder.toBuffer()); + let instance = new WebAssembly.Instance(module, {m: {imported_mem: mem}}); +} + +(function TestAtomicCompareExchgLoop() { + CmpExchgLoop(kExprI64AtomicCompareExchange, 3); + CmpExchgLoop(kExprI64AtomicCompareExchange32U, 2); + CmpExchgLoop(kExprI64AtomicCompareExchange16U, 1); + CmpExchgLoop(kExprI64AtomicCompareExchange8U, 0); +})(); diff --git a/deps/v8/test/mjsunit/wasm/bounds-check-64bit.js b/deps/v8/test/mjsunit/wasm/bounds-check-64bit.js index 9308393da4..d909bcc542 100644 --- a/deps/v8/test/mjsunit/wasm/bounds-check-64bit.js +++ b/deps/v8/test/mjsunit/wasm/bounds-check-64bit.js @@ -6,7 +6,7 @@ load("test/mjsunit/wasm/wasm-constants.js"); load("test/mjsunit/wasm/wasm-module-builder.js"); const builder = new WasmModuleBuilder(); -builder.addMemory(1, kV8MaxPages, false); +builder.addMemory(1, undefined, false); builder.addFunction('load', kSig_i_ii) .addBody([ kExprGetLocal, 0, diff --git a/deps/v8/test/mjsunit/wasm/compare-exchange-stress.js b/deps/v8/test/mjsunit/wasm/compare-exchange-stress.js new file mode 100644 index 0000000000..d308919088 --- /dev/null +++ b/deps/v8/test/mjsunit/wasm/compare-exchange-stress.js @@ -0,0 +1,207 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --experimental-wasm-threads + +load("test/mjsunit/wasm/wasm-constants.js"); +load("test/mjsunit/wasm/wasm-module-builder.js"); + +const kSequenceLength = 8192; +const kNumberOfWorkers = 4; +const kBitMask = kNumberOfWorkers - 1; +const kSequenceStartAddress = 32; + +function makeWorkerCodeForOpcode(compareExchangeOpcode, size, functionName, + builder) { + let loadMemOpcode = kTrapUnreachable; + switch (size) { + case 32: + loadMemOpcode = kExprI32LoadMem; + break; + case 16: + loadMemOpcode = kExprI32LoadMem16U; + break; + case 8: + loadMemOpcode = kExprI32LoadMem8U; + break; + default: + throw "!"; + } + const kArgMemoryCell = 0; // target for atomic ops + const kArgSequencePtr = 1; // address of sequence + const kArgSeqenceLength = 2; // lenght of sequence + const kArgWorkerId = 3; // id of this worker + const kArgBitMask = 4; // mask to extract worker id from value + const kLocalCurrentOffset = 5; // current position in sequence in bytes + const kLocalExpectedValue = 6; // the value we are waiting for + const kLocalNextValue = 7; // the value to write in the update + let body = [ + // Turn sequence length to equivalent in bytes. + kExprGetLocal, kArgSeqenceLength, + kExprI32Const, size / 8, + kExprI32Mul, + kExprSetLocal, kArgSeqenceLength, + // Outer block so we have something to jump for return. + ...[kExprBlock, kWasmStmt, + // Set counter to 0. + kExprI32Const, 0, + kExprSetLocal, kLocalCurrentOffset, + // Outer loop until maxcount. + ...[kExprLoop, kWasmStmt, + // Find the next value to wait for. + ...[kExprLoop, kWasmStmt, + // Check end of sequence. + kExprGetLocal, kLocalCurrentOffset, + kExprGetLocal, kArgSeqenceLength, + kExprI32Eq, + kExprBrIf, 2, // return + ...[kExprBlock, kWasmStmt, + // Load next value. + kExprGetLocal, kArgSequencePtr, + kExprGetLocal, kLocalCurrentOffset, + kExprI32Add, + loadMemOpcode, 0, 0, + // Mask off bits. + kExprGetLocal, kArgBitMask, + kExprI32And, + // Compare with worker id. + kExprGetLocal, kArgWorkerId, + kExprI32Eq, + kExprBrIf, 0, + // Not found, increment position. + kExprGetLocal, kLocalCurrentOffset, + kExprI32Const, size / 8, + kExprI32Add, + kExprSetLocal, kLocalCurrentOffset, + kExprBr, 1, + kExprEnd + ], + // Found, end loop. + kExprEnd + ], + // Load expected value to local. + kExprGetLocal, kArgSequencePtr, + kExprGetLocal, kLocalCurrentOffset, + kExprI32Add, + loadMemOpcode, 0, 0, + kExprSetLocal, kLocalExpectedValue, + // Load value after expected one. + kExprGetLocal, kArgSequencePtr, + kExprGetLocal, kLocalCurrentOffset, + kExprI32Add, + kExprI32Const, size / 8, + kExprI32Add, + loadMemOpcode, 0, 0, + kExprSetLocal, kLocalNextValue, + // Hammer on memory until value found. + ...[kExprLoop, kWasmStmt, + // Load address. + kExprGetLocal, kArgMemoryCell, + // Load expected value. + kExprGetLocal, kLocalExpectedValue, + // Load updated value. + kExprGetLocal, kLocalNextValue, + // Try update. + kAtomicPrefix, compareExchangeOpcode, 0, 0, + // Load expected value. + kExprGetLocal, kLocalExpectedValue, + // Spin if not what expected. + kExprI32Ne, + kExprBrIf, 0, + kExprEnd + ], + // Next iteration of loop. + kExprGetLocal, kLocalCurrentOffset, + kExprI32Const, size / 8, + kExprI32Add, + kExprSetLocal, kLocalCurrentOffset, + kExprBr, 0, + kExprEnd + ], // outer loop + kExprEnd + ], // the block + kExprReturn + ]; + builder.addFunction(functionName, makeSig([kWasmI32, kWasmI32, kWasmI32, + kWasmI32, kWasmI32 + ], [])) + .addLocals({ + i32_count: 3 + }) + .addBody(body) + .exportAs(functionName); +} + +function generateSequence(typedarray, start, count) { + let end = count + start; + for (let i = start; i < end; i++) { + typedarray[i] = Math.floor(Math.random() * 256); + } +} + +function spawnWorker(module, memory, address, sequence) { + let workers = []; + for (let i = 0; i < kNumberOfWorkers; i++) { + let worker = new Worker( + `onmessage = function(msg) { + this.instance = new WebAssembly.Instance(msg.module, + {m: {imported_mem: msg.memory}}); + instance.exports.worker(msg.address, msg.sequence, msg.sequenceLength, msg.workerId, + msg.bitMask); + postMessage({workerId: msg.workerId}); + }`, + {type: 'string'} + ); + workers.push(worker); + worker.postMessage({ + module: module, + memory: memory, + address: address, + sequence: sequence, + sequenceLength: kSequenceLength, + workerId: i, + bitMask: kBitMask + }); + } + return workers; +} + +function waitForWorkers(workers) { + for (let worker of workers) { + worker.getMessage(); + worker.terminate(); + } +} + +function testOpcode(opcode, opcodeSize) { + print("Testing I32AtomicCompareExchange" + opcodeSize); + let builder = new WasmModuleBuilder(); + builder.addImportedMemory("m", "imported_mem", 0, 1, "shared"); + + makeWorkerCodeForOpcode(opcode, opcodeSize, "worker", builder); + + let memory = new WebAssembly.Memory({ + initial: 1, + maximum: 1, + shared: true + }); + let memoryView = new Uint8Array(memory.buffer); + generateSequence(memoryView, kSequenceStartAddress, kSequenceLength * (opcodeSize / 8)); + + let module = new WebAssembly.Module(builder.toBuffer()); + let workers = spawnWorker(module, memory, 0, kSequenceStartAddress); + + // Fire the workers off + for (let i = opcodeSize / 8 - 1; i >= 0; i--) { + memoryView[i] = memoryView[kSequenceStartAddress + i]; + } + + waitForWorkers(workers); + + print("DONE"); +} + +testOpcode(kExprI32AtomicCompareExchange, 32); +testOpcode(kExprI32AtomicCompareExchange16U, 16); +testOpcode(kExprI32AtomicCompareExchange8U, 8); diff --git a/deps/v8/test/mjsunit/wasm/compare-exchange64-stress.js b/deps/v8/test/mjsunit/wasm/compare-exchange64-stress.js new file mode 100644 index 0000000000..89cc7ecb34 --- /dev/null +++ b/deps/v8/test/mjsunit/wasm/compare-exchange64-stress.js @@ -0,0 +1,213 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --experimental-wasm-threads + +load("test/mjsunit/wasm/wasm-constants.js"); +load("test/mjsunit/wasm/wasm-module-builder.js"); + +const kSequenceLength = 8192; +const kNumberOfWorkers = 4; +const kBitMask = kNumberOfWorkers - 1; +const kSequenceStartAddress = 32; + +function makeWorkerCodeForOpcode(compareExchangeOpcode, size, functionName, + builder) { + let loadMemOpcode = kTrapUnreachable; + switch (size) { + case 64: + loadMemOpcode = kExprI64LoadMem; + break; + case 32: + loadMemOpcode = kExprI64LoadMem32U; + break; + case 16: + loadMemOpcode = kExprI64LoadMem16U; + break; + case 8: + loadMemOpcode = kExprI64LoadMem8U; + break; + default: + throw "!"; + } + const kArgMemoryCell = 0; // target for atomic ops + const kArgSequencePtr = 1; // address of sequence + const kArgSeqenceLength = 2; // lenght of sequence + const kArgWorkerId = 3; // id of this worker + const kArgBitMask = 4; // mask to extract worker id from value + const kLocalCurrentOffset = 5; // current position in sequence in bytes + const kLocalExpectedValue = 6; // the value we are waiting for + const kLocalNextValue = 7; // the value to write in the update + let body = [ + // Turn sequence length to equivalent in bytes. + kExprGetLocal, kArgSeqenceLength, + kExprI32Const, size / 8, + kExprI32Mul, + kExprSetLocal, kArgSeqenceLength, + // Outer block so we have something to jump for return. + ...[kExprBlock, kWasmStmt, + // Set counter to 0. + kExprI32Const, 0, + kExprSetLocal, kLocalCurrentOffset, + // Outer loop until maxcount. + ...[kExprLoop, kWasmStmt, + // Find the next value to wait for. + ...[kExprLoop, kWasmStmt, + // Check end of sequence. + kExprGetLocal, kLocalCurrentOffset, + kExprGetLocal, kArgSeqenceLength, + kExprI32Eq, + kExprBrIf, 2, // return + ...[kExprBlock, kWasmStmt, + // Load next value. + kExprGetLocal, kArgSequencePtr, + kExprGetLocal, kLocalCurrentOffset, + kExprI32Add, + loadMemOpcode, 0, 0, + // Mask off bits. + kExprGetLocal, kArgBitMask, + kExprI64UConvertI32, + kExprI64And, + // Compare with worker id. + kExprGetLocal, kArgWorkerId, + kExprI64UConvertI32, + kExprI64Eq, + kExprBrIf, 0, + // Not found, increment position. + kExprGetLocal, kLocalCurrentOffset, + kExprI32Const, size / 8, + kExprI32Add, + kExprSetLocal, kLocalCurrentOffset, + kExprBr, 1, + kExprEnd + ], + // Found, end loop. + kExprEnd + ], + // Load expected value to local. + kExprGetLocal, kArgSequencePtr, + kExprGetLocal, kLocalCurrentOffset, + kExprI32Add, + loadMemOpcode, 0, 0, + kExprSetLocal, kLocalExpectedValue, + // Load value after expected one. + kExprGetLocal, kArgSequencePtr, + kExprGetLocal, kLocalCurrentOffset, + kExprI32Add, + kExprI32Const, size / 8, + kExprI32Add, + loadMemOpcode, 0, 0, + kExprSetLocal, kLocalNextValue, + // Hammer on memory until value found. + ...[kExprLoop, kWasmStmt, + // Load address. + kExprGetLocal, kArgMemoryCell, + // Load expected value. + kExprGetLocal, kLocalExpectedValue, + // Load updated value. + kExprGetLocal, kLocalNextValue, + // Try update. + kAtomicPrefix, compareExchangeOpcode, 0, 0, + // Load expected value. + kExprGetLocal, kLocalExpectedValue, + // Spin if not what expected. + kExprI64Ne, + kExprBrIf, 0, + kExprEnd + ], + // Next iteration of loop. + kExprGetLocal, kLocalCurrentOffset, + kExprI32Const, size / 8, + kExprI32Add, + kExprSetLocal, kLocalCurrentOffset, + kExprBr, 0, + kExprEnd + ], // outer loop + kExprEnd + ], // the block + kExprReturn + ]; + builder.addFunction(functionName, makeSig([kWasmI32, kWasmI32, kWasmI32, + kWasmI32, kWasmI32 + ], [])) + .addLocals({ + i32_count: 1, i64_count: 2 + }) + .addBody(body) + .exportAs(functionName); +} + +function generateSequence(typedarray, start, count) { + let end = count + start; + for (let i = start; i < end; i++) { + typedarray[i] = Math.floor(Math.random() * 256); + } +} + +function spawnWorker(module, memory, address, sequence) { + let workers = []; + for (let i = 0; i < kNumberOfWorkers; i++) { + let worker = new Worker( + `onmessage = function(msg) { + this.instance = new WebAssembly.Instance(msg.module, + {m: {imported_mem: msg.memory}}); + instance.exports.worker(msg.address, msg.sequence, msg.sequenceLength, msg.workerId, + msg.bitMask); + postMessage({workerId: msg.workerId}); + }`, + {type: 'string'} + ); + workers.push(worker); + worker.postMessage({ + module: module, + memory: memory, + address: address, + sequence: sequence, + sequenceLength: kSequenceLength, + workerId: i, + bitMask: kBitMask + }); + } + return workers; +} + +function waitForWorkers(workers) { + for (let worker of workers) { + worker.getMessage(); + worker.terminate(); + } +} + +function testOpcode(opcode, opcodeSize) { + print("Testing I64AtomicCompareExchange" + opcodeSize); + let builder = new WasmModuleBuilder(); + builder.addImportedMemory("m", "imported_mem", 0, 2, "shared"); + + makeWorkerCodeForOpcode(opcode, opcodeSize, "worker", builder); + + let memory = new WebAssembly.Memory({ + initial: 2, + maximum: 2, + shared: true + }); + let memoryView = new Uint8Array(memory.buffer); + generateSequence(memoryView, kSequenceStartAddress, kSequenceLength * (opcodeSize / 8)); + + let module = new WebAssembly.Module(builder.toBuffer()); + let workers = spawnWorker(module, memory, 0, kSequenceStartAddress); + + // Fire the workers off + for (let i = opcodeSize / 8 - 1; i >= 0; i--) { + memoryView[i] = memoryView[kSequenceStartAddress + i]; + } + + waitForWorkers(workers); + + print("DONE"); +} + +testOpcode(kExprI64AtomicCompareExchange, 64); +testOpcode(kExprI64AtomicCompareExchange32U, 32); +testOpcode(kExprI64AtomicCompareExchange16U, 16); +testOpcode(kExprI64AtomicCompareExchange8U, 8); diff --git a/deps/v8/test/mjsunit/wasm/data-segments.js b/deps/v8/test/mjsunit/wasm/data-segments.js index 571995931a..e73e3fb3a7 100644 --- a/deps/v8/test/mjsunit/wasm/data-segments.js +++ b/deps/v8/test/mjsunit/wasm/data-segments.js @@ -37,8 +37,6 @@ function GlobalImportedInitTest(pad) { var builder = new WasmModuleBuilder(); builder.addMemory(1, 1, false); - while (pad-- > 0) builder.addGlobal(kWasmI32); // pad - var g = builder.addImportedGlobal("mod", "offset", kWasmI32); while (pad-- > 0) builder.addGlobal(kWasmI32); // pad diff --git a/deps/v8/test/mjsunit/wasm/exceptions-export.js b/deps/v8/test/mjsunit/wasm/exceptions-export.js new file mode 100644 index 0000000000..72ec02dec3 --- /dev/null +++ b/deps/v8/test/mjsunit/wasm/exceptions-export.js @@ -0,0 +1,81 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --expose-wasm --experimental-wasm-eh + +load("test/mjsunit/wasm/wasm-constants.js"); +load("test/mjsunit/wasm/wasm-module-builder.js"); + +(function TestExportSimple() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_v); + builder.addExportOfKind("ex", kExternalException, except); + let instance = builder.instantiate(); + + assertTrue(Object.prototype.hasOwnProperty.call(instance.exports, 'ex')); + assertEquals("object", typeof instance.exports.ex); + assertInstanceof(instance.exports.ex, WebAssembly.Exception); + assertSame(instance.exports.ex.constructor, WebAssembly.Exception); +})(); + +(function TestExportMultiple() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let except1 = builder.addException(kSig_v_v); + let except2 = builder.addException(kSig_v_i); + builder.addExportOfKind("ex1a", kExternalException, except1); + builder.addExportOfKind("ex1b", kExternalException, except1); + builder.addExportOfKind("ex2", kExternalException, except2); + let instance = builder.instantiate(); + + assertTrue(Object.prototype.hasOwnProperty.call(instance.exports, 'ex1a')); + assertTrue(Object.prototype.hasOwnProperty.call(instance.exports, 'ex1b')); + assertTrue(Object.prototype.hasOwnProperty.call(instance.exports, 'ex2')); + assertSame(instance.exports.ex1a, instance.exports.ex1b); + assertNotSame(instance.exports.ex1a, instance.exports.ex2); +})(); + +(function TestExportOutOfBounds() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_v); + builder.addExportOfKind("ex_oob", kExternalException, except + 1); + assertThrows( + () => builder.instantiate(), WebAssembly.CompileError, + /Wasm decoding failed: exception index 1 out of bounds/); +})(); + +(function TestExportSameNameTwice() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_v); + builder.addExportOfKind("ex", kExternalException, except); + builder.addExportOfKind("ex", kExternalException, except); + assertThrows( + () => builder.instantiate(), WebAssembly.CompileError, + /Duplicate export name 'ex' for exception 0 and exception 0/); +})(); + +(function TestExportModuleGetExports() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_v); + builder.addExportOfKind("ex", kExternalException, except); + let module = new WebAssembly.Module(builder.toBuffer()); + + let exports = WebAssembly.Module.exports(module); + assertArrayEquals([{ name: "ex", kind: "exception" }], exports); +})(); + +(function TestConstructorNonCallable() { + print(arguments.callee.name); + // TODO(wasm): Currently the constructor function of an exported exception is + // not callable. This can/will change once the proposal matures, at which + // point we should add a full exceptions-api.js test suite for the API and + // remove this test case from this file. + assertThrows( + () => WebAssembly.Exception(), TypeError, + /WebAssembly.Exception cannot be called/); +})(); diff --git a/deps/v8/test/mjsunit/wasm/exceptions-import.js b/deps/v8/test/mjsunit/wasm/exceptions-import.js new file mode 100644 index 0000000000..b5276727ba --- /dev/null +++ b/deps/v8/test/mjsunit/wasm/exceptions-import.js @@ -0,0 +1,96 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --expose-wasm --experimental-wasm-eh + +load("test/mjsunit/wasm/wasm-constants.js"); +load("test/mjsunit/wasm/wasm-module-builder.js"); + +// Helper function to return a new exported exception with the {kSig_v_v} type +// signature from an anonymous module. The underlying module is thrown away. +// This allows tests to reason solely about importing exceptions. +function NewExportedException() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_v); + builder.addExportOfKind("ex", kExternalException, except); + let instance = builder.instantiate(); + return instance.exports.ex; +} + +(function TestImportSimple() { + print(arguments.callee.name); + let exported = NewExportedException(); + let builder = new WasmModuleBuilder(); + let except = builder.addImportedException("m", "ex", kSig_v_v); + + assertDoesNotThrow(() => builder.instantiate({ m: { ex: exported }})); +})(); + +(function TestImportMultiple() { + print(arguments.callee.name); + let exported = NewExportedException(); + let builder = new WasmModuleBuilder(); + let except1 = builder.addImportedException("m", "ex1", kSig_v_v); + let except2 = builder.addImportedException("m", "ex2", kSig_v_v); + let except3 = builder.addException(kSig_v_v); + builder.addExportOfKind("ex2", kExternalException, except2); + builder.addExportOfKind("ex3", kExternalException, except3); + let instance = builder.instantiate({ m: { ex1: exported, ex2: exported }}); + + assertTrue(except1 < except3 && except2 < except3); + assertEquals(undefined, instance.exports.ex1); + assertSame(exported, instance.exports.ex2); + assertNotSame(exported, instance.exports.ex3); +})(); + +(function TestImportMissing() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let except = builder.addImportedException("m", "ex", kSig_v_v); + + assertThrows( + () => builder.instantiate({}), TypeError, + /module is not an object or function/); + assertThrows( + () => builder.instantiate({ m: {}}), WebAssembly.LinkError, + /exception import requires a WebAssembly.Exception/); +})(); + +(function TestImportValueMismatch() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let except = builder.addImportedException("m", "ex", kSig_v_v); + + assertThrows( + () => builder.instantiate({ m: { ex: 23 }}), WebAssembly.LinkError, + /exception import requires a WebAssembly.Exception/); + assertThrows( + () => builder.instantiate({ m: { ex: {} }}), WebAssembly.LinkError, + /exception import requires a WebAssembly.Exception/); + var monkey = Object.create(NewExportedException()); + assertThrows( + () => builder.instantiate({ m: { ex: monkey }}), WebAssembly.LinkError, + /exception import requires a WebAssembly.Exception/); +})(); + +(function TestImportSignatureMismatch() { + print(arguments.callee.name); + let exported = NewExportedException(); + let builder = new WasmModuleBuilder(); + let except = builder.addImportedException("m", "ex", kSig_v_i); + + assertThrows( + () => builder.instantiate({ m: { ex: exported }}), WebAssembly.LinkError, + /imported exception does not match the expected type/); +})(); + +(function TestImportModuleGetImports() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let except = builder.addImportedException("m", "ex", kSig_v_v); + let module = new WebAssembly.Module(builder.toBuffer()); + + let imports = WebAssembly.Module.imports(module); + assertArrayEquals([{ module: "m", name: "ex", kind: "exception" }], imports); +})(); diff --git a/deps/v8/test/mjsunit/wasm/exceptions-shared.js b/deps/v8/test/mjsunit/wasm/exceptions-shared.js new file mode 100644 index 0000000000..f2a5b56e9a --- /dev/null +++ b/deps/v8/test/mjsunit/wasm/exceptions-shared.js @@ -0,0 +1,158 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --expose-wasm --experimental-wasm-eh + +load("test/mjsunit/wasm/wasm-constants.js"); +load("test/mjsunit/wasm/wasm-module-builder.js"); + +// Helper function to return a new exported exception with the {kSig_v_v} type +// signature from an anonymous module. The underlying module is thrown away. +function NewExportedException() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_v); + builder.addExportOfKind("ex", kExternalException, except); + let instance = builder.instantiate(); + return instance.exports.ex; +} + +// Check that an instance matches an exception thrown by itself, even when the +// exception is re-thrown by a regular JavaScript function. +(function TestSingleInstance() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let sig_index = builder.addType(kSig_v_v); + let fun = builder.addImport("m", "f", sig_index); + let except = builder.addException(kSig_v_v); + builder.addFunction("throw", kSig_v_v) + .addBody([ + kExprThrow, except + ]).exportFunc(); + builder.addFunction("catch", kSig_v_v) + .addBody([ + kExprTry, kWasmStmt, + kExprCallFunction, fun, + kExprCatch, except, + kExprEnd, + ]).exportFunc(); + let ex_obj = new Error("my exception"); + let instance = builder.instantiate({ m: { f: function() { throw ex_obj }}}); + + assertThrows(() => instance.exports.throw(), WebAssembly.RuntimeError); + assertThrowsEquals(() => instance.exports.catch(), ex_obj); + try { + instance.exports.throw(); + } catch (e) { + ex_obj = e; + } + assertDoesNotThrow(() => instance.exports.catch()); +})(); + +// Check that two instances distinguish their individual exceptions if they are +// not shared, even when declared by the same underlying module. +(function TestMultiInstanceNonShared() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let sig_index = builder.addType(kSig_v_v); + let fun = builder.addImport("m", "f", sig_index); + let except = builder.addException(kSig_v_v); + builder.addFunction("throw", kSig_v_v) + .addBody([ + kExprThrow, except + ]).exportFunc(); + builder.addFunction("catch", kSig_v_v) + .addBody([ + kExprTry, kWasmStmt, + kExprCallFunction, fun, + kExprCatch, except, + kExprEnd, + ]).exportFunc(); + let ex_obj = new Error("my exception"); + let instance1 = builder.instantiate({ m: { f: assertUnreachable }}); + let instance2 = builder.instantiate({ m: { f: function() { throw ex_obj }}}); + + assertThrows(() => instance1.exports.throw(), WebAssembly.RuntimeError); + assertThrowsEquals(() => instance2.exports.catch(), ex_obj); + try { + instance1.exports.throw(); + } catch (e) { + ex_obj = e; + } + assertThrowsEquals(() => instance2.exports.catch(), ex_obj); +})(); + +// Check that two instances match their exceptions if they are shared properly, +// even if the local exception index of export and import is different. +(function TestMultiInstanceShared() { + print(arguments.callee.name); + let builder = new WasmModuleBuilder(); + let sig_index = builder.addType(kSig_v_v); + let fun = builder.addImport("m", "f", sig_index); + let except1 = builder.addImportedException("m", "ex1", kSig_v_v); + let except2 = builder.addException(kSig_v_v); + builder.addExportOfKind("ex2", kExternalException, except2); + builder.addFunction("throw", kSig_v_v) + .addBody([ + kExprThrow, except2 + ]).exportFunc(); + builder.addFunction("catch", kSig_v_v) + .addBody([ + kExprTry, kWasmStmt, + kExprCallFunction, fun, + kExprCatch, except1, + kExprEnd, + ]).exportFunc(); + let ex_obj = new Error("my exception"); + let instance1 = builder.instantiate({ m: { f: assertUnreachable, + ex1: NewExportedException() }}); + let instance2 = builder.instantiate({ m: { f: function() { throw ex_obj }, + ex1: instance1.exports.ex2 }}); + + assertThrows(() => instance1.exports.throw(), WebAssembly.RuntimeError); + assertThrowsEquals(() => instance2.exports.catch(), ex_obj); + try { + instance1.exports.throw(); + } catch (e) { + ex_obj = e; + } + assertDoesNotThrow(() => instance2.exports.catch()); +})(); + +// Check that two instances based on different modules match their exceptions if +// they are shared properly, even if the local exception index is different. +(function TestMultiModuleShared() { + print(arguments.callee.name); + let builder1 = new WasmModuleBuilder(); + let except1 = builder1.addException(kSig_v_v); + let except2 = builder1.addException(kSig_v_v); + builder1.addExportOfKind("ex", kExternalException, except2); + builder1.addFunction("throw", kSig_v_v) + .addBody([ + kExprThrow, except2 + ]).exportFunc(); + let builder2 = new WasmModuleBuilder(); + let sig_index = builder2.addType(kSig_v_v); + let fun = builder2.addImport("m", "f", sig_index); + let except = builder2.addImportedException("m", "ex", kSig_v_v); + builder2.addFunction("catch", kSig_v_v) + .addBody([ + kExprTry, kWasmStmt, + kExprCallFunction, fun, + kExprCatch, except, + kExprEnd, + ]).exportFunc(); + let ex_obj = new Error("my exception"); + let instance1 = builder1.instantiate(); + let instance2 = builder2.instantiate({ m: { f: function() { throw ex_obj }, + ex: instance1.exports.ex }}); + + assertThrows(() => instance1.exports.throw(), WebAssembly.RuntimeError); + assertThrowsEquals(() => instance2.exports.catch(), ex_obj); + try { + instance1.exports.throw(); + } catch (e) { + ex_obj = e; + } + assertDoesNotThrow(() => instance2.exports.catch()); +})(); diff --git a/deps/v8/test/mjsunit/wasm/exceptions.js b/deps/v8/test/mjsunit/wasm/exceptions.js index 74d8e7dfb5..d165c8742d 100644 --- a/deps/v8/test/mjsunit/wasm/exceptions.js +++ b/deps/v8/test/mjsunit/wasm/exceptions.js @@ -1,84 +1,110 @@ -// Copyright 2015 the V8 project authors. All rights reserved. +// Copyright 2018 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --expose-wasm --experimental-wasm-eh +// Flags: --expose-wasm --experimental-wasm-eh --allow-natives-syntax load("test/mjsunit/wasm/wasm-constants.js"); load("test/mjsunit/wasm/wasm-module-builder.js"); -// The following method doesn't attempt to catch an raised exception. -var test_throw = (function () { - var builder = new WasmModuleBuilder(); +function assertWasmThrows(instance, runtime_id, values, code) { + try { + if (typeof code === 'function') { + code(); + } else { + eval(code); + } + } catch (e) { + assertInstanceof(e, WebAssembly.RuntimeError); + var e_runtime_id = %GetWasmExceptionId(e, instance); + assertTrue(Number.isInteger(e_runtime_id)); + assertEquals(e_runtime_id, runtime_id); + var e_values = %GetWasmExceptionValues(e); + assertArrayEquals(values, e_values); + return; // Success. + } + throw new MjsUnitAssertionError('Did not throw expected <' + runtime_id + + '> with values: ' + values); +} + +// First we just test that "except_ref" local variables are allowed. +(function TestLocalExceptRef() { + let builder = new WasmModuleBuilder(); + builder.addFunction("push_and_drop_except_ref", kSig_v_v) + .addBody([ + kExprGetLocal, 0, + kExprDrop, + ]).addLocals({except_count: 1}).exportFunc(); + let instance = builder.instantiate(); - builder.addException(kSig_v_v); + assertDoesNotThrow(instance.exports.push_and_drop_except_ref); +})(); +// The following method doesn't attempt to catch an raised exception. +(function TestThrowSimple() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_v); builder.addFunction("throw_if_param_not_zero", kSig_i_i) .addBody([ kExprGetLocal, 0, kExprI32Const, 0, kExprI32Ne, kExprIf, kWasmStmt, - kExprThrow, 0, + kExprThrow, except, kExprEnd, kExprI32Const, 1 ]).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertEquals(1, instance.exports.throw_if_param_not_zero(0)); + assertWasmThrows(instance, except, [], () => instance.exports.throw_if_param_not_zero(10)); + assertWasmThrows(instance, except, [], () => instance.exports.throw_if_param_not_zero(-1)); })(); -// Check the test_throw exists. -assertFalse(test_throw === undefined); -assertFalse(test_throw === null); -assertFalse(test_throw === 0); -assertEquals("object", typeof test_throw.exports); -assertEquals("function", typeof test_throw.exports.throw_if_param_not_zero); +// Test that empty try/catch blocks work. +(function TestCatchEmptyBlocks() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_v); + builder.addFunction("catch_empty_try", kSig_v_v) + .addBody([ + kExprTry, kWasmStmt, + kExprCatch, except, + kExprEnd, + ]).exportFunc(); + let instance = builder.instantiate(); -// Test expected behavior of throws -assertEquals(1, test_throw.exports.throw_if_param_not_zero(0)); -assertWasmThrows(0, [], function() { test_throw.exports.throw_if_param_not_zero(10) }); -assertWasmThrows(0, [], function() { test_throw.exports.throw_if_param_not_zero(-1) }); + assertDoesNotThrow(instance.exports.catch_empty_try); +})(); // Now that we know throwing works, we test catching the exceptions we raise. -var test_catch = (function () { - var builder = new WasmModuleBuilder(); - - builder.addException(kSig_v_v); +(function TestCatchSimple() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_v); builder.addFunction("simple_throw_catch_to_0_1", kSig_i_i) .addBody([ kExprTry, kWasmI32, kExprGetLocal, 0, kExprI32Eqz, kExprIf, kWasmStmt, - kExprThrow, 0, + kExprThrow, except, kExprEnd, - kExprI32Const, 1, - kExprCatch, 0, - kExprI32Const, 0, + kExprI32Const, 42, + kExprCatch, except, + kExprI32Const, 23, kExprEnd ]).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertEquals(23, instance.exports.simple_throw_catch_to_0_1(0)); + assertEquals(42, instance.exports.simple_throw_catch_to_0_1(1)); })(); -// Check the test_catch exists. -assertFalse(test_catch === undefined); -assertFalse(test_catch === null); -assertFalse(test_catch === 0); -assertEquals("object", typeof test_catch.exports); -assertEquals("function", typeof test_catch.exports.simple_throw_catch_to_0_1); - -// Test expected behavior of simple catch. -assertEquals(0, test_catch.exports.simple_throw_catch_to_0_1(0)); -assertEquals(1, test_catch.exports.simple_throw_catch_to_0_1(1)); - // Test that we can distinguish which exception was thrown. -var test_catch_2 = (function () { - var builder = new WasmModuleBuilder(); - - builder.addException(kSig_v_v); - builder.addException(kSig_v_v); - builder.addException(kSig_v_v); +(function TestCatchComplex() { + let builder = new WasmModuleBuilder(); + let except1 = builder.addException(kSig_v_v); + let except2 = builder.addException(kSig_v_v); + let except3 = builder.addException(kSig_v_v); builder.addFunction("catch_different_exceptions", kSig_i_i) .addBody([ kExprTry, kWasmI32, @@ -86,172 +112,122 @@ var test_catch_2 = (function () { kExprGetLocal, 0, kExprI32Eqz, kExprIf, kWasmStmt, - kExprThrow, 0, + kExprThrow, except1, kExprElse, kExprGetLocal, 0, kExprI32Const, 1, kExprI32Eq, kExprIf, kWasmStmt, - kExprThrow, 1, + kExprThrow, except2, kExprElse, - kExprThrow, 2, + kExprThrow, except3, kExprEnd, kExprEnd, kExprI32Const, 2, - kExprCatch, 0, + kExprCatch, except1, kExprI32Const, 3, kExprEnd, - kExprCatch, 1, + kExprCatch, except2, kExprI32Const, 4, kExprEnd ]).exportFunc(); - return builder.instantiate(); -})(); - -assertFalse(test_catch_2 === undefined); -assertFalse(test_catch_2 === null); -assertFalse(test_catch_2 === 0); -assertEquals("object", typeof test_catch_2.exports); -assertEquals("function", typeof test_catch_2.exports.catch_different_exceptions); + let instance = builder.instantiate(); -assertEquals(3, test_catch_2.exports.catch_different_exceptions(0)); -assertEquals(4, test_catch_2.exports.catch_different_exceptions(1)); -assertWasmThrows(2, [], function() { test_catch_2.exports.catch_different_exceptions(2) }); + assertEquals(3, instance.exports.catch_different_exceptions(0)); + assertEquals(4, instance.exports.catch_different_exceptions(1)); + assertWasmThrows(instance, except3, [], () => instance.exports.catch_different_exceptions(2)); +})(); // Test throwing an exception with multiple values. -var test_throw_1_2 = (function() { - var builder = new WasmModuleBuilder(); - builder.addException(kSig_v_ii); +(function TestThrowMultipleValues() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_ii); builder.addFunction("throw_1_2", kSig_v_v) .addBody([ kExprI32Const, 1, kExprI32Const, 2, - kExprThrow, 0, + kExprThrow, except, ]).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertWasmThrows(instance, except, [0, 1, 0, 2], () => instance.exports.throw_1_2()); })(); -assertFalse(test_throw_1_2 === undefined); -assertFalse(test_throw_1_2 === null); -assertFalse(test_throw_1_2 === 0); -assertEquals("object", typeof test_throw_1_2.exports); -assertEquals("function", typeof test_throw_1_2.exports.throw_1_2); - -assertWasmThrows(0, [0, 1, 0, 2], function() { test_throw_1_2.exports.throw_1_2(); }); - // Test throwing/catching the i32 parameter value. -var test_throw_catch_param_i = (function () { - var builder = new WasmModuleBuilder(); - builder.addException(kSig_v_i); +(function TestThrowCatchParamI() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_i); builder.addFunction("throw_catch_param", kSig_i_i) .addBody([ kExprTry, kWasmI32, kExprGetLocal, 0, - kExprThrow, 0, + kExprThrow, except, kExprI32Const, 2, - kExprCatch, 0, + kExprCatch, except, kExprReturn, kExprEnd, ]).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertEquals(0, instance.exports.throw_catch_param(0)); + assertEquals(1, instance.exports.throw_catch_param(1)); + assertEquals(10, instance.exports.throw_catch_param(10)); })(); -assertFalse(test_throw_catch_param_i === undefined); -assertFalse(test_throw_catch_param_i === null); -assertFalse(test_throw_catch_param_i === 0); -assertEquals("object", typeof test_throw_catch_param_i.exports); -assertEquals("function", - typeof test_throw_catch_param_i.exports.throw_catch_param); - -assertEquals(0, test_throw_catch_param_i.exports.throw_catch_param(0)); -assertEquals(1, test_throw_catch_param_i.exports.throw_catch_param(1)); -assertEquals(10, test_throw_catch_param_i.exports.throw_catch_param(10)); - // Test the encoding of a thrown exception with an integer exception. - -var test_throw_param_i = (function () { - var builder = new WasmModuleBuilder(); - builder.addException(kSig_v_i); +(function TestThrowParamI() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_i); builder.addFunction("throw_param", kSig_v_i) .addBody([ kExprGetLocal, 0, - kExprThrow, 0, + kExprThrow, except, ]).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertWasmThrows(instance, except, [0, 5], () => instance.exports.throw_param(5)); + assertWasmThrows(instance, except, [6, 31026], () => instance.exports.throw_param(424242)); })(); -assertFalse(test_throw_param_i === undefined); -assertFalse(test_throw_param_i === null); -assertFalse(test_throw_param_i === 0); -assertEquals("object", typeof test_throw_param_i.exports); -assertEquals("function", - typeof test_throw_param_i.exports.throw_param); - -assertWasmThrows(0, [0, 5], function() { test_throw_param_i.exports.throw_param(5); }); -assertWasmThrows(0, [6, 31026], - function() { test_throw_param_i.exports.throw_param(424242); }); - // Test throwing/catching the f32 parameter value. -var test_throw_catch_param_f = (function () { - var builder = new WasmModuleBuilder(); - builder.addException(kSig_v_f); +(function TestThrowCatchParamF() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_f); builder.addFunction("throw_catch_param", kSig_f_f) .addBody([ kExprTry, kWasmF32, kExprGetLocal, 0, - kExprThrow, 0, + kExprThrow, except, kExprF32Const, 0, 0, 0, 0, - kExprCatch, 0, + kExprCatch, except, kExprReturn, kExprEnd, ]).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertEquals(5.0, instance.exports.throw_catch_param(5.0)); + assertEquals(10.5, instance.exports.throw_catch_param(10.5)); })(); -assertFalse(test_throw_catch_param_f === undefined); -assertFalse(test_throw_catch_param_f === null); -assertFalse(test_throw_catch_param_f === 0); -assertEquals("object", typeof test_throw_catch_param_f.exports); -assertEquals("function", - typeof test_throw_catch_param_f.exports.throw_catch_param); - -assertEquals(5.0, test_throw_catch_param_f.exports.throw_catch_param(5.0)); -assertEquals(10.5, test_throw_catch_param_f.exports.throw_catch_param(10.5)); - // Test the encoding of a thrown exception with a float value. - -var test_throw_param_f = (function () { - var builder = new WasmModuleBuilder(); - builder.addException(kSig_v_f); +(function TestThrowParamF() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_f); builder.addFunction("throw_param", kSig_v_f) .addBody([ kExprGetLocal, 0, - kExprThrow, 0, + kExprThrow, except, ]).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertWasmThrows(instance, except, [16544, 0], () => instance.exports.throw_param(5.0)); + assertWasmThrows(instance, except, [16680, 0], () => instance.exports.throw_param(10.5)); })(); -assertFalse(test_throw_param_f === undefined); -assertFalse(test_throw_param_f === null); -assertFalse(test_throw_param_f === 0); -assertEquals("object", typeof test_throw_param_f.exports); -assertEquals("function", - typeof test_throw_param_f.exports.throw_param); - -assertWasmThrows(0, [16544, 0], - function() { test_throw_param_f.exports.throw_param(5.0); }); -assertWasmThrows(0, [16680, 0], - function() { test_throw_param_f.exports.throw_param(10.5); }); - // Test throwing/catching an I64 value -var test_throw_catch_param_l = (function () { - var builder = new WasmModuleBuilder(); - builder.addException(kSig_v_l); +(function TestThrowCatchParamL() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_l); builder.addFunction("throw_catch_param", kSig_i_i) .addBody([ kExprGetLocal, 0, @@ -259,9 +235,9 @@ var test_throw_catch_param_l = (function () { kExprSetLocal, 1, kExprTry, kWasmI32, kExprGetLocal, 1, - kExprThrow, 0, + kExprThrow, except, kExprI32Const, 2, - kExprCatch, 0, + kExprCatch, except, kExprGetLocal, 1, kExprI64Eq, kExprIf, kWasmI32, @@ -273,26 +249,17 @@ var test_throw_catch_param_l = (function () { kExprReturn, kExprEnd, ]).addLocals({i64_count: 1}).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertEquals(1, instance.exports.throw_catch_param(5)); + assertEquals(1, instance.exports.throw_catch_param(0)); + assertEquals(1, instance.exports.throw_catch_param(-1)); })(); -assertFalse(test_throw_catch_param_l === undefined); -assertFalse(test_throw_catch_param_l === null); -assertFalse(test_throw_catch_param_l === 0); -assertEquals("object", typeof test_throw_catch_param_l.exports); -assertEquals("function", - typeof test_throw_catch_param_l.exports.throw_catch_param); - -assertEquals(1, test_throw_catch_param_l.exports.throw_catch_param(5)); -assertEquals(1, test_throw_catch_param_l.exports.throw_catch_param(0)); -assertEquals(1, test_throw_catch_param_l.exports.throw_catch_param(-1)); - // Test the encoding of a thrown exception with an I64 value. - -var test_throw_param_l = (function () { - var builder = new WasmModuleBuilder(); - builder.addException(kSig_v_l); +(function TestThrowParamL() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_l); builder.addFunction("throw_param", kSig_v_ii) .addBody([ kExprGetLocal, 0, @@ -302,428 +269,357 @@ var test_throw_param_l = (function () { kExprGetLocal, 1, kExprI64UConvertI32, kExprI64Ior, - kExprThrow, 0 + kExprThrow, except, ]).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertWasmThrows(instance, except, [0, 10, 0, 5], () => instance.exports.throw_param(10, 5)); + assertWasmThrows(instance, except, [65535, 65535, 0, 13], () => instance.exports.throw_param(-1, 13)); })(); -assertFalse(test_throw_param_l === undefined); -assertFalse(test_throw_param_l === null); -assertFalse(test_throw_param_l === 0); -assertEquals("object", typeof test_throw_param_l.exports); -assertEquals("function", - typeof test_throw_param_l.exports.throw_param); - -assertWasmThrows(0, [0, 10, 0, 5], - function() { test_throw_param_l.exports.throw_param(10, 5); }); -assertWasmThrows(0, [65535, 65535, 0, 13], - function() { test_throw_param_l.exports.throw_param(-1, 13); }); - // Test throwing/catching the F64 parameter value -var test_throw_catch_param_d = (function () { - var builder = new WasmModuleBuilder(); - builder.addException(kSig_v_d); +(function TestThrowCatchParamD() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_d); builder.addFunction("throw_catch_param", kSig_d_d) .addBody([ kExprTry, kWasmF64, kExprGetLocal, 0, - kExprThrow, 0, + kExprThrow, except, kExprF64Const, 0, 0, 0, 0, 0, 0, 0, 0, - kExprCatch, 0, + kExprCatch, except, kExprReturn, kExprEnd, ]).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertEquals(5.0, instance.exports.throw_catch_param(5.0)); + assertEquals(10.5, instance.exports.throw_catch_param(10.5)); })(); -assertFalse(test_throw_catch_param_d === undefined); -assertFalse(test_throw_catch_param_d === null); -assertFalse(test_throw_catch_param_d === 0); -assertEquals("object", typeof test_throw_catch_param_d.exports); -assertEquals("function", - typeof test_throw_catch_param_d.exports.throw_catch_param); - -assertEquals(5.0, test_throw_catch_param_d.exports.throw_catch_param(5.0)); -assertEquals(10.5, test_throw_catch_param_d.exports.throw_catch_param(10.5)); - // Test the encoding of a thrown exception with an f64 value. - -var test_throw_param_d = (function () { - var builder = new WasmModuleBuilder(); - builder.addException(kSig_v_d); +(function TestThrowParamD() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_d); builder.addFunction("throw_param", kSig_v_f) .addBody([ kExprGetLocal, 0, kExprF64ConvertF32, - kExprThrow, 0 + kExprThrow, except, ]).exportFunc(); + let instance = builder.instantiate(); - return builder.instantiate(); + assertWasmThrows(instance, except, [16404, 0, 0, 0], () => instance.exports.throw_param(5.0)); + assertWasmThrows(instance, except, [16739, 4816, 0, 0], () => instance.exports.throw_param(10000000.5)); })(); -assertFalse(test_throw_param_d === undefined); -assertFalse(test_throw_param_d === null); -assertFalse(test_throw_param_d === 0); -assertEquals("object", typeof test_throw_param_d.exports); -assertEquals("function", - typeof test_throw_param_d.exports.throw_param); - -assertWasmThrows(0, [16404, 0, 0, 0], - function() { test_throw_param_d.exports.throw_param(5.0); }); -assertWasmThrows(0, [16739, 4816, 0, 0], - function() { test_throw_param_d.exports.throw_param(10000000.5); }); - -/* TODO(kschimpf) Convert these tests to work for the proposed exceptions. - -// The following methods do not attempt to catch the exception they raise. -var test_throw = (function () { - var builder = new WasmModuleBuilder(); - +// Test the encoding of a computed parameter value. +(function TestThrowParamComputed() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_i); builder.addFunction("throw_expr_with_params", kSig_v_ddi) - .addBody([ - // p2 * (p0 + min(p0, p1))|0 - 20 - kExprGetLocal, 2, - kExprGetLocal, 0, - kExprGetLocal, 0, - kExprGetLocal, 1, - kExprF64Min, - kExprF64Add, - kExprI32SConvertF64, - kExprI32Mul, - kExprI32Const, 20, - kExprI32Sub, - kExprThrow, - ]) - .exportFunc() - - return builder.instantiate(); + .addBody([ + // p2 * (p0 + min(p0, p1))|0 - 20 + kExprGetLocal, 2, + kExprGetLocal, 0, + kExprGetLocal, 0, + kExprGetLocal, 1, + kExprF64Min, + kExprF64Add, + kExprI32SConvertF64, + kExprI32Mul, + kExprI32Const, 20, + kExprI32Sub, + kExprThrow, except, + ]).exportFunc() + let instance = builder.instantiate(); + + assertWasmThrows(instance, except, [65535, 65536-8], () => instance.exports.throw_expr_with_params(1.5, 2.5, 4)); + assertWasmThrows(instance, except, [0, 12], () => instance.exports.throw_expr_with_params(5.7, 2.5, 4)); })(); -// Check the test_throw exists. -assertFalse(test_throw === undefined); -assertFalse(test_throw === null); -assertFalse(test_throw === 0); -assertEquals("object", typeof test_throw.exports); -assertEquals("function", typeof test_throw.exports.throw_expr_with_params); - -assertEquals(1, test_throw.exports.throw_param_if_not_zero(0)); -assertWasmThrows( - -8, function() { test_throw.exports.throw_expr_with_params(1.5, 2.5, 4); }); -assertWasmThrows( - 12, function() { test_throw.exports.throw_expr_with_params(5.7, 2.5, 4); }); - -// Now that we know throwing works, we test catching the exceptions we raise. -var test_catch = (function () { - var builder = new WasmModuleBuilder(); - - // Helper function for throwing from js. It is imported by the Wasm module - // as throw_i. - function throw_value(value) { - throw value; - } - var sig_index = builder.addType(kSig_v_i); - var kJSThrowI = builder.addImport("", "throw_i", sig_index); - - // Helper function that throws a string. Wasm should not catch it. - function throw_string() { - throw "use wasm;"; - } - sig_index = builder.addType(kSig_v_v); - var kJSThrowString = builder.addImport("", "throw_string", sig_index); - - // Helper function that throws undefined. Wasm should not catch it. - function throw_undefined() { - throw undefined; - } - var kJSThrowUndefined = builder.addImport("", "throw_undefined", sig_index); - - // Helper function that throws an fp. Wasm should not catch it. - function throw_fp() { - throw 10.5; - } - var kJSThrowFP = builder.addImport("", "throw_fp", sig_index); - - // Helper function that throws a large number. Wasm should not catch it. - function throw_large() { - throw 1e+28; - } - var kJSThrowLarge = builder.addImport("", "throw_large", sig_index); +// Now that we know catching works locally, we test catching exceptions that +// cross function boundaries and/or raised by JavaScript. +(function TestCatchCrossFunctions() { + let builder = new WasmModuleBuilder(); + let except = builder.addException(kSig_v_i); + + // Helper function for throwing from JS. It is imported by the Wasm module + // as throw_i. + function throw_value(value) { + throw value; + } + let sig_index = builder.addType(kSig_v_i); + let kJSThrowI = builder.addImport("", "throw_i", sig_index); + + // Helper function that throws a string. Wasm should not catch it. + function throw_string() { + throw "use wasm"; + } + sig_index = builder.addType(kSig_v_v); + let kJSThrowString = builder.addImport("", "throw_string", sig_index); + + // Helper function that throws undefined. Wasm should not catch it. + function throw_undefined() { + throw undefined; + } + let kJSThrowUndefined = builder.addImport("", "throw_undefined", sig_index); + + // Helper function that throws an fp. Wasm should not catch it. + function throw_fp() { + throw 10.5; + } + let kJSThrowFP = builder.addImport("", "throw_fp", sig_index); + + // Helper function that throws a large number. Wasm should not catch it. + function throw_large() { + throw 1e+28; + } + let kJSThrowLarge = builder.addImport("", "throw_large", sig_index); + + // Helper function for throwing from WebAssembly. + let kWasmThrowFunction = + builder.addFunction("throw", kSig_v_i) + .addBody([ + kExprGetLocal, 0, + kExprThrow, except, + ]) + .index; - // Helper function for throwing from WebAssembly. - var kWasmThrowFunction = - builder.addFunction("throw", kSig_v_i) - .addBody([ + // Scenario 1: Throw and catch appear on the same function. This should + // happen in case of inlining, for example. + builder.addFunction("same_scope", kSig_i_i) + .addBody([ + kExprTry, kWasmI32, + kExprGetLocal, 0, + kExprI32Const, 0, + kExprI32Ne, + kExprIf, kWasmStmt, kExprGetLocal, 0, - kExprThrow - ]) - .index; + kExprThrow, except, + kExprUnreachable, + kExprEnd, + kExprI32Const, 63, + kExprCatch, except, + kExprEnd + ]) + .exportFunc(); - // Scenario 1: Throw and catch appear on the same function. This should - // happen in case of inlining, for example. - builder.addFunction("same_scope", kSig_i_i) - .addBody([ + builder.addFunction("same_scope_ignore", kSig_i_i) + .addBody([ kExprTry, kWasmI32, kExprGetLocal, 0, - kExprI32Const, 0, - kExprI32Ne, - kExprIf, kWasmStmt, - kExprGetLocal, 0, - kExprThrow, - kExprUnreachable, - kExprEnd, - kExprI32Const, 63, - kExprCatch, 1, - kExprGetLocal, 1, - kExprEnd - ]) - .addLocals({i32_count: 1}) - .exportFunc() - .index; - - builder.addFunction("same_scope_ignore", kSig_i_i) - .addBody([ - kExprTry, kWasmI32, - kExprGetLocal, 0, - kExprThrow, - kExprUnreachable, - kExprCatch, 1, - kExprGetLocal, 0, - kExprEnd, - ]) - .addLocals({i32_count: 1}) - .exportFunc(); - - builder.addFunction("same_scope_multiple", kSig_i_i) - // path = 0; - // - // try { - // try { - // try { - // if (p == 1) - // throw 1; - // path |= 2 - // } catch (v) { - // path |= v | 4; - // throw path; - // } - // if (p == 2) - // throw path|8; - // path |= 16; - // } catch (v) { - // path |= v | 32; - // throw path; - // } - // if (p == 3) - // throw path|64; - // path |= 128 - // } catch (v) { - // path |= v | 256; - // } - // - // return path; - // - // p == 1 -> path == 293 - // p == 2 -> path == 298 - // p == 3 -> path == 338 - // else -> path == 146 - .addBody([ + kExprThrow, except, + kExprUnreachable, + kExprCatch, except, + kExprEnd, + ]) + .exportFunc(); + + builder.addFunction("same_scope_multiple", kSig_i_i) + // path = 0; + // + // try { + // try { + // try { + // if (p == 1) + // throw 1; + // path |= 2 + // } catch (v) { + // path |= v | 4; + // throw path; + // } + // if (p == 2) + // throw path|8; + // path |= 16; + // } catch (v) { + // path |= v | 32; + // throw path; + // } + // if (p == 3) + // throw path|64; + // path |= 128 + // } catch (v) { + // path |= v | 256; + // } + // + // return path; + // + // p == 1 -> path == 293 + // p == 2 -> path == 298 + // p == 3 -> path == 338 + // else -> path == 146 + .addBody([ + kExprTry, kWasmI32, kExprTry, kWasmI32, kExprTry, kWasmI32, - kExprTry, kWasmI32, - kExprGetLocal, 0, - kExprI32Const, 1, - kExprI32Eq, - kExprIf, kWasmStmt, - kExprI32Const, 1, - kExprThrow, - kExprUnreachable, - kExprEnd, - kExprI32Const, 2, - kExprCatch, 1, - kExprGetLocal, 1, - kExprI32Const, 4, - kExprI32Ior, - kExprThrow, - kExprUnreachable, - kExprEnd, - kExprTeeLocal, 2, kExprGetLocal, 0, - kExprI32Const, 2, + kExprI32Const, 1, kExprI32Eq, kExprIf, kWasmStmt, - kExprGetLocal, 2, - kExprI32Const, 8, - kExprI32Ior, - kExprThrow, + kExprI32Const, 1, + kExprThrow, except, kExprUnreachable, kExprEnd, - kExprI32Const, 16, - kExprI32Ior, - kExprCatch, 1, - kExprGetLocal, 1, - kExprI32Const, 32, + kExprI32Const, 2, + kExprCatch, except, + kExprI32Const, 4, kExprI32Ior, - kExprThrow, + kExprThrow, except, kExprUnreachable, kExprEnd, - kExprTeeLocal, 2, + kExprTeeLocal, 1, kExprGetLocal, 0, - kExprI32Const, 3, + kExprI32Const, 2, kExprI32Eq, kExprIf, kWasmStmt, - kExprGetLocal, 2, - kExprI32Const, / *64=* / 192, 0, + kExprGetLocal, 1, + kExprI32Const, 8, kExprI32Ior, - kExprThrow, + kExprThrow, except, kExprUnreachable, kExprEnd, - kExprI32Const, / *128=* / 128, 1, + kExprI32Const, 16, kExprI32Ior, - kExprCatch, 1, + kExprCatch, except, + kExprI32Const, 32, + kExprI32Ior, + kExprThrow, except, + kExprUnreachable, + kExprEnd, + kExprTeeLocal, 1, + kExprGetLocal, 0, + kExprI32Const, 3, + kExprI32Eq, + kExprIf, kWasmStmt, kExprGetLocal, 1, - kExprI32Const, / *256=* / 128, 2, + kExprI32Const, /*64=*/ 192, 0, kExprI32Ior, + kExprThrow, except, + kExprUnreachable, kExprEnd, - ]) - .addLocals({i32_count: 2}) - .exportFunc(); + kExprI32Const, /*128=*/ 128, 1, + kExprI32Ior, + kExprCatch, except, + kExprI32Const, /*256=*/ 128, 2, + kExprI32Ior, + kExprEnd, + ]) + .addLocals({i32_count: 1}) + .exportFunc(); - // Scenario 2: Catches an exception raised from the direct callee. - var kFromDirectCallee = - builder.addFunction("from_direct_callee", kSig_i_i) - .addBody([ - kExprTry, kWasmI32, - kExprGetLocal, 0, - kExprCallFunction, kWasmThrowFunction, - kExprI32Const, / *-1=* / 127, - kExprCatch, 1, - kExprGetLocal, 1, - kExprEnd - ]) - .addLocals({i32_count: 1}) - .exportFunc() - .index; - - // Scenario 3: Catches an exception raised from an indirect callee. - var kFromIndirectCalleeHelper = kFromDirectCallee + 1; - builder.addFunction("from_indirect_callee_helper", kSig_v_ii) - .addBody([ + // Scenario 2: Catches an exception raised from the direct callee. + builder.addFunction("from_direct_callee", kSig_i_i) + .addBody([ + kExprTry, kWasmI32, kExprGetLocal, 0, - kExprI32Const, 0, - kExprI32GtS, - kExprIf, kWasmStmt, - kExprGetLocal, 0, - kExprI32Const, 1, - kExprI32Sub, - kExprGetLocal, 1, - kExprI32Const, 1, - kExprI32Sub, - kExprCallFunction, kFromIndirectCalleeHelper, - kExprEnd, - kExprGetLocal, 1, kExprCallFunction, kWasmThrowFunction, - ]); + kExprUnreachable, + kExprCatch, except, + kExprEnd, + ]) + .exportFunc(); - builder.addFunction("from_indirect_callee", kSig_i_i) - .addBody([ - kExprTry, kWasmI32, - kExprGetLocal, 0, - kExprI32Const, 0, - kExprCallFunction, kFromIndirectCalleeHelper, - kExprI32Const, / *-1=* / 127, - kExprCatch, 1, - kExprGetLocal, 1, - kExprEnd - ]) - .addLocals({i32_count: 1}) - .exportFunc(); + // Scenario 3: Catches an exception raised from an indirect callee. + let sig_v_i = builder.addType(kSig_v_i); + builder.appendToTable([kWasmThrowFunction, kWasmThrowFunction]); + builder.addFunction("from_indirect_callee", kSig_i_ii) + .addBody([ + kExprTry, kWasmI32, + kExprGetLocal, 0, + kExprGetLocal, 1, + kExprCallIndirect, sig_v_i, kTableZero, + kExprUnreachable, + kExprCatch, except, + kExprEnd + ]) + .exportFunc(); - // Scenario 4: Catches an exception raised in JS. - builder.addFunction("from_js", kSig_i_i) - .addBody([ - kExprTry, kWasmI32, - kExprGetLocal, 0, - kExprCallFunction, kJSThrowI, - kExprI32Const, / *-1=* / 127, - kExprCatch, 1, - kExprGetLocal, 1, - kExprEnd, - ]) - .addLocals({i32_count: 1}) - .exportFunc(); + // Scenario 4: Does not catch an exception raised in JS, even if primitive + // values are being used as exceptions. + builder.addFunction("i_from_js", kSig_i_i) + .addBody([ + kExprTry, kWasmI32, + kExprGetLocal, 0, + kExprCallFunction, kJSThrowI, + kExprUnreachable, + kExprCatch, except, + kExprUnreachable, + kExprEnd, + ]) + .exportFunc(); - // Scenario 5: Does not catch an exception raised in JS if it is not a - // number. - builder.addFunction("string_from_js", kSig_v_v) - .addBody([ - kExprCallFunction, kJSThrowString - ]) - .exportFunc(); + builder.addFunction("string_from_js", kSig_v_v) + .addBody([ + kExprTry, kWasmStmt, + kExprCallFunction, kJSThrowString, + kExprCatch, except, + kExprUnreachable, + kExprEnd, + ]) + .exportFunc(); - builder.addFunction("fp_from_js", kSig_v_v) - .addBody([ - kExprCallFunction, kJSThrowFP - ]) - .exportFunc(); + builder.addFunction("fp_from_js", kSig_v_v) + .addBody([ + kExprTry, kWasmStmt, + kExprCallFunction, kJSThrowFP, + kExprCatch, except, + kExprUnreachable, + kExprEnd, + ]) + .exportFunc(); - builder.addFunction("large_from_js", kSig_v_v) - .addBody([ - kExprCallFunction, kJSThrowLarge - ]) - .exportFunc(); + builder.addFunction("large_from_js", kSig_v_v) + .addBody([ + kExprTry, kWasmStmt, + kExprCallFunction, kJSThrowLarge, + kExprCatch, except, + kExprUnreachable, + kExprEnd, + ]) + .exportFunc(); - builder.addFunction("undefined_from_js", kSig_v_v) - .addBody([ - kExprCallFunction, kJSThrowUndefined - ]) - .exportFunc(); + builder.addFunction("undefined_from_js", kSig_v_v) + .addBody([ + kExprTry, kWasmStmt, + kExprCallFunction, kJSThrowUndefined, + kExprCatch, except, + kExprUnreachable, + kExprEnd, + ]) + .exportFunc(); - return builder.instantiate({"": { + let instance = builder.instantiate({"": { throw_i: throw_value, throw_string: throw_string, throw_fp: throw_fp, throw_large, throw_large, throw_undefined: throw_undefined }}); -})(); -// Check the test_catch exists. -assertFalse(test_catch === undefined); -assertFalse(test_catch === null); -assertFalse(test_catch === 0); -assertEquals("object", typeof test_catch.exports); -assertEquals("function", typeof test_catch.exports.same_scope); -assertEquals("function", typeof test_catch.exports.same_scope_ignore); -assertEquals("function", typeof test_catch.exports.same_scope_multiple); -assertEquals("function", typeof test_catch.exports.from_direct_callee); -assertEquals("function", typeof test_catch.exports.from_indirect_callee); -assertEquals("function", typeof test_catch.exports.from_js); -assertEquals("function", typeof test_catch.exports.string_from_js); - -assertEquals(63, test_catch.exports.same_scope(0)); -assertEquals(1024, test_catch.exports.same_scope(1024)); -assertEquals(-3, test_catch.exports.same_scope(-3)); -assertEquals(-1, test_catch.exports.same_scope_ignore(-1)); -assertEquals(1, test_catch.exports.same_scope_ignore(1)); -assertEquals(0x7FFFFFFF, test_catch.exports.same_scope_ignore(0x7FFFFFFF)); -assertEquals(1024, test_catch.exports.same_scope_ignore(1024)); -assertEquals(-1, test_catch.exports.same_scope_ignore(-1)); -assertEquals(293, test_catch.exports.same_scope_multiple(1)); -assertEquals(298, test_catch.exports.same_scope_multiple(2)); -assertEquals(338, test_catch.exports.same_scope_multiple(3)); -assertEquals(146, test_catch.exports.same_scope_multiple(0)); -assertEquals(-10024, test_catch.exports.from_direct_callee(-10024)); -assertEquals(3334333, test_catch.exports.from_direct_callee(3334333)); -assertEquals(-1, test_catch.exports.from_direct_callee(0xFFFFFFFF)); -assertEquals(0x7FFFFFFF, test_catch.exports.from_direct_callee(0x7FFFFFFF)); -assertEquals(-10, test_catch.exports.from_indirect_callee(10)); -assertEquals(-77, test_catch.exports.from_indirect_callee(77)); -assertEquals(10, test_catch.exports.from_js(10)); -assertEquals(-10, test_catch.exports.from_js(-10)); - -assertThrowsEquals(test_catch.exports.string_from_js, "use wasm;"); -assertThrowsEquals(test_catch.exports.large_from_js, 1e+28); -assertThrowsEquals(test_catch.exports.undefined_from_js, undefined); -*/ + assertEquals(63, instance.exports.same_scope(0)); + assertEquals(1024, instance.exports.same_scope(1024)); + assertEquals(-3, instance.exports.same_scope(-3)); + assertEquals(-1, instance.exports.same_scope_ignore(-1)); + assertEquals(1, instance.exports.same_scope_ignore(1)); + assertEquals(0x7FFFFFFF, instance.exports.same_scope_ignore(0x7FFFFFFF)); + assertEquals(1024, instance.exports.same_scope_ignore(1024)); + assertEquals(-1, instance.exports.same_scope_ignore(-1)); + assertEquals(293, instance.exports.same_scope_multiple(1)); + assertEquals(298, instance.exports.same_scope_multiple(2)); + assertEquals(338, instance.exports.same_scope_multiple(3)); + assertEquals(146, instance.exports.same_scope_multiple(0)); + assertEquals(-10024, instance.exports.from_direct_callee(-10024)); + assertEquals(3334333, instance.exports.from_direct_callee(3334333)); + assertEquals(-1, instance.exports.from_direct_callee(0xFFFFFFFF)); + assertEquals(0x7FFFFFFF, instance.exports.from_direct_callee(0x7FFFFFFF)); + assertEquals(10, instance.exports.from_indirect_callee(10, 0)); + assertEquals(77, instance.exports.from_indirect_callee(77, 1)); + + assertThrowsEquals(() => instance.exports.i_from_js(10), 10); + assertThrowsEquals(() => instance.exports.i_from_js(-10), -10); + assertThrowsEquals(instance.exports.string_from_js, "use wasm"); + assertThrowsEquals(instance.exports.fp_from_js, 10.5); + assertThrowsEquals(instance.exports.large_from_js, 1e+28); + assertThrowsEquals(instance.exports.undefined_from_js, undefined); +})(); diff --git a/deps/v8/test/mjsunit/wasm/grow-memory-detaching.js b/deps/v8/test/mjsunit/wasm/grow-memory-detaching.js index da6516afd7..69273d9184 100644 --- a/deps/v8/test/mjsunit/wasm/grow-memory-detaching.js +++ b/deps/v8/test/mjsunit/wasm/grow-memory-detaching.js @@ -9,7 +9,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js"); let module = (() => { let builder = new WasmModuleBuilder(); - builder.addMemory(1, kV8MaxPages, false); + builder.addMemory(1, undefined, false); builder.addFunction("grow_memory", kSig_i_i) .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) .exportFunc(); diff --git a/deps/v8/test/mjsunit/wasm/grow-memory.js b/deps/v8/test/mjsunit/wasm/grow-memory.js index fc82dc6004..48e3252d08 100644 --- a/deps/v8/test/mjsunit/wasm/grow-memory.js +++ b/deps/v8/test/mjsunit/wasm/grow-memory.js @@ -37,11 +37,15 @@ function genGrowMemoryBuilder() { return builder; } +// V8 internal memory size limit. +var kV8MaxPages = 32767; + + // TODO(gdeepti): Generate tests programatically for all the sizes instead of // current implementation. function testGrowMemoryReadWrite32() { var builder = genGrowMemoryBuilder(); - builder.addMemory(1, kV8MaxPages, false); + builder.addMemory(1, undefined, false); var module = builder.instantiate(); var offset; function peek() { return module.exports.load(offset); } @@ -88,7 +92,7 @@ testGrowMemoryReadWrite32(); function testGrowMemoryReadWrite16() { var builder = genGrowMemoryBuilder(); - builder.addMemory(1, kV8MaxPages, false); + builder.addMemory(1, undefined, false); var module = builder.instantiate(); var offset; function peek() { return module.exports.load16(offset); } @@ -135,7 +139,7 @@ testGrowMemoryReadWrite16(); function testGrowMemoryReadWrite8() { var builder = genGrowMemoryBuilder(); - builder.addMemory(1, kV8MaxPages, false); + builder.addMemory(1, undefined, false); var module = builder.instantiate(); var offset; function peek() { return module.exports.load8(offset); } @@ -182,7 +186,7 @@ testGrowMemoryReadWrite8(); function testGrowMemoryZeroInitialSize() { var builder = genGrowMemoryBuilder(); - builder.addMemory(0, kV8MaxPages, false); + builder.addMemory(0, undefined, false); var module = builder.instantiate(); var offset; function peek() { return module.exports.load(offset); } @@ -216,7 +220,7 @@ testGrowMemoryZeroInitialSize(); function testGrowMemoryZeroInitialSize32() { var builder = genGrowMemoryBuilder(); - builder.addMemory(0, kV8MaxPages, false); + builder.addMemory(0, undefined, false); var module = builder.instantiate(); var offset; function peek() { return module.exports.load(offset); } @@ -242,7 +246,7 @@ testGrowMemoryZeroInitialSize32(); function testGrowMemoryZeroInitialSize16() { var builder = genGrowMemoryBuilder(); - builder.addMemory(0, kV8MaxPages, false); + builder.addMemory(0, undefined, false); var module = builder.instantiate(); var offset; function peek() { return module.exports.load16(offset); } @@ -268,7 +272,7 @@ testGrowMemoryZeroInitialSize16(); function testGrowMemoryZeroInitialSize8() { var builder = genGrowMemoryBuilder(); - builder.addMemory(0, kV8MaxPages, false); + builder.addMemory(0, undefined, false); var module = builder.instantiate(); var offset; function peek() { return module.exports.load8(offset); } @@ -294,7 +298,7 @@ testGrowMemoryZeroInitialSize8(); function testGrowMemoryTrapMaxPagesZeroInitialMemory() { var builder = genGrowMemoryBuilder(); - builder.addMemory(0, kV8MaxPages, false); + builder.addMemory(0, undefined, false); var module = builder.instantiate(); function growMem(pages) { return module.exports.grow_memory(pages); } assertEquals(-1, growMem(kV8MaxPages + 1)); @@ -314,7 +318,7 @@ testGrowMemoryTrapMaxPages(); function testGrowMemoryTrapsWithNonSmiInput() { var builder = genGrowMemoryBuilder(); - builder.addMemory(0, kV8MaxPages, false); + builder.addMemory(0, undefined, false); var module = builder.instantiate(); function growMem(pages) { return module.exports.grow_memory(pages); } // The parameter of grow_memory is unsigned. Therefore -1 stands for @@ -326,7 +330,7 @@ testGrowMemoryTrapsWithNonSmiInput(); function testGrowMemoryCurrentMemory() { var builder = genGrowMemoryBuilder(); - builder.addMemory(1, kV8MaxPages, false); + builder.addMemory(1, undefined, false); builder.addFunction("memory_size", kSig_i_v) .addBody([kExprMemorySize, kMemoryZero]) .exportFunc(); @@ -342,7 +346,7 @@ testGrowMemoryCurrentMemory(); function testGrowMemoryPreservesDataMemOp32() { var builder = genGrowMemoryBuilder(); - builder.addMemory(1, kV8MaxPages, false); + builder.addMemory(1, undefined, false); var module = builder.instantiate(); var offset, val; function peek() { return module.exports.load(offset); } @@ -365,7 +369,7 @@ testGrowMemoryPreservesDataMemOp32(); function testGrowMemoryPreservesDataMemOp16() { var builder = genGrowMemoryBuilder(); - builder.addMemory(1, kV8MaxPages, false); + builder.addMemory(1, undefined, false); var module = builder.instantiate(); var offset, val; function peek() { return module.exports.load16(offset); } @@ -388,7 +392,7 @@ testGrowMemoryPreservesDataMemOp16(); function testGrowMemoryPreservesDataMemOp8() { var builder = genGrowMemoryBuilder(); - builder.addMemory(1, kV8MaxPages, false); + builder.addMemory(1, undefined, false); var module = builder.instantiate(); var offset, val = 0; function peek() { return module.exports.load8(offset); } @@ -415,7 +419,7 @@ testGrowMemoryPreservesDataMemOp8(); function testGrowMemoryOutOfBoundsOffset() { var builder = genGrowMemoryBuilder(); - builder.addMemory(1, kV8MaxPages, false); + builder.addMemory(1, undefined, false); var module = builder.instantiate(); var offset, val; function peek() { return module.exports.load(offset); } @@ -492,7 +496,7 @@ testGrowMemoryDeclaredSpecMaxTraps(); function testGrowMemory2Gb() { print("testGrowMemory2Gb"); var builder = genGrowMemoryBuilder(); - builder.addMemory(1, kV8MaxPages, false); + builder.addMemory(1, undefined, false); var module = builder.instantiate(); var offset, val; function peek() { return module.exports.load(offset); } diff --git a/deps/v8/test/mjsunit/wasm/import-memory.js b/deps/v8/test/mjsunit/wasm/import-memory.js index df4f0d3fe8..ca91c698c8 100644 --- a/deps/v8/test/mjsunit/wasm/import-memory.js +++ b/deps/v8/test/mjsunit/wasm/import-memory.js @@ -7,6 +7,9 @@ load("test/mjsunit/wasm/wasm-constants.js"); load("test/mjsunit/wasm/wasm-module-builder.js"); +// V8 internal memory size limit. +var kV8MaxPages = 32767; + (function TestOne() { print("TestOne"); let memory = new WebAssembly.Memory({initial: 1}); diff --git a/deps/v8/test/mjsunit/wasm/import-mutable-global.js b/deps/v8/test/mjsunit/wasm/import-mutable-global.js index 4985d99211..46b9ca5f5a 100644 --- a/deps/v8/test/mjsunit/wasm/import-mutable-global.js +++ b/deps/v8/test/mjsunit/wasm/import-mutable-global.js @@ -195,7 +195,7 @@ function addGlobalGetterAndSetter(builder, index, name, type) { (function TestImportedAndNonImportedMutableGlobal() { let global = new WebAssembly.Global({value: 'i32', mutable: true}, 1); let builder = new WasmModuleBuilder(); - builder.addGlobal(kWasmI32, true).exportAs('i32'); builder.addImportedGlobal("mod", "g", kWasmI32, true); + builder.addGlobal(kWasmI32, true).exportAs('i32'); builder.instantiate({mod: {g: global}}); })(); diff --git a/deps/v8/test/mjsunit/wasm/table.js b/deps/v8/test/mjsunit/wasm/table.js index 4724561670..32bdecad66 100644 --- a/deps/v8/test/mjsunit/wasm/table.js +++ b/deps/v8/test/mjsunit/wasm/table.js @@ -159,8 +159,8 @@ function assertTableIsValid(table, length) { (function TestSet() { let builder = new WasmModuleBuilder; - builder.addExport("wasm", builder.addFunction("", kSig_v_v).addBody([])); builder.addExport("host", builder.addImport("test", "f", kSig_v_v)); + builder.addExport("wasm", builder.addFunction("", kSig_v_v).addBody([])); let {wasm, host} = builder.instantiate({test: {f() {}}}).exports; let table = new WebAssembly.Table({element: "anyfunc", initial: 10}); @@ -207,8 +207,8 @@ function assertTableIsValid(table, length) { (function TestIndexing() { let builder = new WasmModuleBuilder; - builder.addExport("wasm", builder.addFunction("", kSig_v_v).addBody([])); builder.addExport("host", builder.addImport("test", "f", kSig_v_v)); + builder.addExport("wasm", builder.addFunction("", kSig_v_v).addBody([])); let {wasm, host} = builder.instantiate({test: {f() {}}}).exports; let table = new WebAssembly.Table({element: "anyfunc", initial: 10}); @@ -230,8 +230,8 @@ function assertTableIsValid(table, length) { (function TestGrow() { let builder = new WasmModuleBuilder; - builder.addExport("wasm", builder.addFunction("", kSig_v_v).addBody([])); builder.addExport("host", builder.addImport("test", "f", kSig_v_v)); + builder.addExport("wasm", builder.addFunction("", kSig_v_v).addBody([])); let {wasm, host} = builder.instantiate({test: {f() {}}}).exports; function init(table) { diff --git a/deps/v8/test/mjsunit/wasm/trap-handler-fallback.js b/deps/v8/test/mjsunit/wasm/trap-handler-fallback.js index 26296696c5..465ca449cc 100644 --- a/deps/v8/test/mjsunit/wasm/trap-handler-fallback.js +++ b/deps/v8/test/mjsunit/wasm/trap-handler-fallback.js @@ -33,17 +33,14 @@ load("test/mjsunit/wasm/wasm-module-builder.js"); // space per isolate (see kAddressSpaceLimit in wasm-memory.cc), which allows // up to 128 fast memories. As long as we create more than that, we should // trigger the fallback behavior. - for (var i = 0; i < 135; i++) { + for (var i = 0; i < 135 && !fallback_occurred; i++) { memory = new WebAssembly.Memory({initial: 1}); instance = builder.instantiate({mod: {imported_mem: memory}}); instances.push(instance); assertTraps(kTrapMemOutOfBounds, () => instance.exports.load(1 << 20)); - fallback_occurred = fallback_occurred || !%WasmMemoryHasFullGuardRegion(memory); - if (fallback_occurred) { - break; - } + fallback_occurred = !%WasmMemoryHasFullGuardRegion(memory); } assertTrue(fallback_occurred); })(); @@ -63,17 +60,14 @@ load("test/mjsunit/wasm/wasm-module-builder.js"); // space per isolate (see kAddressSpaceLimit in wasm-memory.cc), which allows // up to 128 fast memories. As long as we create more than that, we should // trigger the fallback behavior. - for (var i = 0; i < 135; i++) { + for (var i = 0; i < 135 && !fallback_occurred; i++) { memory = new WebAssembly.Memory({initial: 1}); instance = builder.instantiate({mod: {imported_mem: memory}}); instances.push(instance); assertTraps(kTrapMemOutOfBounds, () => instance.exports.load(1 << 20)); - fallback_occurred = fallback_occurred || !%WasmMemoryHasFullGuardRegion(memory); - if (fallback_occurred) { - break; - } + fallback_occurred = !%WasmMemoryHasFullGuardRegion(memory); } assertTrue(fallback_occurred); })(); @@ -132,17 +126,14 @@ load("test/mjsunit/wasm/wasm-module-builder.js"); // up to 128 fast memories. As long as we create more than that, we should // trigger the fallback behavior. const module = builder.toModule(); - for (var i = 0; i < 135; i++) { + for (var i = 0; i < 135 && !fallback_occurred; i++) { memory = new WebAssembly.Memory({initial: 1}); instance = new WebAssembly.Instance(module, {mod: {imported_mem: memory}}); instances.push(instance); assertTraps(kTrapMemOutOfBounds, () => instance.exports.load(1 << 20)); - fallback_occurred = fallback_occurred || !%WasmMemoryHasFullGuardRegion(memory); - if (fallback_occurred) { - break; - } + fallback_occurred = !%WasmMemoryHasFullGuardRegion(memory); } assertTrue(fallback_occurred); })(); diff --git a/deps/v8/test/mjsunit/wasm/unicode.js b/deps/v8/test/mjsunit/wasm/unicode.js index 49c95da030..7e29c00f33 100644 --- a/deps/v8/test/mjsunit/wasm/unicode.js +++ b/deps/v8/test/mjsunit/wasm/unicode.js @@ -52,7 +52,7 @@ checkExports('☺☺mul☺☺', '☺☺mul☺☺', '☺☺add☺☺', '☺☺add builder.addFunction('three snowmen: ☃☃☃', kSig_i_v).addBody([]).exportFunc(); assertThrows( () => builder.instantiate(), WebAssembly.CompileError, - /Compiling wasm function #0:three snowmen: ☃☃☃ failed: /); + /Compiling wasm function "three snowmen: ☃☃☃" failed: /); })(); (function errorMessageUnicodeInImportModuleName() { diff --git a/deps/v8/test/mjsunit/wasm/wasm-constants.js b/deps/v8/test/mjsunit/wasm/wasm-constants.js index f5aead9fb6..cc10e9953c 100644 --- a/deps/v8/test/mjsunit/wasm/wasm-constants.js +++ b/deps/v8/test/mjsunit/wasm/wasm-constants.js @@ -15,9 +15,6 @@ function bytes() { return buffer; } -// V8 internal constants -var kV8MaxPages = 32767; - // Header declaration constants var kWasmH0 = 0; var kWasmH1 = 0x61; @@ -94,11 +91,13 @@ let kWasmF32 = 0x7d; let kWasmF64 = 0x7c; let kWasmS128 = 0x7b; let kWasmAnyRef = 0x6f; +let kWasmExceptRef = 0x68; let kExternalFunction = 0; let kExternalTable = 1; let kExternalMemory = 2; let kExternalGlobal = 3; +let kExternalException = 4; let kTableZero = 0; let kMemoryZero = 0; @@ -373,6 +372,43 @@ let kExprI32AtomicCompareExchange = 0x48 let kExprI32AtomicCompareExchange8U = 0x4a let kExprI32AtomicCompareExchange16U = 0x4b +let kExprI64AtomicLoad = 0x11; +let kExprI64AtomicLoad8U = 0x14; +let kExprI64AtomicLoad16U = 0x15; +let kExprI64AtomicLoad32U = 0x16; +let kExprI64AtomicStore = 0x18; +let kExprI64AtomicStore8U = 0x1b; +let kExprI64AtomicStore16U = 0x1c; +let kExprI64AtomicStore32U = 0x1d; +let kExprI64AtomicAdd = 0x1f; +let kExprI64AtomicAdd8U = 0x22; +let kExprI64AtomicAdd16U = 0x23; +let kExprI64AtomicAdd32U = 0x24; +let kExprI64AtomicSub = 0x26; +let kExprI64AtomicSub8U = 0x29; +let kExprI64AtomicSub16U = 0x2a; +let kExprI64AtomicSub32U = 0x2b; +let kExprI64AtomicAnd = 0x2d; +let kExprI64AtomicAnd8U = 0x30; +let kExprI64AtomicAnd16U = 0x31; +let kExprI64AtomicAnd32U = 0x32; +let kExprI64AtomicOr = 0x34; +let kExprI64AtomicOr8U = 0x37; +let kExprI64AtomicOr16U = 0x38; +let kExprI64AtomicOr32U = 0x39; +let kExprI64AtomicXor = 0x3b; +let kExprI64AtomicXor8U = 0x3e; +let kExprI64AtomicXor16U = 0x3f; +let kExprI64AtomicXor32U = 0x40; +let kExprI64AtomicExchange = 0x42; +let kExprI64AtomicExchange8U = 0x45; +let kExprI64AtomicExchange16U = 0x46; +let kExprI64AtomicExchange32U = 0x47; +let kExprI64AtomicCompareExchange = 0x49 +let kExprI64AtomicCompareExchange8U = 0x4c; +let kExprI64AtomicCompareExchange16U = 0x4d; +let kExprI64AtomicCompareExchange32U = 0x4e; + let kTrapUnreachable = 0; let kTrapMemOutOfBounds = 1; let kTrapDivByZero = 2; @@ -413,29 +449,6 @@ function assertTraps(trap, code) { throw new MjsUnitAssertionError('Did not trap, expected: ' + kTrapMsgs[trap]); } -function assertWasmThrows(runtime_id, values, code) { - try { - if (typeof code === 'function') { - code(); - } else { - eval(code); - } - } catch (e) { - assertTrue(e instanceof WebAssembly.RuntimeError); - var e_runtime_id = e['WasmExceptionRuntimeId']; - assertEquals(e_runtime_id, runtime_id); - assertTrue(Number.isInteger(e_runtime_id)); - var e_values = e['WasmExceptionValues']; - assertEquals(values.length, e_values.length); - for (i = 0; i < values.length; ++i) { - assertEquals(values[i], e_values[i]); - } - // Success. - return; - } - throw new MjsUnitAssertionError('Did not throw expected: ' + runtime_id + values); -} - function wasmI32Const(val) { let bytes = [kExprI32Const]; for (let i = 0; i < 4; ++i) { diff --git a/deps/v8/test/mjsunit/wasm/wasm-module-builder.js b/deps/v8/test/mjsunit/wasm/wasm-module-builder.js index 98a3c6d4e0..38b4a0e308 100644 --- a/deps/v8/test/mjsunit/wasm/wasm-module-builder.js +++ b/deps/v8/test/mjsunit/wasm/wasm-module-builder.js @@ -179,6 +179,7 @@ class WasmModuleBuilder { this.explicit = []; this.num_imported_funcs = 0; this.num_imported_globals = 0; + this.num_imported_exceptions = 0; return this; } @@ -228,10 +229,12 @@ class WasmModuleBuilder { } addException(type) { - if (type.results.length != 0) - throw new Error('Invalid exception signature: ' + type); + if (type.results.length != 0) { + throw new Error('Exception signature must have void result: ' + type); + } + let except_index = this.exceptions.length + this.num_imported_exceptions; this.exceptions.push(type); - return this.exceptions.length - 1; + return except_index; } addFunction(name, type) { @@ -243,6 +246,9 @@ class WasmModuleBuilder { } addImport(module = "", name, type) { + if (this.functions.length != 0) { + throw new Error('Imported functions must be declared before local ones'); + } let type_index = (typeof type) == "number" ? type : this.addType(type); this.imports.push({module: module, name: name, kind: kExternalFunction, type: type_index}); @@ -250,6 +256,9 @@ class WasmModuleBuilder { } addImportedGlobal(module = "", name, type, mutable = false) { + if (this.globals.length != 0) { + throw new Error('Imported globals must be declared before local ones'); + } let o = {module: module, name: name, kind: kExternalGlobal, type: type, mutable: mutable}; this.imports.push(o); @@ -269,6 +278,18 @@ class WasmModuleBuilder { this.imports.push(o); } + addImportedException(module = "", name, type) { + if (type.results.length != 0) { + throw new Error('Exception signature must have void result: ' + type); + } + if (this.exceptions.length != 0) { + throw new Error('Imported exceptions must be declared before local ones'); + } + let o = {module: module, name: name, kind: kExternalException, type: type}; + this.imports.push(o); + return this.num_imported_exceptions++; + } + addExport(name, index) { this.exports.push({name: name, kind: kExternalFunction, index: index}); return this; @@ -378,6 +399,11 @@ class WasmModuleBuilder { section.emit_u8(has_max ? 1 : 0); // flags section.emit_u32v(imp.initial); // initial if (has_max) section.emit_u32v(imp.maximum); // maximum + } else if (imp.kind == kExternalException) { + section.emit_u32v(imp.type.params.length); + for (let param of imp.type.params) { + section.emit_u8(param); + } } else { throw new Error("unknown/unsupported import kind " + imp.kind); } @@ -478,6 +504,20 @@ class WasmModuleBuilder { }); } + // Add exceptions. + if (wasm.exceptions.length > 0) { + if (debug) print("emitting exceptions @ " + binary.length); + binary.emit_section(kExceptionSectionCode, section => { + section.emit_u32v(wasm.exceptions.length); + for (let type of wasm.exceptions) { + section.emit_u32v(type.params.length); + for (let param of type.params) { + section.emit_u8(param); + } + } + }); + } + // Add export table. var mem_export = (wasm.memory !== undefined && wasm.memory.exp); var exports_count = wasm.exports.length + (mem_export ? 1 : 0); @@ -530,20 +570,6 @@ class WasmModuleBuilder { }); } - // Add exceptions. - if (wasm.exceptions.length > 0) { - if (debug) print("emitting exceptions @ " + binary.length); - binary.emit_section(kExceptionSectionCode, section => { - section.emit_u32v(wasm.exceptions.length); - for (let type of wasm.exceptions) { - section.emit_u32v(type.params.length); - for (let param of type.params) { - section.emit_u8(param); - } - } - }); - } - // Add function bodies. if (wasm.functions.length > 0) { // emit function bodies @@ -569,6 +595,12 @@ class WasmModuleBuilder { if (l.s128_count > 0) { local_decls.push({count: l.s128_count, type: kWasmS128}); } + if (l.anyref_count > 0) { + local_decls.push({count: l.anyref_count, type: kWasmAnyRef}); + } + if (l.except_count > 0) { + local_decls.push({count: l.except_count, type: kWasmExceptRef}); + } } let header = new Binary; diff --git a/deps/v8/test/mjsunit/wasm/worker-interpreter.js b/deps/v8/test/mjsunit/wasm/worker-interpreter.js index d730ed7a74..9bc1e1e11c 100644 --- a/deps/v8/test/mjsunit/wasm/worker-interpreter.js +++ b/deps/v8/test/mjsunit/wasm/worker-interpreter.js @@ -34,7 +34,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js"); } } `; - let worker = new Worker(workerScript); + let worker = new Worker(workerScript, {type: 'string'}); // Call method without using the interpreter. var initial_interpreted = %WasmNumInterpretedCalls(instance); diff --git a/deps/v8/test/mjsunit/wasm/worker-memory.js b/deps/v8/test/mjsunit/wasm/worker-memory.js index e2a8cf8857..c5b99ede7e 100644 --- a/deps/v8/test/mjsunit/wasm/worker-memory.js +++ b/deps/v8/test/mjsunit/wasm/worker-memory.js @@ -5,7 +5,7 @@ // Flags: --experimental-wasm-threads (function TestPostMessageUnsharedMemory() { - let worker = new Worker(''); + let worker = new Worker('', {type: 'string'}); let memory = new WebAssembly.Memory({initial: 1, maximum: 2}); assertThrows(() => worker.postMessage(memory), Error); @@ -39,7 +39,7 @@ let workerHelpers = postMessage("OK"); };`; - let worker = new Worker(workerScript); + let worker = new Worker(workerScript, {type: 'string'}); let memory = new WebAssembly.Memory({initial: 1, maximum: 2, shared: true}); worker.postMessage(memory); assertEquals("OK", worker.getMessage()); @@ -60,7 +60,7 @@ let workerHelpers = postMessage("OK"); };`; - let worker = new Worker(workerScript); + let worker = new Worker(workerScript, {type: 'string'}); let memory = new WebAssembly.Memory({initial: 1, maximum: 2, shared: true}); let obj = {memories: [memory, memory], buffer: memory.buffer, foo: 1}; worker.postMessage(obj); @@ -75,7 +75,8 @@ let workerHelpers = postMessage("OK"); };`; - let workers = [new Worker(workerScript), new Worker(workerScript)]; + let workers = [new Worker(workerScript, {type: 'string'}), + new Worker(workerScript, {type: 'string'})]; let memory = new WebAssembly.Memory({initial: 1, maximum: 2, shared: true}); for (let worker of workers) { worker.postMessage(memory); diff --git a/deps/v8/test/mjsunit/wasm/worker-module.js b/deps/v8/test/mjsunit/wasm/worker-module.js index 72645f8dbf..b60b19571b 100644 --- a/deps/v8/test/mjsunit/wasm/worker-module.js +++ b/deps/v8/test/mjsunit/wasm/worker-module.js @@ -27,7 +27,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js"); } `; - let worker = new Worker(workerScript); + let worker = new Worker(workerScript, {type: 'string'}); worker.postMessage(module); assertEquals(42, worker.getMessage()); worker.terminate(); |