diff --git a/implementation-contributed/curation_logs/v8.json b/implementation-contributed/curation_logs/v8.json
index 5a28d08464cbd6ae1367d4939d91870224d1599c..e60d641446b911917bf2e7a544163eede457980f 100644
--- a/implementation-contributed/curation_logs/v8.json
+++ b/implementation-contributed/curation_logs/v8.json
@@ -1,5 +1,5 @@
{
- "sourceRevisionAtLastExport": "06354392",
- "targetRevisionAtLastExport": "e69d65f39",
+ "sourceRevisionAtLastExport": "1e6d9607",
+ "targetRevisionAtLastExport": "eeae2a723",
"curatedFiles": {}
}
\ No newline at end of file
diff --git a/implementation-contributed/v8/mjsunit/compiler/abstract-equal-symbol.js b/implementation-contributed/v8/mjsunit/compiler/abstract-equal-symbol.js
new file mode 100644
index 0000000000000000000000000000000000000000..c1057e1d1b7cab70b00039462fc5d530a5428b83
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/compiler/array-buffer-is-view.js b/implementation-contributed/v8/mjsunit/compiler/array-buffer-is-view.js
new file mode 100644
index 0000000000000000000000000000000000000000..b56763b5b2a384dac593cff377641d9cac6cd5d0
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/compiler/array-is-array.js b/implementation-contributed/v8/mjsunit/compiler/array-is-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..37c916ddac515a32a1229659ccfa4066a7783259
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/compiler/dataview-constant.js b/implementation-contributed/v8/mjsunit/compiler/dataview-constant.js
new file mode 100644
index 0000000000000000000000000000000000000000..f5f0b5e9558381da20240bd47491b321d03239bd
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/compiler/dataview-neutered.js b/implementation-contributed/v8/mjsunit/compiler/dataview-neutered.js
new file mode 100644
index 0000000000000000000000000000000000000000..54b35f73c8ad81e3a1344666712ef6ba6c863b14
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/compiler/dataview-nonconstant.js b/implementation-contributed/v8/mjsunit/compiler/dataview-nonconstant.js
new file mode 100644
index 0000000000000000000000000000000000000000..0420660c83c3b4ab406c1c17b91c51e20ffb89b9
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/compiler/math-imul.js b/implementation-contributed/v8/mjsunit/compiler/math-imul.js
new file mode 100644
index 0000000000000000000000000000000000000000..1de18a6a2d133a3cd12997e02f6f2bb8a7f73401
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/compiler/number-add.js b/implementation-contributed/v8/mjsunit/compiler/number-add.js
index d0f2c63194c978e525513166f715aa3360f1ac91..61e6495c527748bc93a25662de3e3bcac6ab486a 100644
--- a/implementation-contributed/v8/mjsunit/compiler/number-add.js
+++ b/implementation-contributed/v8/mjsunit/compiler/number-add.js
@@ -31,3 +31,32 @@
%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/implementation-contributed/v8/mjsunit/compiler/number-divide.js b/implementation-contributed/v8/mjsunit/compiler/number-divide.js
new file mode 100644
index 0000000000000000000000000000000000000000..c4cc8fa88190c3f47e9492da01bccdb17f74dafd
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/compiler/number-issafeinteger.js b/implementation-contributed/v8/mjsunit/compiler/number-issafeinteger.js
index 192fb6c124f5acc5ca9e4f3a653d431e4c8cd455..b705e95ed53169fb6dfae3fbcaaf5054f6d2c3df 100644
--- a/implementation-contributed/v8/mjsunit/compiler/number-issafeinteger.js
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/compiler/number-modulus.js b/implementation-contributed/v8/mjsunit/compiler/number-modulus.js
new file mode 100644
index 0000000000000000000000000000000000000000..cccb93b8033436fb000f974359bd875c9dadff2f
--- /dev/null
+++ b/implementation-contributed/v8/mjsunit/compiler/number-modulus.js
@@ -0,0 +1,125 @@
+// 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 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);
+})();
diff --git a/implementation-contributed/v8/mjsunit/compiler/number-subtract.js b/implementation-contributed/v8/mjsunit/compiler/number-subtract.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb3e1c7e708e4e498f6cf8674b3c6f87e95c5078
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/compiler/redundancy-elimination.js b/implementation-contributed/v8/mjsunit/compiler/redundancy-elimination.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1bed70d6af94ab621d505f1480cdc6af3151369
--- /dev/null
+++ b/implementation-contributed/v8/mjsunit/compiler/redundancy-elimination.js
@@ -0,0 +1,134 @@
+// 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 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));
+})();
diff --git a/implementation-contributed/v8/mjsunit/d8/d8-worker-script.js b/implementation-contributed/v8/mjsunit/d8/d8-worker-script.js
new file mode 100644
index 0000000000000000000000000000000000000000..7c5d595b2b99a991249b634777361949a658cd5b
--- /dev/null
+++ b/implementation-contributed/v8/mjsunit/d8/d8-worker-script.js
@@ -0,0 +1,39 @@
+// 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:
+//
+// * 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.
+
+// Verify that the Worker constrcutor by default treats its first argument
+// as the filename of a script load and run.
+
+// 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/implementation-contributed/v8/mjsunit/d8/d8-worker-script.txt b/implementation-contributed/v8/mjsunit/d8/d8-worker-script.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9254cea4f4bfa83fb62f983600c62b582a4b688e
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/d8/d8-worker-sharedarraybuffer.js b/implementation-contributed/v8/mjsunit/d8/d8-worker-sharedarraybuffer.js
index 0a15413ea301f16ad7f1c797519bb6b7dbf90be8..f166ca2eb1a338254664a9392bee3bca45abac23 100644
--- a/implementation-contributed/v8/mjsunit/d8/d8-worker-sharedarraybuffer.js
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/d8/d8-worker-spawn-worker.js b/implementation-contributed/v8/mjsunit/d8/d8-worker-spawn-worker.js
index a114d8587e0ebc7095565cfebb3634e7fdefbbe7..621ec253bcd73d59ac94e0d249e0d132d7d1822f 100644
--- a/implementation-contributed/v8/mjsunit/d8/d8-worker-spawn-worker.js
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/d8/d8-worker.js b/implementation-contributed/v8/mjsunit/d8/d8-worker.js
index a73d7b1706e87bd46fa11dcc0449659915049557..afc03f5c8b02c0d1c4503efe949db4f11c7cb9ed 100644
--- a/implementation-contributed/v8/mjsunit/d8/d8-worker.js
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/harmony/atomics-notify.js b/implementation-contributed/v8/mjsunit/harmony/atomics-notify.js
new file mode 100644
index 0000000000000000000000000000000000000000..cf18321786e3dca08f716ac5698c3aeb4d710b38
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/harmony/atomics-value-check.js b/implementation-contributed/v8/mjsunit/harmony/atomics-value-check.js
index b953863daf42784ef0418604e8bb11c69a839f38..053bc6dfc54b673a368a35ac90ad3555c66a3574 100644
--- a/implementation-contributed/v8/mjsunit/harmony/atomics-value-check.js
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/harmony/bigint/comparisons.js b/implementation-contributed/v8/mjsunit/harmony/bigint/comparisons.js
index 73eb24d6875e6916b23d10982b115bf1272b6083..513131555ac25b26e24b07200cca3e70106a7fa6 100644
--- a/implementation-contributed/v8/mjsunit/harmony/bigint/comparisons.js
+++ b/implementation-contributed/v8/mjsunit/harmony/bigint/comparisons.js
@@ -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/implementation-contributed/v8/mjsunit/harmony/futex.js b/implementation-contributed/v8/mjsunit/harmony/futex.js
index 394b4ddaf04df30e92fbda23cb918b56defae5f0..188832cf3c93defcd1b35cee2f980b9c7467cb81 100644
--- a/implementation-contributed/v8/mjsunit/harmony/futex.js
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/harmony/regexp-property-sequence.js b/implementation-contributed/v8/mjsunit/harmony/regexp-property-sequence.js
index 91a97844a374303fac1641f84946809e8d62e870..4d432980163c3bd0d0feb23ba47a0d18726a49d2 100644
--- a/implementation-contributed/v8/mjsunit/harmony/regexp-property-sequence.js
+++ b/implementation-contributed/v8/mjsunit/harmony/regexp-property-sequence.js
@@ -9,13 +9,13 @@ 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"));
+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"));
+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}"));
+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}"));
@@ -27,10 +27,34 @@ 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}"));
@@ -42,16 +66,23 @@ assertFalse(/\p{Emoji_ZWJ_Sequence}/u.test("\u{1F467}\u{200D}\u{1F468}"));
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 Austra"));
+ "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 Austra"));
+ "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 Austra"));
+ "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 Austra"));
+ "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/implementation-contributed/v8/mjsunit/harmony/to-number.js b/implementation-contributed/v8/mjsunit/harmony/to-number.js
index 6dc4db59a27c6ef968127b30be04f3047dc66194..a48a7d83f8c8befb57bc0a149bc4c2cb77b02381 100644
--- a/implementation-contributed/v8/mjsunit/harmony/to-number.js
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/harmony/well-formed-json-stringify-checked.js b/implementation-contributed/v8/mjsunit/harmony/well-formed-json-stringify-checked.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1179d385573f63680e07f1098696d97694030aa
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/harmony/well-formed-json-stringify-unchecked.js b/implementation-contributed/v8/mjsunit/harmony/well-formed-json-stringify-unchecked.js
new file mode 100644
index 0000000000000000000000000000000000000000..260d748ece51da296eadc4788f3d7c2883d592cb
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/ignition/regress-616064.js b/implementation-contributed/v8/mjsunit/ignition/regress-616064.js
index 805de41ac54fe2b4f37bb2a8680e538d226df5f8..f14679a422bd262254a67403de91ec45681e312a 100644
--- a/implementation-contributed/v8/mjsunit/ignition/regress-616064.js
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/json.js b/implementation-contributed/v8/mjsunit/json.js
index 102f777c743f6dc23d8fbb93f9c705c23e2f9480..04754577ffb15be6c5479904cf72c591dffcd2da 100644
--- a/implementation-contributed/v8/mjsunit/json.js
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/mjsunit.js b/implementation-contributed/v8/mjsunit/mjsunit.js
index a458e0cd10f738fa64fb1615d93a2b49813a72d8..59923a42475d7a2103d3d993a88ede36c6b438b4 100644
--- a/implementation-contributed/v8/mjsunit/mjsunit.js
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/regress/regress-4271.js b/implementation-contributed/v8/mjsunit/regress/regress-4271.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..5b724b01b646070a31ee64b64278d36b5a3ceb93 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-4271.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-4271.js
@@ -0,0 +1,24 @@
+// 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.
+
+if (this.Worker) {
+ // Throw rather than overflow internal field index
+ assertThrows(function() {
+ Worker.prototype.terminate();
+ });
+
+ assertThrows(function() {
+ Worker.prototype.getMessage();
+ });
+
+ assertThrows(function() {
+ Worker.prototype.postMessage({});
+ });
+
+ // Don't throw for real worker
+ var worker = new Worker('', {type: 'string'});
+ worker.getMessage();
+ worker.postMessage({});
+ worker.terminate();
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-4279.js b/implementation-contributed/v8/mjsunit/regress/regress-4279.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..ddc272793e641399cca0c79e3283f72a0a9d23e3 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-4279.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-4279.js
@@ -0,0 +1,11 @@
+// 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.
+
+if (this.Worker && this.quit) {
+ try {
+ new Function(new Worker("55"), {type: 'string'});
+ } catch(err) {}
+
+ quit();
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-821368.js b/implementation-contributed/v8/mjsunit/regress/regress-821368.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..8f8a01b3f73e816f05061ff1baa3c5e76c67b134 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-821368.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-821368.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.
+
+const worker = new Worker("onmessage = function(){}", {type: 'string'});
+const buffer = new ArrayBuffer();
+worker.postMessage(buffer, [buffer]);
+try {
+ worker.postMessage(buffer, [buffer]);
+} catch (e) {
+ if (e != "ArrayBuffer could not be transferred") {
+ throw e;
+ }
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-503578.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-503578.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..59c33da20e8134aad20a17db0dac0ec6d8639397 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-503578.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-503578.js
@@ -0,0 +1,14 @@
+// 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.
+
+if (this.Worker) {
+ function __f_0(byteLength) {
+ var __v_1 = new ArrayBuffer(byteLength);
+ var __v_5 = new Uint32Array(__v_1);
+ return __v_5;
+ }
+ var __v_6 = new Worker('onmessage = function() {}', {type: 'string'});
+ var __v_3 = __f_0(16);
+ __v_6.postMessage(__v_3);
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-503698.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-503698.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..c817bede29ef7c0ee661c080ae248d6f0efdc77a 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-503698.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-503698.js
@@ -0,0 +1,9 @@
+// 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: --invoke-weak-callbacks
+
+if (this.Worker) {
+ var __v_6 = new Worker('', {type: 'string'});
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-503968.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-503968.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0552163144c6c4104de4fad2b05327fa9abbd7ef 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-503968.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-503968.js
@@ -0,0 +1,13 @@
+// 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.
+
+if (this.Worker) {
+ function __f_0() { this.s = new Object(); }
+ function __f_1() {
+ this.l = [new __f_0, new __f_0];
+ }
+ __v_6 = new __f_1;
+ var __v_9 = new Worker('', {type: 'string'});
+ __v_9.postMessage(__v_6);
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-503991.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-503991.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..7b96e92677d1e26fe940f4f3d9069654acf2c56c 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-503991.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-503991.js
@@ -0,0 +1,9 @@
+// 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.
+
+if (this.Worker) {
+ __v_3 = "";
+ var __v_6 = new Worker('', {type: 'string'});
+ __v_6.postMessage(__v_3);
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-504136.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-504136.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..25b11e0fec391152101c9851d8a2c0511dc6b295 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-504136.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-504136.js
@@ -0,0 +1,9 @@
+// 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.
+
+if (this.Worker) {
+ var __v_10 = new Worker('', {type: 'string'});
+ __v_10.terminate();
+ __v_10.getMessage();
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-504727.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-504727.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..a295a1bd35b005c1d89501ac6e57a5045798e082 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-504727.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-504727.js
@@ -0,0 +1,9 @@
+// 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: --no-test
+
+if (this.Worker) {
+ var __v_2 = new Worker('', {type: 'string'});
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-504729.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-504729.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..8b1f8b08995d101bf03c473d6944cf816226cb51 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-504729.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-504729.js
@@ -0,0 +1,9 @@
+// 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.
+
+if (this.Worker) {
+ Function.prototype.toString = "foo";
+ function __f_7() {}
+ assertThrows(function() { var __v_5 = new Worker(__f_7.toString(), {type: 'string'}) });
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-505778.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-505778.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..3d87ba6982b91a4c466d2c699121fbe972ef47bd 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-505778.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-505778.js
@@ -0,0 +1,8 @@
+// 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.
+
+if (this.Worker) {
+ var __v_7 = new Worker('onmessage = function() {}', {type: 'string'});
+ __v_7.postMessage("");
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-506549.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-506549.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..219fd10cb7b214594a04f65a562c6701e795890c 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-506549.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-506549.js
@@ -0,0 +1,10 @@
+// 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.
+
+if (this.Worker) {
+ var __v_5 = {};
+ __v_5.__defineGetter__('byteLength', function() {foo();});
+ var __v_8 = new Worker('onmessage = function() {};', {type: 'string'});
+ assertThrows(function() { __v_8.postMessage(__v_5); });
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-511880.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-511880.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..5dceb2a733970478e3ed016816cfb02801f141b8 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-511880.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-511880.js
@@ -0,0 +1,13 @@
+// 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.
+
+if (this.Worker) {
+ var __v_8 =
+ `var __v_9 = new Worker('postMessage(42)', {type: 'string'});
+ onmessage = function(parentMsg) {
+ __v_9.postMessage(parentMsg);
+ };`;
+ var __v_9 = new Worker(__v_8, {type: 'string'});
+ __v_9.postMessage(9);
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-514081.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-514081.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..3d99b4586bad0efb431fb91a0b782e71e3c2c810 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-514081.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-514081.js
@@ -0,0 +1,18 @@
+// 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.
+
+if (this.Worker) {
+ var __v_7 = new Worker('onmessage = function() {};', {type: 'string'});
+ var e;
+ var ab = new ArrayBuffer(2 * 1000 * 1000);
+ try {
+ __v_7.postMessage(ab);
+ threw = false;
+ } catch (e) {
+ // postMessage failed, should be a DataCloneError message.
+ assertContains('cloned', e.message);
+ threw = true;
+ }
+ assertTrue(threw, 'Should throw when trying to serialize large message.');
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-518747.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-518747.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..2a4058d401fd0e3116739235af78429eae93c142 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-518747.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-518747.js
@@ -0,0 +1,9 @@
+// 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.
+
+if (this.Worker) {
+ Worker.prototype = 12;
+ var __v_6 = new Worker('', {type: 'string'});
+ __v_6.postMessage([]);
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-522496.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-522496.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..4dea5a89ac59bc5dd3d247084fd3ca22f0c56009 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-522496.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-522496.js
@@ -0,0 +1,9 @@
+// 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.
+
+if (this.Worker) {
+ var worker = new Worker("onmessage = function(){}", {type: 'string'});
+ var buf = new ArrayBuffer();
+ worker.postMessage(buf, [buf]);
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-687063.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-687063.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c579331fbc65ef3e7affa68fa7c311bd3689d0f
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/regress/regress-crbug-722871.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-722871.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..e71f083be6b28c7b9693dca6d2bfbea59376c2df 100644
--- a/implementation-contributed/v8/mjsunit/regress/regress-crbug-722871.js
+++ b/implementation-contributed/v8/mjsunit/regress/regress-crbug-722871.js
@@ -0,0 +1,113 @@
+// 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.
+let sab = new SharedArrayBuffer(10 * 4);
+let memory = new Int32Array(sab);
+let workers = [];
+let runningWorkers = 0;
+
+function startWorker(script) {
+ let worker = new Worker(script, {type: 'string'});
+ worker.done = false;
+ worker.idx = workers.length;
+ workers.push(worker);
+ worker.postMessage(memory);
+ ++runningWorkers;
+};
+
+let shared = `
+ function wait(memory, index, waitCondition, wakeCondition) {
+ while (memory[index] == waitCondition) {
+ var result = Atomics.wait(memory, index, waitCondition);
+ switch (result) {
+ case 'not-equal':
+ case 'ok':
+ break;
+ default:
+ postMessage('Error: bad result from wait: ' + result);
+ break;
+ }
+ var value = memory[index];
+ if (value != wakeCondition) {
+ postMessage(
+ 'Error: wait returned not-equal but the memory has a bad value: ' +
+ value);
+ }
+ }
+ var value = memory[index];
+ if (value != wakeCondition) {
+ postMessage(
+ 'Error: done waiting but the memory has a bad value: ' + value);
+ }
+ }
+
+ function wake(memory, index) {
+ var result = Atomics.wake(memory, index, 1);
+ if (result != 0 && result != 1) {
+ postMessage('Error: bad result from wake: ' + result);
+ }
+ }
+`;
+
+let worker1 = startWorker(shared + `
+ onmessage = function(msg) {
+ let memory = msg;
+ const didStartIdx = 0;
+ const shouldGoIdx = 1;
+ const didEndIdx = 2;
+
+ postMessage("started");
+ postMessage("memory: " + memory);
+ wait(memory, didStartIdx, 0, 1);
+ memory[shouldGoIdx] = 1;
+ wake(memory, shouldGoIdx);
+ wait(memory, didEndIdx, 0, 1);
+ postMessage("memory: " + memory);
+ postMessage("done");
+ };
+`);
+
+let worker2 = startWorker(shared + `
+ onmessage = function(msg) {
+ let memory = msg;
+ const didStartIdx = 0;
+ const shouldGoIdx = 1;
+ const didEndIdx = 2;
+
+ postMessage("started");
+ postMessage("memory: " + memory);
+ Atomics.store(memory, didStartIdx, 1);
+ wake(memory, didStartIdx);
+ wait(memory, shouldGoIdx, 0, 1);
+ Atomics.store(memory, didEndIdx, 1);
+ wake(memory, didEndIdx, 1);
+ postMessage("memory: " + memory);
+ postMessage("done");
+ };
+`);
+
+let running = true;
+while (running) {
+ for (let worker of workers) {
+ if (worker.done) continue;
+
+ let msg = worker.getMessage();
+ if (msg) {
+ switch (msg) {
+ case "done":
+ if (worker.done === false) {
+ print("worker #" + worker.idx + " done.");
+ worker.done = true;
+ if (--runningWorkers === 0) {
+ running = false;
+ }
+ }
+ break;
+
+ default:
+ print("msg from worker #" + worker.idx + ": " + msg);
+ break;
+ }
+ }
+ }
+}
diff --git a/implementation-contributed/v8/mjsunit/regress/regress-crbug-887891.js b/implementation-contributed/v8/mjsunit/regress/regress-crbug-887891.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e72ab263a26a717756fad1f7823577e6a2dbeeb
--- /dev/null
+++ b/implementation-contributed/v8/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/implementation-contributed/v8/mjsunit/regress/wasm/regress-801850.js b/implementation-contributed/v8/mjsunit/regress/wasm/regress-801850.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..b56af694a99a14449efd557feac8f8327909bb79 100644
--- a/implementation-contributed/v8/mjsunit/regress/wasm/regress-801850.js
+++ b/implementation-contributed/v8/mjsunit/regress/wasm/regress-801850.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.
+
+load('test/mjsunit/wasm/wasm-constants.js');
+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() {};', {type: 'string'});
+worker.postMessage(module)
diff --git a/implementation-contributed/v8/mjsunit/regress/wasm/regress-803427.js b/implementation-contributed/v8/mjsunit/regress/wasm/regress-803427.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..d3ab31b4c95ac601bc8e79d58cbe4260dcf105d0 100644
--- a/implementation-contributed/v8/mjsunit/regress/wasm/regress-803427.js
+++ b/implementation-contributed/v8/mjsunit/regress/wasm/regress-803427.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: --wasm-lazy-compilation
+
+load('test/mjsunit/wasm/wasm-constants.js');
+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() {};', {type: 'string'});
+worker.postMessage(module)
diff --git a/implementation-contributed/v8/mjsunit/regress/wasm/regress-8059.js b/implementation-contributed/v8/mjsunit/regress/wasm/regress-8059.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..c30ed152f8a0e8ea1102bd94faa88f91e2726b75 100644
--- a/implementation-contributed/v8/mjsunit/regress/wasm/regress-8059.js
+++ b/implementation-contributed/v8/mjsunit/regress/wasm/regress-8059.js
@@ -0,0 +1,42 @@
+// 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: --no-wasm-disable-structured-cloning
+
+load("test/mjsunit/wasm/wasm-constants.js");
+load("test/mjsunit/wasm/wasm-module-builder.js");
+
+(function TestPostModule() {
+ let builder = new WasmModuleBuilder();
+ builder.addFunction("add", kSig_i_ii)
+ .addBody([kExprGetLocal, 0, kExprGetLocal, 1, kExprI32Add])
+ .exportFunc();
+
+ let module = builder.toModule();
+
+ let workerScript = `
+ onmessage = function(module) {
+ try {
+ let instance = new WebAssembly.Instance(module);
+ let result = instance.exports.add(40, 2);
+ postMessage(result);
+ } catch(e) {
+ postMessage('ERROR: ' + e);
+ }
+ }
+ `;
+
+ let realm = Realm.create();
+ Realm.shared = { m:module, s:workerScript };
+
+ let realmScript = `
+ let worker = new Worker(Realm.shared.s, {type: 'string'});
+ worker.postMessage(Realm.shared.m);
+ let message = worker.getMessage();
+ worker.terminate();
+ message;
+ `;
+ let message = Realm.eval(realm, realmScript);
+ assertEquals(42, message);
+})();
diff --git a/implementation-contributed/v8/mjsunit/regress/wasm/regress-808012.js b/implementation-contributed/v8/mjsunit/regress/wasm/regress-808012.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..ae613ceb54973f642e1b16d54221b1c155c24187 100644
--- a/implementation-contributed/v8/mjsunit/regress/wasm/regress-808012.js
+++ b/implementation-contributed/v8/mjsunit/regress/wasm/regress-808012.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: --wasm-lazy-compilation
+
+load('test/mjsunit/wasm/wasm-constants.js');
+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() {};', {type: 'string'});
+worker.postMessage(module);
diff --git a/implementation-contributed/v8/mjsunit/regress/wasm/regress-808848.js b/implementation-contributed/v8/mjsunit/regress/wasm/regress-808848.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..bcf8469a1474f87c8a0eb903881491e49a78c785 100644
--- a/implementation-contributed/v8/mjsunit/regress/wasm/regress-808848.js
+++ b/implementation-contributed/v8/mjsunit/regress/wasm/regress-808848.js
@@ -0,0 +1,67 @@
+// 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
+
+load('test/mjsunit/wasm/wasm-constants.js');
+load('test/mjsunit/wasm/wasm-module-builder.js');
+
+// The number of locals must be greater than the constant defined here:
+// https://cs.chromium.org/chromium/src/v8/src/compiler/x64/code-generator-x64.cc?l=3146
+const kNumLocals = 128;
+
+function varuint32(val) {
+ let bytes = [];
+ for (let i = 0; i < 4; ++i) {
+ bytes.push(0x80 | ((val >> (7 * i)) & 0x7f));
+ }
+ bytes.push((val >> (7 * 4)) & 0x7f);
+ return bytes;
+}
+
+// Generate a function that calls the "get" import `kNumLocals` times, and
+// stores each result in a local, then calls the "call" import `kNumLocals`
+// times with the stored local values.
+//
+// The intention is to create a function that has a large stack frame.
+let body = [];
+
+for (let i = 0; i < kNumLocals; ++i) {
+ body.push(kExprCallFunction, 0, kExprSetLocal, ...varuint32(i));
+}
+
+for (let i = 0; i < kNumLocals; ++i) {
+ body.push(kExprGetLocal, ...varuint32(i), kExprCallFunction, 1);
+}
+
+let builder = new WasmModuleBuilder();
+builder.addImport('mod', 'get', kSig_i_v);
+builder.addImport('mod', 'call', kSig_v_i);
+builder.
+ addFunction('main', kSig_v_v).
+ addLocals({i32_count: kNumLocals}).
+ addBody(body).
+ exportAs('main');
+let m1_bytes = builder.toBuffer();
+let m1 = new WebAssembly.Module(m1_bytes);
+
+// Serialize the module and postMessage it to another thread.
+let serialized_m1 = %SerializeWasmModule(m1);
+
+let worker_onmessage = function(msg) {
+ let {serialized_m1, m1_bytes} = msg;
+
+ let m1_clone = %DeserializeWasmModule(serialized_m1, m1_bytes);
+ let imports = {mod: {get: () => 3, call: () => {}}};
+ let i2 = new WebAssembly.Instance(m1_clone, imports);
+ i2.exports.main();
+ postMessage('done');
+}
+let workerScript = "onmessage = " + worker_onmessage.toString();
+
+let worker = new Worker(workerScript, {type: 'string'});
+worker.postMessage({serialized_m1, m1_bytes});
+
+// Wait for worker to finish.
+print(worker.getMessage());
diff --git a/implementation-contributed/v8/mjsunit/samevalue.js b/implementation-contributed/v8/mjsunit/samevalue.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..1e5384d73d5fa642e4d525b8a1367485f107bb4f 100644
--- a/implementation-contributed/v8/mjsunit/samevalue.js
+++ b/implementation-contributed/v8/mjsunit/samevalue.js
@@ -0,0 +1,123 @@
+// Copyright 2010 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.
+
+
+// Flags: --expose-natives-as natives --allow-natives-syntax
+// Test the SameValue and SameValueZero internal methods.
+
+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;
+
+// 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) {
+ var result = sameValue(a, b);
+ assertTrue(result === sameValueZero(a, b));
+ return result;
+}
+
+// Calls SameValue and SameValueZero and checks that their results don't match.
+function sameValueZeroOnly(a, b) {
+ var result = sameValueZero(a, b);
+ assertTrue(result && !sameValue(a, b));
+ return result;
+}
+
+assertTrue(sameValueBoth(0, 0));
+assertTrue(sameValueBoth(+0, +0));
+assertTrue(sameValueBoth(-0, -0));
+assertTrue(sameValueBoth(1, 1));
+assertTrue(sameValueBoth(2, 2));
+assertTrue(sameValueBoth(-1, -1));
+assertTrue(sameValueBoth(0.5, 0.5));
+assertTrue(sameValueBoth(true, true));
+assertTrue(sameValueBoth(false, false));
+assertTrue(sameValueBoth(NaN, NaN));
+assertTrue(sameValueBoth(null, null));
+assertTrue(sameValueBoth("foo", "foo"));
+assertTrue(sameValueBoth(obj1, obj1));
+// Undefined values.
+assertTrue(sameValueBoth());
+assertTrue(sameValueBoth(undefined, undefined));
+
+assertFalse(sameValueBoth(0,1));
+assertFalse(sameValueBoth("foo", "bar"));
+assertFalse(sameValueBoth(obj1, obj2));
+assertFalse(sameValueBoth(true, false));
+
+assertFalse(sameValueBoth(obj1, true));
+assertFalse(sameValueBoth(obj1, "foo"));
+assertFalse(sameValueBoth(obj1, 1));
+assertFalse(sameValueBoth(obj1, undefined));
+assertFalse(sameValueBoth(obj1, NaN));
+
+assertFalse(sameValueBoth(undefined, true));
+assertFalse(sameValueBoth(undefined, "foo"));
+assertFalse(sameValueBoth(undefined, 1));
+assertFalse(sameValueBoth(undefined, obj1));
+assertFalse(sameValueBoth(undefined, NaN));
+
+assertFalse(sameValueBoth(NaN, true));
+assertFalse(sameValueBoth(NaN, "foo"));
+assertFalse(sameValueBoth(NaN, 1));
+assertFalse(sameValueBoth(NaN, obj1));
+assertFalse(sameValueBoth(NaN, undefined));
+
+assertFalse(sameValueBoth("foo", true));
+assertFalse(sameValueBoth("foo", 1));
+assertFalse(sameValueBoth("foo", obj1));
+assertFalse(sameValueBoth("foo", undefined));
+assertFalse(sameValueBoth("foo", NaN));
+
+assertFalse(sameValueBoth(true, 1));
+assertFalse(sameValueBoth(true, obj1));
+assertFalse(sameValueBoth(true, undefined));
+assertFalse(sameValueBoth(true, NaN));
+assertFalse(sameValueBoth(true, "foo"));
+
+assertFalse(sameValueBoth(1, true));
+assertFalse(sameValueBoth(1, obj1));
+assertFalse(sameValueBoth(1, undefined));
+assertFalse(sameValueBoth(1, NaN));
+assertFalse(sameValueBoth(1, "foo"));
+
+// Special string cases.
+assertFalse(sameValueBoth("1", 1));
+assertFalse(sameValueBoth("true", true));
+assertFalse(sameValueBoth("false", false));
+assertFalse(sameValueBoth("undefined", undefined));
+assertFalse(sameValueBoth("NaN", NaN));
+
+// SameValue considers -0 and +0 to be different; SameValueZero considers
+// -0 and +0 to be the same.
+assertTrue(sameValueZeroOnly(+0, -0));
+assertTrue(sameValueZeroOnly(-0, +0));
diff --git a/implementation-contributed/v8/mjsunit/test-async.js b/implementation-contributed/v8/mjsunit/test-async.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..d4fee9bfb9587ac751a21b6a5674c3577259b29a 100644
--- a/implementation-contributed/v8/mjsunit/test-async.js
+++ b/implementation-contributed/v8/mjsunit/test-async.js
@@ -0,0 +1,117 @@
+// 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
+
+// Used for async tests. See definition below for more documentation.
+var testAsync;
+
+(function () { // Scope for utility functions.
+ /**
+ * This is to be used through the testAsync helper function defined
+ * below.
+ *
+ * This requires the --allow-natives-syntax flag to allow calling
+ * runtime functions.
+ *
+ * There must be at least one assertion in an async test. A test
+ * with no assertions will fail.
+ *
+ * @example
+ * testAsync(assert => {
+ * assert.plan(1) // There should be one assertion in this test.
+ * Promise.resolve(1)
+ * .then(val => assert.equals(1, val),
+ * assert.unreachable);
+ * })
+ */
+ class AsyncAssertion {
+ constructor(test, name) {
+ this.expectedAsserts_ = -1;
+ this.actualAsserts_ = 0;
+ this.test_ = test;
+ this.name_ = name || '';
+ }
+
+ /**
+ * Sets the number of expected asserts in the test. The test fails
+ * if the number of asserts computed after running the test is not
+ * equal to this specified value.
+ * @param {number} expectedAsserts
+ */
+ plan(expectedAsserts) {
+ this.expectedAsserts_ = expectedAsserts;
+ }
+
+ fail(expectedText, found) {
+ let message = formatFailureText(expectedText, found);
+ message += "\nin test:" + this.name_
+ message += "\n" + Function.prototype.toString.apply(this.test_);
+ %AbortJS(message);
+ }
+
+ equals(expected, found, name_opt) {
+ this.actualAsserts_++;
+ if (!deepEquals(expected, found)) {
+ this.fail(prettyPrinted(expected), found, name_opt);
+ }
+ }
+
+ unreachable() {
+ let message = "Failure: unreachable in test: " + this.name_;
+ message += "\n" + Function.prototype.toString.apply(this.test_);
+ %AbortJS(message);
+ }
+
+ unexpectedRejection(details) {
+ return (error) => {
+ let message =
+ "Failure: unexpected Promise rejection in test: " + this.name_;
+ if (details) message += "\n @" + details;
+ if (error instanceof Error) {
+ message += "\n" + String(error.stack);
+ } else {
+ message += "\n" + String(error);
+ }
+ message += "\n\n" + Function.prototype.toString.apply(this.test_);
+ %AbortJS(message);
+ };
+ }
+
+ drainMicrotasks() {
+ %RunMicrotasks();
+ }
+
+ done_() {
+ if (this.expectedAsserts_ === -1) {
+ let message = "Please call t.plan(count) to initialize test harness " +
+ "with correct assert count (Note: count > 0)";
+ %AbortJS(message);
+ }
+
+ if (this.expectedAsserts_ !== this.actualAsserts_) {
+ let message = "Expected asserts: " + this.expectedAsserts_;
+ message += ", Actual asserts: " + this.actualAsserts_;
+ message += "\nin test: " + this.name_;
+ message += "\n" + Function.prototype.toString.apply(this.test_);
+ %AbortJS(message);
+ }
+ }
+ }
+
+ /** This is used to test async functions and promises.
+ * @param {testCallback} test - test function
+ * @param {string} [name] - optional name of the test
+ *
+ *
+ * @callback testCallback
+ * @param {AsyncAssertion} assert
+ */
+ testAsync = function(test, name) {
+ let assert = new AsyncAssertion(test, name);
+ test(assert);
+ %RunMicrotasks();
+ assert.done_();
+ }
+})();
diff --git a/implementation-contributed/v8/test262/harness-agent.js b/implementation-contributed/v8/test262/harness-agent.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..254df2469ff0a5f1b961575a17dde2352dd1f7d8 100644
--- a/implementation-contributed/v8/test262/harness-agent.js
+++ b/implementation-contributed/v8/test262/harness-agent.js
@@ -0,0 +1,118 @@
+// 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.
+
+$262.agent = (function () {
+
+var workers = [];
+var i32a = null;
+var pendingReports = [];
+
+// Agents call Atomics.wait on this location to sleep.
+var SLEEP_LOC = 0;
+// 1 if the started worker is ready, 0 otherwise.
+var START_LOC = 1;
+// The number of workers that have received the broadcast.
+var BROADCAST_LOC = 2;
+// Each worker has a count of outstanding reports; worker N uses memory
+// location [WORKER_REPORT_LOC + N].
+var WORKER_REPORT_LOC = 3;
+
+function workerScript(script) {
+ return `
+ var index;
+ var i32a = null;
+ var broadcasts = [];
+ var pendingReceiver = null;
+
+ function handleBroadcast() {
+ if (pendingReceiver && broadcasts.length > 0) {
+ pendingReceiver.apply(null, broadcasts.shift());
+ pendingReceiver = null;
+ }
+ };
+
+ var onmessage = function(msg) {
+ switch (msg.kind) {
+ case 'start':
+ i32a = msg.i32a;
+ index = msg.index;
+ (0, eval)(\`${script}\`);
+ break;
+
+ case 'broadcast':
+ Atomics.add(i32a, ${BROADCAST_LOC}, 1);
+ broadcasts.push([msg.sab, msg.id]);
+ handleBroadcast();
+ break;
+ }
+ };
+
+ var $262 = {
+ agent: {
+ receiveBroadcast(receiver) {
+ pendingReceiver = receiver;
+ handleBroadcast();
+ },
+
+ report(msg) {
+ postMessage(String(msg));
+ Atomics.add(i32a, ${WORKER_REPORT_LOC} + index, 1);
+ },
+
+ sleep(s) { Atomics.wait(i32a, ${SLEEP_LOC}, 0, s); },
+
+ leaving() {},
+
+ monotonicNow() {
+ return performance.now();
+ }
+ }
+ };`;
+}
+
+var agent = {
+ start(script) {
+ if (i32a === null) {
+ i32a = new Int32Array(new SharedArrayBuffer(256));
+ }
+ var w = new Worker(workerScript(script), {type: 'string'});
+ w.index = workers.length;
+ w.postMessage({kind: 'start', i32a: i32a, index: w.index});
+ workers.push(w);
+ },
+
+ broadcast(sab, id) {
+ if (!(sab instanceof SharedArrayBuffer)) {
+ throw new TypeError('sab must be a SharedArrayBuffer.');
+ }
+
+ Atomics.store(i32a, BROADCAST_LOC, 0);
+
+ for (var w of workers) {
+ w.postMessage({kind: 'broadcast', sab: sab, id: id|0});
+ }
+
+ while (Atomics.load(i32a, BROADCAST_LOC) != workers.length) {}
+ },
+
+ getReport() {
+ for (var w of workers) {
+ while (Atomics.load(i32a, WORKER_REPORT_LOC + w.index) > 0) {
+ pendingReports.push(w.getMessage());
+ Atomics.sub(i32a, WORKER_REPORT_LOC + w.index, 1);
+ }
+ }
+
+ return pendingReports.shift() || null;
+ },
+
+ sleep(s) { Atomics.wait(i32a, SLEEP_LOC, 0, s); },
+
+ monotonicNow() {
+ return performance.now();
+ }
+};
+return agent;
+
+})();