The Tor Browser / file revision

 // |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');