summaryrefslogtreecommitdiffstats
path: root/js/src/tests/ecma_5/Object/defineProperty-setup.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/tests/ecma_5/Object/defineProperty-setup.js')
-rw-r--r--js/src/tests/ecma_5/Object/defineProperty-setup.js1071
1 files changed, 1071 insertions, 0 deletions
diff --git a/js/src/tests/ecma_5/Object/defineProperty-setup.js b/js/src/tests/ecma_5/Object/defineProperty-setup.js
new file mode 100644
index 000000000..da6fe8f49
--- /dev/null
+++ b/js/src/tests/ecma_5/Object/defineProperty-setup.js
@@ -0,0 +1,1071 @@
+// |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);
+
+function TestRunner()
+{
+ this._logLines = [];
+}
+TestRunner.prototype =
+ {
+ // MAIN METHODS
+
+ runFunctionLengthTests: function runFunctionLengthTests()
+ {
+ var self = this;
+ function functionLengthTests()
+ {
+ self._fullFunctionLengthTests(() => Function("one", "/* body */"), 1);
+ self._fullFunctionLengthTests(() => function(one, two, three=null) { }, 2);
+ self._fullFunctionLengthTests(() => (one, two, ...etc) => 0, 2);
+ self._fullFunctionLengthTests(() => ({method(){}}.method), 0);
+ self._fullFunctionLengthTests(() => Object.getOwnPropertyDescriptor({set x(v){}}, "x").set, 1);
+ }
+
+ 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";
+ },
+ _fullFunctionLengthTests: function _fullFunctionLengthTests(funFactory, len)
+ {
+ print("Running Function.length (" + funFactory + ") tests now...");
+
+ for (var i = 0, sz = VALID_DESCRIPTORS.length; i < sz; i++)
+ {
+ var desc = VALID_DESCRIPTORS[i];
+ this._runSingleFunctionLengthTest(funFactory(), 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: true,
+ 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!");
+}