The Tor Browser: comparison js/src/tests/js1_8_5/extensions/clone-object.js

comparison: js/src/tests/js1_8_5/extensions/clone-object.js

js/src/tests/js1_8_5/extensions/clone-object.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:9ca8f2e77afa
+// |reftest| skip-if(!xulRuntime.shell)
+// -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// Any copyright is dedicated to the Public Domain.
+// http://creativecommons.org/licenses/publicdomain/
+// Assert that cloning b does the right thing as far as we can tell.
+// Caveat: getters in b must produce the same value each time they're
+// called. We may call them several times.
+//
+// If desc is provided, then the very first thing we do to b is clone it.
+// (The self-modifying object test counts on this.)
+//
+function check(b, desc) {
+function classOf(obj) {
+return Object.prototype.toString.call(obj);
+}
+function ownProperties(obj) {
+return Object.getOwnPropertyNames(obj).
+map(function (p) { return [p, Object.getOwnPropertyDescriptor(obj, p)]; });
+}
+function isCloneable(pair) {
+return typeof pair[0] === 'string' && pair[1].enumerable;
+}
+function notIndex(p) {
+var u = p >>> 0;
+return !("" + u == p && u != 0xffffffff);
+}
+function assertIsCloneOf(a, b, path) {
+assertEq(a === b, false);
+var ca = classOf(a);
+assertEq(ca, classOf(b), path);
+assertEq(Object.getPrototypeOf(a),
+ca == "[object Object]" ? Object.prototype : Array.prototype,
+path);
+// 'b', the original object, may have non-enumerable or XMLName
+// properties; ignore them.  'a', the clone, should not have any
+// non-enumerable properties (except .length, if it's an Array) or
+// XMLName properties.
+var pb = ownProperties(b).filter(isCloneable);
+var pa = ownProperties(a);
+for (var i = 0; i < pa.length; i++) {
+assertEq(typeof pa[i][0], "string", "clone should not have E4X properties " + path);
+if (!pa[i][1].enumerable) {
+if (Array.isArray(a) && pa[i][0] == "length") {
+// remove it so that the comparisons below will work
+pa.splice(i, 1);
+i--;
+} else {
+throw new Error("non-enumerable clone property " + uneval(pa[i][0]) + " " + path);
+}
+}
+}
+// Check that, apart from properties whose names are array indexes,
+// the enumerable properties appear in the same order.
+var aNames = pa.map(function (pair) { return pair[1]; }).filter(notIndex);
+var bNames = pa.map(function (pair) { return pair[1]; }).filter(notIndex);
+assertEq(aNames.join(","), bNames.join(","), path);
+// Check that the lists are the same when including array indexes.
+function byName(a, b) { a = a[0]; b = b[0]; return a < b ? -1 : a === b ? 0 : 1; }
+pa.sort(byName);
+pb.sort(byName);
+assertEq(pa.length, pb.length, "should see the same number of properties " + path);
+for (var i = 0; i < pa.length; i++) {
+var aName = pa[i][0];
+var bName = pb[i][0];
+assertEq(aName, bName, path);
+var path2 = path + "." + aName;
+var da = pa[i][1];
+var db = pb[i][1];
+assertEq(da.configurable, true, path2);
+assertEq(da.writable, true, path2);
+assertEq("value" in da, true, path2);
+var va = da.value;
+var vb = b[pb[i][0]];
+if (typeof va === "object" && va !== null)
+queue.push([va, vb, path2]);
+else
+assertEq(va, vb, path2);
+}
+}
+var banner = "while testing clone of " + (desc || uneval(b));
+var a = deserialize(serialize(b));
+var queue = [[a, b, banner]];
+while (queue.length) {
+var triple = queue.shift();
+assertIsCloneOf(triple[0], triple[1], triple[2]);
+}
+return a; // for further testing
+}
+function test() {
+check({});
+check([]);
+check({x: 0});
+check({x: 0.7, p: "forty-two", y: null, z: undefined});
+check(Array.prototype);
+check(Object.prototype);
+// before and after
+var b, a;
+// Slow array.
+b = [, 1, 2, 3];
+b.expando = true;
+b[5] = 5;
+b[0] = 0;
+b[4] = 4;
+delete b[2];
+check(b);
+// Check cloning properties other than basic data properties. (check()
+// asserts that the properties of the clone are configurable, writable,
+// enumerable data properties.)
+b = {};
+Object.defineProperties(b, {
+x: {enumerable: true, get: function () { return 12479; }},
+y: {enumerable: true, configurable: true, writable: false, value: 0},
+z: {enumerable: true, configurable: false, writable: true, value: 0},
+hidden: {enumerable:false, value: 1334}});
+check(b);
+// Check corner cases involving property names.
+b = {"-1": -1,
+0xffffffff: null,
+0x100000000: null,
+"": 0,
+"\xff\x7f\u7fff\uffff\ufeff\ufffe": 1, // random unicode id
+"\ud800 \udbff \udc00 \udfff": 2}; // busted surrogate pairs
+check(b);
+b = [];
+b[-1] = -1;
+b[0xffffffff] = null;
+b[0x100000000] = null;
+b[""] = 0;
+b["\xff\x7f\u7fff\uffff\ufeff\ufffe"] = 1;
+b["\ud800 \udbff \udc00 \udfff"] = 2;
+check(b);
+// An array's .length property is not enumerable, so it is not cloned.
+b = Array(5);
+assertEq(b.length, 5);
+a = check(b);
+assertEq(a.length, 0);
+b[1] = "ok";
+a = check(b);
+assertEq(a.length, 2);
+// Check that prototypes are not cloned, per spec.
+b = Object.create({x:1});
+b.y = 2;
+b.z = 3;
+check(b);
+// Check that cloning does not separate merge points in the tree.
+var same = {};
+b = {one: same, two: same};
+a = check(b);
+assertEq(a.one === a.two, true);
+b = [same, same];
+a = check(b);
+assertEq(a[0] === a[1], true);
+// Try cloning a deep object. Don't fail with "too much recursion".
+b = {};
+var current = b;
+for (var i = 0; i < 10000; i++) {
+var next = {};
+current['x' + i] = next;
+current = next;
+}
+check(b, "deepObject");  // takes 2 seconds :-\
+/*
+XXX TODO spin this out into its own test
+// This fails quickly with an OOM error. An exception would be nicer.
+function Infinitree() {
+return { get left() { return new Infinitree; },
+get right() { return new Infinitree; }};
+}
+var threw = false;
+try {
+serialize(new Infinitree);
+} catch (exc) {
+threw = true;
+}
+assertEq(threw, true);
+*/
+// Clone an array with holes.
+check([0, 1, 2, , 4, 5, 6]);
+// Array holes should not take up space.
+b = [];
+b[255] = 1;
+check(b);
+assertEq(serialize(b).clonebuffer.length < 255, true);
+// Self-modifying object.
+// This should never read through to b's prototype.
+b = Object.create({y: 2},
+{x: {enumerable: true,
+configurable: true,
+get: function() { if (this.hasOwnProperty("y")) delete this.y; return 1; }},
+y: {enumerable: true,
+configurable: true,
+writable: true,
+value: 3}});
+check(b, "selfModifyingObject");
+// Ignore properties with object-ids.
+var uri = "http://example.net";
+b = {x: 1, y: 2};
+Object.defineProperty(b, Array(uri, "x"), {enumerable: true, value: 3});
+Object.defineProperty(b, Array(uri, "y"), {enumerable: true, value: 5});
+check(b);
+}
+test();
+reportCompare(0, 0, 'ok');