summaryrefslogtreecommitdiffstats
path: root/js/src/tests/non262/extensions/clone-transferables.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/tests/non262/extensions/clone-transferables.js')
-rw-r--r--js/src/tests/non262/extensions/clone-transferables.js129
1 files changed, 129 insertions, 0 deletions
diff --git a/js/src/tests/non262/extensions/clone-transferables.js b/js/src/tests/non262/extensions/clone-transferables.js
new file mode 100644
index 0000000000..6b3ff99079
--- /dev/null
+++ b/js/src/tests/non262/extensions/clone-transferables.js
@@ -0,0 +1,129 @@
+// |reftest| skip-if(!xulRuntime.shell)
+// Any copyright is dedicated to the Public Domain.
+// http://creativecommons.org/licenses/publicdomain/
+
+function* buffer_options() {
+ for (var scope of ["SameProcess",
+ "DifferentProcess",
+ "DifferentProcessForIndexedDB"])
+ {
+ for (var size of [0, 8, 16, 200, 1000, 4096, 8192, 65536]) {
+ yield { scope, size };
+ }
+ }
+}
+
+
+function test() {
+ for (var {scope, size} of buffer_options()) {
+ var old = new ArrayBuffer(size);
+ var copy = deserialize(serialize([old, old], [old], { scope }), { scope });
+ assertEq(old.byteLength, 0);
+ assertEq(copy[0] === copy[1], true);
+ copy = copy[0];
+ assertEq(copy.byteLength, size);
+
+ var constructors = [ Int8Array,
+ Uint8Array,
+ Int16Array,
+ Uint16Array,
+ Int32Array,
+ Uint32Array,
+ Float32Array,
+ Float64Array,
+ Uint8ClampedArray,
+ DataView ];
+
+ for (var ctor of constructors) {
+ var dataview = (ctor === DataView);
+
+ var buf = new ArrayBuffer(size);
+ var old_arr = new ctor(buf);
+ assertEq(buf.byteLength, size);
+ assertEq(buf, old_arr.buffer);
+ if (!dataview)
+ assertEq(old_arr.length, size / old_arr.BYTES_PER_ELEMENT);
+
+ var copy_arr = deserialize(serialize(old_arr, [ buf ], { scope }), { scope });
+ assertEq(buf.byteLength, 0,
+ "donor array buffer should be detached");
+ if (!dataview) {
+ assertEq(old_arr.length, 0,
+ "donor typed array should be detached");
+ }
+ assertEq(copy_arr.buffer.byteLength == size, true);
+ if (!dataview)
+ assertEq(copy_arr.length, size / old_arr.BYTES_PER_ELEMENT);
+
+ buf = null;
+ old_arr = null;
+ gc(); // Tickle the ArrayBuffer -> view management
+ }
+
+ for (var ctor of constructors) {
+ var dataview = (ctor === DataView);
+
+ var buf = new ArrayBuffer(size);
+ var old_arr = new ctor(buf);
+ var dv = new DataView(buf); // Second view
+ var copy_arr = deserialize(serialize(old_arr, [ buf ], { scope }), { scope });
+ assertEq(buf.byteLength, 0,
+ "donor array buffer should be detached");
+ if (!dataview) {
+ assertEq(old_arr.byteLength, 0,
+ "donor typed array should be detached");
+ assertEq(old_arr.length, 0,
+ "donor typed array should be detached");
+ }
+
+ buf = null;
+ old_arr = null;
+ gc(); // Tickle the ArrayBuffer -> view management
+ }
+
+ // Mutate the buffer during the clone operation. The modifications should be visible.
+ if (size >= 4) {
+ old = new ArrayBuffer(size);
+ var view = new Int32Array(old);
+ view[0] = 1;
+ var mutator = { get foo() { view[0] = 2; } };
+ var copy = deserialize(serialize([ old, mutator ], [ old ], { scope }), { scope });
+ var viewCopy = new Int32Array(copy[0]);
+ assertEq(view.length, 0); // Underlying buffer now detached.
+ assertEq(viewCopy[0], 2);
+ }
+
+ // Detach the buffer during the clone operation. Should throw an
+ // exception.
+ if (size >= 4) {
+ const b1 = new ArrayBuffer(size);
+ let mutator = {
+ get foo() {
+ serialize(b1, [b1], { scope });
+ }
+ };
+
+ assertThrowsInstanceOf(
+ () => serialize([ b1, mutator ], [b1]),
+ TypeError,
+ "detaching (due to Transferring) while serializing should throw"
+ );
+
+ const b2 = new ArrayBuffer(size);
+ mutator = {
+ get foo() {
+ detachArrayBuffer(b2);
+ }
+ };
+
+ assertThrowsInstanceOf(
+ () => serialize([ b2, mutator ], [b2]),
+ TypeError,
+ "detaching (due to detachArrayBuffer) while serializing should throw"
+ );
+ }
+ }
+}
+
+test();
+reportCompare(0, 0, 'ok');