The Tor Browser: js/src/tests/ecma_5/Object/defineProperty-setup.js@129ffea94266 (annotated)

js/src/tests/ecma_5/Object/defineProperty-setup.js@129ffea94266 (annotated)

js/src/tests/ecma_5/Object/defineProperty-setup.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 // |reftest| skip -- not a test.
 // Any copyright is dedicated to the Public Domain.
 // http://creativecommons.org/licenses/publicdomain/
 assertEq("defineProperty" in Object, true);
 assertEq(Object.defineProperty.length, 3);
 /*
  * Disable an assertion that is pathologically slow given the exhaustiveness of
  * these tests.
  */
 if (typeof enableStackWalkingAssertion === "function")
   enableStackWalkingAssertion(false);
 if (!Object.prototype.toSource)
 {
   Object.defineProperty(Object.prototype, "toSource",
   {
     value: function toSource()
     {
       if (this instanceof RegExp)
       {
         var v = "new RegExp(" + uneval(this.source);
         var f = (this.multiline ? "m" : "") +
                 (this.global ? "g" : "") +
                 (this.ignoreCase ? "i" : "");
         return v + (f ? ", '" + f + "'" : "") + ")";
       }
       return JSON.stringify(this);
     },
     enumerable: false,
     configurable: true,
     writable: true
   });
 }
 if (!("uneval" in this))
 {
   Object.defineProperty(this, "uneval",
   {
     value: function uneval(v)
     {
       if (v === null)
         return "null";
       if (typeof v === "object")
         return v.toSource();
       if (typeof v === "string")
       {
         v = JSON.stringify({v:v});
         return v.substring(5, v.length - 1);
       }
       return "" + v;
     },
     enumerable: false,
     configurable: true,
     writable: true
   });
 }
 // reimplemented for the benefit of engines which don't have this helper
 function assertEq(v1, v2, m)
 {
   if (!SameValue(v1, v2))
   {
     throw "assertion failed: " +
           "got " + uneval(v1) + ", expected " + uneval(v2) +
           (m ? ": " + m : "");
   }
 }
 function SameValue(v1, v2)
 {
   if (v1 === 0 && v2 === 0)
     return 1 / v1 === 1 / v2;
   if (v1 !== v1 && v2 !== v2)
     return true;
   return v1 === v2;
 }
 function PropertyDescriptor(pd)
 {
   if (pd)
     this.update(pd);
 }
 PropertyDescriptor.prototype.update = function update(pd)
 {
   if ("get" in pd)
     this.get = pd.get;
   if ("set" in pd)
     this.set = pd.set;
   if ("configurable" in pd)
     this.configurable = pd.configurable;
   if ("writable" in pd)
     this.writable = pd.writable;
   if ("enumerable" in pd)
     this.enumerable = pd.enumerable;
   if ("value" in pd)
     this.value = pd.value;
 };
 PropertyDescriptor.prototype.convertToDataDescriptor = function convertToDataDescriptor()
 {
   delete this.get;
   delete this.set;
   this.writable = false;
   this.value = undefined;
 };
 PropertyDescriptor.prototype.convertToAccessorDescriptor = function convertToAccessorDescriptor()
 {
   delete this.writable;
   delete this.value;
   this.get = undefined;
   this.set = undefined;
 };
 function compareDescriptors(d1, d2)
 {
   if (d1 === undefined)
   {
     assertEq(d2, undefined, "non-descriptors");
     return;
   }
   if (d2 === undefined)
   {
     assertEq(true, false, "descriptor-equality mismatch: " + uneval(d1) + ", " + uneval(d2));
     return;
   }
   var props = ["value", "get", "set", "enumerable", "configurable", "writable"];
   for (var i = 0, sz = props.length; i < sz; i++)
   {
     var p = props[i];
     assertEq(p in d1, p in d2, p + " different in d1/d2");
     if (p in d1)
       assertEq(d1[p], d2[p], p);
   }
 }
 function examine(desc, field, allowDefault)
 {
   if (field in desc)
     return desc[field];
   assertEq(allowDefault, true, "reimplementation error");
   switch (field)
   {
     case "value":
     case "get":
     case "set":
       return undefined;
     case "writable":
     case "enumerable":
     case "configurable":
       return false;
     default:
       assertEq(true, false, "bad field name: " + field);
   }
 }
 function IsAccessorDescriptor(desc)
 {
   if (!desc)
     return false;
   if (!("get" in desc) && !("set" in desc))
     return false;
   return true;
 }
 function IsDataDescriptor(desc)
 {
   if (!desc)
     return false;
   if (!("value" in desc) && !("writable" in desc))
     return false;
   return true;
 }
 function IsGenericDescriptor(desc)
 {
   if (!desc)
     return false;
   if (!IsAccessorDescriptor(desc) && !IsDataDescriptor(desc))
     return true;
   return false;
 }
 function CustomObject()
 {
   this.properties = {};
   this.extensible = true;
 }
 CustomObject.prototype =
 {
   _reject: function _reject(throwing, msg)
   {
     if (throwing)
       throw new TypeError(msg + "; rejected!");
     return false;
   },
   defineOwnProperty: function defineOwnProperty(propname, desc, throwing)
   {
     assertEq(typeof propname, "string", "non-string propname");
     // Step 1.
     var current = this.properties[propname];
     // Step 2.
     var extensible = this.extensible;
     // Step 3.
     if (current === undefined && !extensible)
       return this._reject(throwing, "object not extensible");
     // Step 4.
     if (current === undefined && extensible)
     {
       var p;
       // Step 4(a).
       if (IsGenericDescriptor(desc) || IsDataDescriptor(desc))
       {
         p = new PropertyDescriptor();
         p.value = examine(desc, "value", true);
         p.writable = examine(desc, "writable", true);
         p.enumerable = examine(desc, "enumerable", true);
         p.configurable = examine(desc, "configurable", true);
       }
       // Step 4(b).
       else
       {
         p = new PropertyDescriptor();
         p.get = examine(desc, "get", true);
         p.set = examine(desc, "set", true);
         p.enumerable = examine(desc, "enumerable", true);
         p.configurable = examine(desc, "configurable", true);
       }
       this.properties[propname] = p;
       // Step 4(c).
       return true;
     }
     // Step 5.
     if (!("value" in desc) && !("get" in desc) && !("set" in desc) &&
         !("writable" in desc) && !("enumerable" in desc) &&
         !("configurable" in desc))
     {
       return;
     }
     // Step 6.
     do
     {
       if ("value" in desc)
       {
         if (!("value" in current) || !SameValue(desc.value, current.value))
           break;
       }
       if ("get" in desc)
       {
         if (!("get" in current) || !SameValue(desc.get, current.get))
           break;
       }
       if ("set" in desc)
       {
         if (!("set" in current) || !SameValue(desc.set, current.set))
           break;
       }
       if ("writable" in desc)
       {
         if (!("writable" in current) ||
             !SameValue(desc.writable, current.writable))
         {
           break;
         }
       }
       if ("enumerable" in desc)
       {
         if (!("enumerable" in current) ||
             !SameValue(desc.enumerable, current.enumerable))
         {
           break;
         }
       }
       if ("configurable" in desc)
       {
         if (!("configurable" in current) ||
             !SameValue(desc.configurable, current.configurable))
         {
           break;
         }
       }
       // all fields in desc also in current, with the same values
       return true;
     }
     while (false);
     // Step 7.
     if (!examine(current, "configurable"))
     {
       if ("configurable" in desc && examine(desc, "configurable"))
         return this._reject(throwing, "can't make configurable again");
       if ("enumerable" in desc &&
           examine(current, "enumerable") !== examine(desc, "enumerable"))
       {
         return this._reject(throwing, "can't change enumerability");
       }
     }
     // Step 8.
     if (IsGenericDescriptor(desc))
     {
       // do nothing
     }
     // Step 9.
     else if (IsDataDescriptor(current) !== IsDataDescriptor(desc))
     {
       // Step 9(a).
       if (!examine(current, "configurable"))
         return this._reject(throwing, "can't change unconfigurable descriptor's type");
       // Step 9(b).
       if (IsDataDescriptor(current))
         current.convertToAccessorDescriptor();
       // Step 9(c).
       else
         current.convertToDataDescriptor();
     }
     // Step 10.
     else if (IsDataDescriptor(current) && IsDataDescriptor(desc))
     {
       // Step 10(a)
       if (!examine(current, "configurable"))
       {
         // Step 10(a).i.
         if (!examine(current, "writable") &&
             "writable" in desc && examine(desc, "writable"))
         {
           return this._reject(throwing, "can't make data property writable again");
         }
         // Step 10(a).ii.
         if (!examine(current, "writable"))
         {
           if ("value" in desc &&
               !SameValue(examine(desc, "value"), examine(current, "value")))
           {
             return this._reject(throwing, "can't change value if not writable");
           }
         }
       }
       // Step 10(b).
       else
       {
         assertEq(examine(current, "configurable"), true,
                  "spec bug step 10(b)");
       }
     }
     // Step 11.
     else
     {
       assertEq(IsAccessorDescriptor(current) && IsAccessorDescriptor(desc),
                true,
                "spec bug");
       // Step 11(a).
       if (!examine(current, "configurable"))
       {
         // Step 11(a).i.
         if ("set" in desc &&
             !SameValue(examine(desc, "set"), examine(current, "set")))
         {
           return this._reject(throwing, "can't change setter if not configurable");
         }
         // Step 11(a).ii.
         if ("get" in desc &&
             !SameValue(examine(desc, "get"), examine(current, "get")))
         {
           return this._reject(throwing, "can't change getter if not configurable");
         }
       }
     }
     // Step 12.
     current.update(desc);
     // Step 13.
     return true;
   }
 };
 function IsCallable(v)
 {
   return typeof v === "undefined" || typeof v === "function";
 }
 var NativeTest =
   {
     newObject: function newObject()
     {
       return {};
     },
     defineProperty: function defineProperty(obj, propname, propdesc)
     {
       Object.defineProperty(obj, propname, propdesc);
     },
     getDescriptor: function getDescriptor(obj, propname)
     {
       return Object.getOwnPropertyDescriptor(obj, propname);
     }
   };
 var ReimplTest =
   {
     newObject: function newObject()
     {
       return new CustomObject();
     },
     defineProperty: function defineProperty(obj, propname, propdesc)
     {
       assertEq(obj instanceof CustomObject, true, "obj not instanceof CustomObject");
       if ("get" in propdesc || "set" in propdesc)
       {
         if ("value" in propdesc || "writable" in propdesc)
           throw new TypeError("get/set and value/writable");
         if (!IsCallable(propdesc.get))
           throw new TypeError("get defined, uncallable");
         if (!IsCallable(propdesc.set))
           throw new TypeError("set defined, uncallable");
       }
       return obj.defineOwnProperty(propname, propdesc, true);
     },
     getDescriptor: function getDescriptor(obj, propname)
     {
       if (!(propname in obj.properties))
         return undefined;
       return new PropertyDescriptor(obj.properties[propname]);
     }
   };
 var JSVAL_INT_MAX = Math.pow(2, 30) - 1;
 var JSVAL_INT_MIN = -Math.pow(2, 30);
 function isValidDescriptor(propdesc)
 {
   if ("get" in propdesc || "set" in propdesc)
   {
     if ("value" in propdesc || "writable" in propdesc)
       return false;
     // We permit null here simply because this test's author believes the
     // implementation may sometime be susceptible to making mistakes in this
     // regard and would prefer to be cautious.
     if (propdesc.get !== null && propdesc.get !== undefined && !IsCallable(propdesc.get))
       return false;
     if (propdesc.set !== null && propdesc.set !== undefined && !IsCallable(propdesc.set))
       return false;
   }
   return true;
 }
 var OMIT = {};
 var VALUES =
   [-Infinity, JSVAL_INT_MIN, -0, +0, 1.5, JSVAL_INT_MAX, Infinity,
    NaN, "foo", "bar", null, undefined, true, false, {}, /a/, OMIT];
 var GETS =
   [undefined, function get1() { return 1; }, function get2() { return 2; },
    null, 5, OMIT];
 var SETS =
   [undefined, function set1() { return 1; }, function set2() { return 2; },
    null, 5, OMIT];
 var ENUMERABLES = [true, false, OMIT];
 var CONFIGURABLES = [true, false, OMIT];
 var WRITABLES = [true, false, OMIT];
 function mapTestDescriptors(filter)
 {
   var descs = [];
   var desc = {};
   function put(field, value)
   {
     if (value !== OMIT)
       desc[field] = value;
   }
   VALUES.forEach(function(value)
   {
     GETS.forEach(function(get)
     {
       SETS.forEach(function(set)
       {
         ENUMERABLES.forEach(function(enumerable)
         {
           CONFIGURABLES.forEach(function(configurable)
           {
             WRITABLES.forEach(function(writable)
             {
               desc = {};
               put("value", value);
               put("get", get);
               put("set", set);
               put("enumerable", enumerable);
               put("configurable", configurable);
               put("writable", writable);
               if (filter(desc))
                 descs.push(desc);
             });
           });
         });
       });
     });
   });
   return descs;
 }
 var ALL_DESCRIPTORS = mapTestDescriptors(function(d) { return true; });
 var VALID_DESCRIPTORS = mapTestDescriptors(isValidDescriptor);
 var SKIP_FULL_FUNCTION_LENGTH_TESTS = true;
 function TestRunner()
 {
   this._logLines = [];
 }
 TestRunner.prototype =
   {
     // MAIN METHODS
     runFunctionLengthTests: function runFunctionLengthTests()
     {
       var self = this;
       function functionLengthTests()
       {
         if (SKIP_FULL_FUNCTION_LENGTH_TESTS)
         {
           print("Skipping full tests for redefining Function.length for now " +
                 "because we don't support redefinition of properties with " +
                 "native getter or setter...");
           self._simpleFunctionLengthTests();
         }
         else
         {
           self._simpleFunctionLengthTests();
           self._fullFunctionLengthTests(function() { }, 0);
           self._fullFunctionLengthTests(function(one) { }, 1);
           self._fullFunctionLengthTests(function(one, two) { }, 2);
         }
       }
       this._runTestSet(functionLengthTests, "Function length tests completed!");
     },
     runNotPresentTests: function runNotPresentTests()
     {
       var self = this;
       function notPresentTests()
       {
         print("Running not-present tests now...");
         for (var i = 0, sz = ALL_DESCRIPTORS.length; i < sz; i++)
           self._runSingleNotPresentTest(ALL_DESCRIPTORS[i]);
       };
       this._runTestSet(notPresentTests, "Not-present length tests completed!");
     },
     runPropertyPresentTestsFraction:
     function runPropertyPresentTestsFraction(part, parts)
     {
       var self = this;
       function propertyPresentTests()
       {
         print("Running already-present tests now...");
         var total = VALID_DESCRIPTORS.length;
         var start = Math.floor((part - 1) / parts * total);
         var end = Math.floor(part / parts * total);
         for (var i = start; i < end; i++)
         {
           var old = VALID_DESCRIPTORS[i];
           print("Starting test with old descriptor " + old.toSource() + "...");
           for (var j = 0, sz2 = VALID_DESCRIPTORS.length; j < sz2; j++)
             self._runSinglePropertyPresentTest(old, VALID_DESCRIPTORS[j], []);
         }
       }
       this._runTestSet(propertyPresentTests,
                        "Property-present fraction " + part + " of " + parts +
                        " completed!");
     },
     runNonTerminalPropertyPresentTestsFraction:
     function runNonTerminalPropertyPresentTestsFraction(part, parts)
     {
       var self = this;
       /*
        * A plain old property to define on the object before redefining the
        * originally-added property, to test redefinition of a property that's
        * not also lastProperty.  NB: we could loop over every possible
        * descriptor here if we wanted, even try adding more than one, but we'd
        * hit cubic complexity and worse, and SpiderMonkey only distinguishes by
        * the mere presence of the middle property, not its precise details.
        */
       var middleDefines =
         [{
            property: "middle",
            descriptor:
              { value: 17, writable: true, configurable: true, enumerable: true }
          }];
       function nonTerminalPropertyPresentTests()
       {
         print("Running non-terminal already-present tests now...");
         var total = VALID_DESCRIPTORS.length;
         var start = Math.floor((part - 1) / parts * total);
         var end = Math.floor(part / parts * total);
         for (var i = start; i < end; i++)
         {
           var old = VALID_DESCRIPTORS[i];
           print("Starting test with old descriptor " + old.toSource() + "...");
           for (var j = 0, sz2 = VALID_DESCRIPTORS.length; j < sz2; j++)
           {
             self._runSinglePropertyPresentTest(old, VALID_DESCRIPTORS[j],
                                                middleDefines);
           }
         }
       }
       this._runTestSet(nonTerminalPropertyPresentTests,
                        "Non-terminal property-present fraction " +
                        part + " of " + parts + " completed!");
     },
     runDictionaryPropertyPresentTestsFraction:
     function runDictionaryPropertyPresentTestsFraction(part, parts)
     {
       var self = this;
       /*
        * Add and readd properties such that the scope for the object is in
        * dictionary mode.
        */
       var middleDefines =
         [
          {
            property: "mid1",
            descriptor:
              { value: 17, writable: true, configurable: true, enumerable: true }
          },
          {
            property: "mid2",
            descriptor:
              { value: 17, writable: true, configurable: true, enumerable: true }
          },
          {
            property: "mid1",
            descriptor:
              { get: function g() { }, set: function s(v){}, configurable: false,
                enumerable: true }
          },
          ];
       function dictionaryPropertyPresentTests()
       {
         print("Running dictionary already-present tests now...");
         var total = VALID_DESCRIPTORS.length;
         var start = Math.floor((part - 1) / parts * total);
         var end = Math.floor(part / parts * total);
         for (var i = start; i < end; i++)
         {
           var old = VALID_DESCRIPTORS[i];
           print("Starting test with old descriptor " + old.toSource() + "...");
           for (var j = 0, sz2 = VALID_DESCRIPTORS.length; j < sz2; j++)
           {
             self._runSinglePropertyPresentTest(old, VALID_DESCRIPTORS[j],
                                                middleDefines);
           }
         }
       }
       this._runTestSet(dictionaryPropertyPresentTests,
                        "Dictionary property-present fraction " +
                        part + " of " + parts + " completed!");
     },
     // HELPERS
     runPropertyPresentTests: function runPropertyPresentTests()
     {
       print("Running already-present tests now...");
       for (var i = 0, sz = VALID_DESCRIPTORS.length; i < sz; i++)
       {
         var old = VALID_DESCRIPTORS[i];
         print("Starting test with old descriptor " + old.toSource() + "...");
         for (var j = 0, sz2 = VALID_DESCRIPTORS.length; j < sz2; j++)
           this._runSinglePropertyPresentTest(old, VALID_DESCRIPTORS[j], []);
       }
     },
     _runTestSet: function _runTestSet(fun, completeMessage)
     {
       try
       {
         fun();
         print(completeMessage);
       }
       catch (e)
       {
         print("ERROR, EXITING (line " + (e.lineNumber || -1) + "): " + e);
         throw e;
       }
       finally
       {
         this._reportAllErrors();
       }
     },
     _reportAllErrors: function _reportAllErrors()
     {
       var errorCount = this._logLines.length;
       print("Full accumulated number of errors: " + errorCount);
       if (errorCount > 0)
         throw errorCount + " errors detected, FAIL";
     },
     _simpleFunctionLengthTests: function _simpleFunctionLengthTests(fun)
     {
       print("Running simple Function.length tests now..");
       function expectThrowTypeError(o, p, desc)
       {
         var err = "<none>", passed = false;
         try
         {
           Object.defineProperty(o, p, desc);
         }
         catch (e)
         {
           err = e;
           passed = e instanceof TypeError;
         }
         assertEq(passed, true, fun + " didn't throw TypeError when called: " + err);
       }
       expectThrowTypeError(function a() { }, "length", { value: 1 });
       expectThrowTypeError(function a() { }, "length", { enumerable: true });
       expectThrowTypeError(function a() { }, "length", { configurable: true });
       expectThrowTypeError(function a() { }, "length", { writable: true });
     },
     _fullFunctionLengthTests: function _fullFunctionLengthTests(fun)
     {
       var len = fun.length;
       print("Running Function.length (" + len + ") tests now...");
       var desc;
       var gen = new DescriptorState();
       while ((desc = gen.nextDescriptor()))
         this._runSingleFunctionLengthTest(fun, len, desc);
     },
     _log: function _log(v)
     {
       var m = "" + v;
       print(m);
       this._logLines.push(m);
     },
     _runSingleNotPresentTest: function _runSingleNotPresentTest(desc)
     {
       var nativeObj = NativeTest.newObject();
       var reimplObj = ReimplTest.newObject();
       try
       {
         NativeTest.defineProperty(nativeObj, "foo", desc);
       }
       catch (e)
       {
         try
         {
           ReimplTest.defineProperty(reimplObj, "foo", desc);
         }
         catch (e2)
         {
           if (e.constructor !== e2.constructor)
           {
             this._log("Difference when comparing native/reimplementation " +
                       "behavior for new descriptor " + desc.toSource() +
                       ", native threw " + e + ", reimpl threw " + e2);
           }
           return;
         }
         this._log("Difference when comparing native/reimplementation " +
                   "behavior for new descriptor " + desc.toSource() +
                   ", error " + e);
         return;
       }
       try
       {
         ReimplTest.defineProperty(reimplObj, "foo", desc);
       }
       catch (e)
       {
         this._log("Reimpl threw defining new descriptor " + desc.toSource() +
                   ", error: " + e);
         return;
       }
       var nativeDesc = NativeTest.getDescriptor(nativeObj, "foo");
       var reimplDesc = ReimplTest.getDescriptor(reimplObj, "foo");
       try
       {
         compareDescriptors(nativeDesc, reimplDesc);
       }
       catch (e)
       {
         this._log("Difference comparing returned descriptors for new " +
                   "property defined with descriptor " + desc.toSource() +
                   "; error: " + e);
         return;
       }
     },
     _runSinglePropertyPresentTest:
     function _runSinglePropertyPresentTest(old, add, middleDefines)
     {
       var nativeObj = NativeTest.newObject();
       var reimplObj = ReimplTest.newObject();
       try
       {
         NativeTest.defineProperty(nativeObj, "foo", old);
       }
       catch (e)
       {
         if (!SameValue(NativeTest.getDescriptor(nativeObj, "foo"), undefined))
         {
           this._log("defining bad property descriptor: " + old.toSource());
           return;
         }
         try
         {
           ReimplTest.defineProperty(reimplObj, "foo", old);
         }
         catch (e2)
         {
           if (!SameValue(ReimplTest.getDescriptor(reimplObj, "foo"),
                          undefined))
           {
             this._log("defining bad property descriptor: " + old.toSource() +
                       "; reimplObj: " + uneval(reimplObj));
           }
           if (e.constructor !== e2.constructor)
           {
             this._log("Different errors defining bad property descriptor: " +
                       old.toSource() + "; native threw " + e + ", reimpl " +
                       "threw " + e2);
           }
           return;
         }
         this._log("Difference defining a property with descriptor " +
                   old.toSource() + ", error " + e);
         return;
       }
       try
       {
         ReimplTest.defineProperty(reimplObj, "foo", old);
       }
       catch (e)
       {
         this._log("Difference when comparing native/reimplementation " +
                   "behavior when adding descriptor " + add.toSource() +
                   ", error: " + e);
         return;
       }
       // Now add (or even readd) however many properties were specified between
       // the original property to add and the new one, to test redefining
       // non-last-properties and properties in scopes in dictionary mode.
       for (var i = 0, sz = middleDefines.length; i < sz; i++)
       {
         var middle = middleDefines[i];
         var prop = middle.property;
         var desc = middle.descriptor;
         try
         {
           NativeTest.defineProperty(nativeObj, prop, desc);
           ReimplTest.defineProperty(reimplObj, prop, desc);
         }
         catch (e)
         {
           this._log("failure defining middle descriptor: " + desc.toSource() +
                     ", error " + e);
           return;
         }
         // Sanity check
         var nativeDesc = NativeTest.getDescriptor(nativeObj, prop);
         var reimplDesc = ReimplTest.getDescriptor(reimplObj, prop);
         compareDescriptors(nativeDesc, reimplDesc);
         compareDescriptors(nativeDesc, desc);
       }
       try
       {
         NativeTest.defineProperty(nativeObj, "foo", add);
       }
       catch (e)
       {
         try
         {
           ReimplTest.defineProperty(reimplObj, "foo", add);
         }
         catch (e2)
         {
           if (e.constructor !== e2.constructor)
           {
             this._log("Difference when comparing native/reimplementation " +
                       "behavior for descriptor " + add.toSource() +
                       " overwriting descriptor " + old.toSource() + "; " +
                       "native threw " + e + ", reimpl threw " + e2);
           }
           return;
         }
         this._log("Difference when comparing native/reimplementation " +
                   "behavior for added descriptor " + add.toSource() + ", " +
                   "initial was " + old.toSource() + "; error: " + e);
         return;
       }
       try
       {
         ReimplTest.defineProperty(reimplObj, "foo", add);
       }
       catch (e)
       {
         this._log("Difference when comparing native/reimplementation " +
                   "behavior for readded descriptor " + add.toSource() + ", " +
                   "initial was " + old.toSource() + "; native readd didn't " +
                   "throw, reimpl add did, error: " + e);
         return;
       }
       var nativeDesc = NativeTest.getDescriptor(nativeObj, "foo");
       var reimplDesc = ReimplTest.getDescriptor(reimplObj, "foo");
       try
       {
         compareDescriptors(nativeDesc, reimplDesc);
       }
       catch (e)
       {
         this._log("Difference comparing returned descriptors for readded " +
                   "property defined with descriptor " + add.toSource() + "; " +
                   "initial was " + old.toSource() + "; error: " + e);
         return;
       }
     },
     _runSingleFunctionLengthTest: function _runSingleFunctionLengthTest(fun, len, desc)
     {
       var nativeObj = fun;
       var reimplObj = ReimplTest.newObject();
       ReimplTest.defineProperty(reimplObj, "length",
       {
         value: len,
         enumerable: false,
         configurable: false,
         writable: false
       });
       try
       {
         NativeTest.defineProperty(nativeObj, "length", desc);
       }
       catch (e)
       {
         try
         {
           ReimplTest.defineProperty(reimplObj, "length", desc);
         }
         catch (e2)
         {
           if (e.constructor !== e2.constructor)
           {
             this._log("Difference when comparing native/reimplementation " +
                       "behavior defining fun.length with " + desc.toSource() +
                       "; native threw " + e + ", reimpl threw " + e2);
           }
           return;
         }
         this._log("Difference when comparing Function.length native/reimpl " +
                   "behavior for descriptor " + desc.toSource() +
                   ", native impl threw error " + e);
         return;
       }
       try
       {
         ReimplTest.defineProperty(reimplObj, "length", desc);
       }
       catch (e)
       {
         this._log("Difference defining new Function.length descriptor: impl " +
                   "succeeded, reimpl threw for descriptor " +
                   desc.toSource() + ", error: " + e);
         return;
       }
       var nativeDesc = NativeTest.getDescriptor(nativeObj, "length");
       var reimplDesc = ReimplTest.getDescriptor(reimplObj, "length");
       try
       {
         compareDescriptors(nativeDesc, reimplDesc);
       }
       catch (e)
       {
         this._log("Difference comparing returned descriptors for " +
                   "Function.length with descriptor " + desc.toSource() +
                   "; error: " + e);
         return;
       }
     }
   };
 function runDictionaryPropertyPresentTestsFraction(PART, PARTS)
 {
   var testfile =
     '15.2.3.6-dictionary-redefinition-' + PART + '-of-' + PARTS + '.js';
   var BUGNUMBER = 560566;
   var summary =
     'ES5 Object.defineProperty(O, P, Attributes): dictionary redefinition ' +
     PART + ' of ' + PARTS;
   print(BUGNUMBER + ": " + summary);
   try
   {
     new TestRunner().runDictionaryPropertyPresentTestsFraction(PART, PARTS);
   }
   catch (e)
   {
     throw "Error thrown during testing: " + e +
             " at line " + e.lineNumber + "\n" +
           (e.stack
             ? "Stack: " + e.stack.split("\n").slice(2).join("\n") + "\n"
             : "");
   }
   if (typeof reportCompare === "function")
     reportCompare(true, true);
   print("Tests complete!");
 }
 function runNonTerminalPropertyPresentTestsFraction(PART, PARTS)
 {
   var BUGNUMBER = 560566;
   var summary =
     'ES5 Object.defineProperty(O, P, Attributes): middle redefinition ' +
     PART + ' of ' + PARTS;
   print(BUGNUMBER + ": " + summary);
   /**************
    * BEGIN TEST *
    **************/
   try
   {
     new TestRunner().runNonTerminalPropertyPresentTestsFraction(PART, PARTS);
   }
   catch (e)
   {
     throw "Error thrown during testing: " + e +
             " at line " + e.lineNumber + "\n" +
           (e.stack
             ? "Stack: " + e.stack.split("\n").slice(2).join("\n") + "\n"
             : "");
   }
   /******************************************************************************/
   if (typeof reportCompare === "function")
     reportCompare(true, true);
   print("Tests complete!");
 }