| //------------------------------------------------------------------------------------------------------- |
| // Copyright (C) Microsoft. All rights reserved. |
| // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information. |
| //------------------------------------------------------------------------------------------------------- |
| |
| var helpers = function helpers() { |
| //private |
| var undefinedAsString = "undefined"; |
| |
| var isInBrowser = function isInBrowser() { |
| return typeof (document) !== undefinedAsString; |
| }; |
| |
| return { |
| // public |
| getDummyObject: function () { |
| //return isInBrowser() ? document : {}; |
| return {}; |
| }, |
| |
| writeln: function writeln() { |
| var line = "", i; |
| for (i = 0; i < arguments.length; i += 1) { |
| line = line.concat(arguments[i]) |
| } |
| if (!isInBrowser()) { |
| WScript.Echo(line); |
| } else { |
| document.writeln(line); |
| document.writeln("<br/>"); |
| } |
| }, |
| |
| printObject: function printObject(o) { |
| var name; |
| for (name in o) { |
| this.writeln(name, o.hasOwnProperty(name) ? "" : " (inherited)", ": ", o[name]); |
| } |
| } |
| } |
| } (); // helpers module. |
| |
| var testRunner = function testRunner() { |
| var executedTestCount = 0; |
| var passedTestCount = 0; |
| var passName; |
| |
| return { |
| // Runs provided tests. |
| // passes is a collection of {name, prep}, where prep is a function to prepare for the pass. |
| // The 'testsToRun' is an object that has enumerable properties, |
| // each property is an object that has 'name' and 'body' properties. |
| runTests: function runTests(passes, testsToRun) { |
| for (var p in passes) { |
| var pass = passes[p]; |
| passName = pass.name; |
| if (pass.prep) { |
| pass.prep(); |
| } |
| for (var i in testsToRun) { |
| var test = tests[i]; |
| |
| // |
| // * If test.disabled (e.g., temp bug), skip it. |
| // * If test.pass specifies a pass name, only run it for that pass. |
| // * If test.pass not defined, run it for any non "runonce" pass. |
| // |
| if (!test.disabled && (test.pass === passName || (!test.pass && !pass.runonce))) { |
| this.runTest(i, test.name, test.body); |
| } |
| } |
| } |
| |
| helpers.writeln("Summary of tests: total executed: ", executedTestCount, |
| "; passed: ", passedTestCount, "; failed: ", executedTestCount - passedTestCount); |
| }, |
| |
| // Runs test body catching all exceptions. |
| // Result: prints PASSED/FAILED to the output. |
| runTest: function runTest(testIndex, testName, testBody) { |
| helpers.writeln("*** ", passName, " (", testIndex, "): ", testName); |
| |
| var isSuccess = true; |
| try { |
| testBody(); |
| } catch (ex) { |
| var message = ex.message !== undefined ? ex.message : ex; |
| helpers.writeln("Test threw exception: ", message); |
| isSuccess = false; |
| } |
| if (isSuccess) { |
| helpers.writeln("PASSED"); |
| ++passedTestCount; |
| } else { |
| helpers.writeln("FAILED"); |
| } |
| |
| ++executedTestCount; |
| } |
| } |
| }(); // testRunner. |
| |
| var assert = function assert() { |
| // private |
| var isObject = function isObject(x) { |
| return x instanceof Object && typeof x !== "function"; |
| }; |
| |
| var compare = function compare(expected, actual) { |
| if (isObject(expected)) { |
| if (!isObject(actual)) return "actual is not an object"; |
| var expectedFieldCount = 0, actualFieldCount = 0; |
| for (var i in expected) { |
| var compareResult = compare(expected[i], actual[i]); |
| if (compareResult !== true) return compareResult; |
| ++expectedFieldCount; |
| } |
| for (var i in actual) { |
| ++actualFieldCount; |
| } |
| if (expectedFieldCount !== actualFieldCount) { |
| return "actual has different number of fields than expected"; |
| } |
| return true; |
| } else { |
| if (isObject(actual)) return "actual is an object"; |
| if (expected === actual) return true; |
| return "expected: " + expected + " actual: " + actual; |
| } |
| }; |
| |
| var addMessage = function addMessage(baseMessage, message) { |
| if (message !== undefined) { |
| baseMessage += ": " + message; |
| } |
| return baseMessage; |
| } |
| |
| return { |
| // Performs deep comparison of arguments. |
| // This works for objects and simple types. |
| // TODO: account for other types? |
| // TODO: account for missing vs undefined fields. |
| areEqual: function areEqual(expected, actual, message) { |
| var compareResult = compare(expected, actual); |
| if (compareResult !== true) { |
| throw addMessage("assert.areEqual failed: " + compareResult, message); |
| } |
| }, |
| |
| areNotEqual: function areNotEqual(expected, actual, message) { |
| var compareResult = compare(expected, actual); |
| if (compareResult === true) { |
| throw addMessage("assert.areNotEqual failed", message); |
| } |
| }, |
| |
| // Makes sure that the function specified by the 'testFunction' parameter |
| // throws the exception specified by the 'expectedException' parameter. |
| // Note: currently we check only for specific exception and not "all exceptions derived from specified". |
| // Example: |
| // assert.throws(function() { eval("{"); }, SyntaxError, "expected SyntaxError") |
| throws: function throws(testFunction, expectedException, message) { |
| var exception = null; |
| try { |
| testFunction(); |
| } catch (ex) { |
| exception = ex; |
| } |
| if (!(exception instanceof Object && exception.constructor === expectedException)) { |
| var expectedString = expectedException.toString().replace(/\n/g, "").replace(/.*function (.*)\(.*/g, "$1"); |
| throw addMessage("assert.throws failed: expected: " + expectedString + ", actual: " + exception, message); |
| } |
| }, |
| |
| // Can be used to fail the test. |
| fail: function fail(message) { |
| throw message; |
| } |
| } |
| }(); // assert. |
| |
| var tests = { |
| // Note: each test has name (string) and body (function) properties. |
| // Success is when the body does not throw, failure -- when it throws. |
| |
| //---------------------- normal identifier property names ------------------------------- |
| test01: { |
| name: "8.12.9.4.a (variation 1): define generic property, check default attrbitues", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo02"; |
| var pd = {}; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: undefined, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test02: { |
| name: "8.12.9.4.a (variation 2): define data property, check default attrbitues", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo03"; |
| var pd = { value: 0 }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 0, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test03: { |
| name: "8.12.9.4.a (variation 3): define generic property by specifying some attributes, check attrbitues", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo02"; |
| var pd = { configurable: true, writable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: undefined, configurable: true, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test04: { |
| name: "8.12.9.4.b: define accessor property, check default attrbitues", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo04"; |
| var getter = function () { return this.Value }; |
| var pd = { get: getter }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: getter, set: undefined, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test05: { |
| name: "8.12.9.5: re-define property: use descriptor with all fields absent, check that nothing happens to previous descriptor", |
| body: function () { |
| var propertyName = "foo05"; |
| var o = { foo05: 1 }; |
| var pd = {}; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: true, value: 1, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test06: { |
| name: "8.12.9.6: re-define property: use equal descriptor with data field, check that nothing happens to previous descriptor", |
| body: function () { |
| var propertyName = "foo06"; |
| var o = { foo06: 1 }; |
| var pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: true, value: 1, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| // where we are: |
| // - re-define |
| // - desc is not empty |
| // - desc and current are not the same |
| |
| test07: { |
| name: "8.12.9.7.a: re-define property: current descriptor is not configurable and descriptor is configurable, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo07"; |
| var pd = { value: 0, configurable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, configurable: true }; |
| assert.throws(function() { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test08: { |
| name: "8.12.9.7.b (variation 1): re-define property: current descriptor is not configurable and descriptor enumerable is specified and it's negation of current enumerable, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo08"; |
| var pd = { value: 0 }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, enumerable: true }; |
| assert.throws(function() { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test09: { |
| name: "8.12.9.7.b (variation 2): re-define property: current descriptor is not configurable and descriptor enumerable is not specified, check that it does not throw", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo09"; |
| var pd = { value: 0, writable: true }; // set writable to true to avoid throw code path. |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, writable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 1, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test10: { |
| name: "8.12.9.7.b (variation 3): re-define property: current descriptor is not configurable and descriptor enumerable is same as current enumerable, check that it does not throw", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo10"; |
| var pd = { value: 0, writable: true }; // set writable to true to avoid throw code path. |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, enumerable: false, writable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 1, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test11: { |
| name: "8.12.9.8: re-define property: descriptor is not empty, generic and is different from current", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo11"; |
| var pd = { value: 0, configurable: true }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { enumerable: true }; // change enumerable to make sure that descriptor is different from current. |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 0, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| // where we are: |
| // - re-define |
| // - desc is not empty |
| // - desc and current are not the same |
| // - descriptor.IsData != current.IsData |
| |
| test12: { |
| name: "8.12.9.9.a: re-define property: descriptor.IsData != current.IsData and current is not configurable, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo12"; |
| var pd = { value: 0, configurable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { get: function () { return this.Value; } }; |
| assert.throws(function() { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test13: { |
| name: "8.12.9.9.b (variation 1): re-define property: convert from data to accessor descriptor, check that configurable/enumerable (true) are preserved", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo13"; |
| var pd = { value: 0, configurable: true, enumerable: true }; |
| Object.defineProperty(o, propertyName, pd); |
| var getter = function() { return this.Value; }; |
| pd = { get: getter }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: getter, set: undefined, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test14: { |
| name: "8.12.9.9.b (variation 2): re-define property: convert from data to accessor descriptor, check that enumerable (false) is preserved", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo14"; |
| var pd = { value: 0, configurable: true, enumerable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var getter = function () { return this.Value; }; |
| pd = { get: getter }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: getter, set: undefined, configurable: true, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test15: { |
| name: "8.12.9.9.b (variation 3): re-define property: convert from data to accessor descriptor, check that configurable/enumerable not preserved when specified by descriptor", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo15"; |
| var pd = { value: 0, configurable: true, enumerable: true }; |
| Object.defineProperty(o, propertyName, pd); |
| var getter = function () { return this.Value; }; |
| pd = { get: getter, configurable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: getter, set: undefined, configurable: false, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test16: { |
| name: "8.12.9.9.c (variation 1): re-define property: convert from accessor to data descriptor, check that configurable/enumerable (true) are preserved", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo16"; |
| var pd = { |
| set: function (arg) { helpers.writeln("setter was called"); this.Value = arg; }, |
| configurable: true, |
| enumerable: true |
| }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 1, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test17: { |
| name: "8.12.9.9.c (variation 2): re-define property: convert from accessor to data descriptor, check that enumerable (false) is preserved", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo17"; |
| var pd = { |
| set: function (arg) { helpers.writeln("setter was called"); this.Value = arg; }, |
| configurable: true, |
| enumerable: false |
| }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 1, configurable: true, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test18: { |
| name: "8.12.9.9.c (variation 3): re-define property: convert from accessor to data descriptor, check that configurable/enumerable (true/false) not preserved when specified by descriptor (false/absent)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo18"; |
| var pd = { |
| set: function (arg) { helpers.writeln("setter was called"); this.Value = arg; }, |
| configurable: true, |
| enumerable: false |
| }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, configurable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| // expected: configurable/enumerable = false/false. |
| var expected = { writable: false, value: 1, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test19: { |
| name: "8.12.9.9.c (variation 4): re-define property: convert from accessor to data descriptor, check that configurable/enumerable (true/true) not preserved when specified by descriptor (absent/false)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo19"; |
| var pd = { |
| set: function (arg) { helpers.writeln("setter was called"); this.Value = arg; }, |
| configurable: true, |
| enumerable: true |
| }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, enumerable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| // expected: configurable/enumerable = true/false. |
| var expected = { writable: false, value: 1, configurable: true, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| // where we are: |
| // - re-define |
| // - desc is not empty |
| // - desc and current are not the same |
| // - descriptor is data, current is data |
| |
| test20: { |
| name: "8.12.9.10.a (variation 1): re-define data property: current is not configurable/not writable and descriptor writable is absent/value is same", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo20"; |
| var pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 1, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test21: { |
| name: "8.12.9.10.a.i: re-define data property: current is not configurable/not writable and descriptor is writable, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo21"; |
| var pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 2, writable: true }; |
| assert.throws(function() { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| return true; |
| } |
| }, |
| |
| test22: { |
| name: "8.12.9.10.a.ii: re-define data property: current is not configurable/not writable and descriptor writable is false and value is different, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo22"; |
| var pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 2, writable: false }; |
| assert.throws(function() { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test23: { |
| name: "8.12.9.10.a (variation 2): re-define data property: current is configurable", |
| body: function () { |
| var propertyName = "foo23"; |
| var o = { foo23: 1 }; |
| var pd = { value: 2, writable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 2, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| // where we are: |
| // - re-define |
| // - desc is not empty |
| // - desc and current are not the same |
| // - descriptor is accessor, current is accessor |
| test24: { |
| name: "Test: 8.12.9.11 (variation 1): re-define accessor property: current configurable is true: valid case", |
| body: function () { |
| var propertyName = "foo24"; |
| var o = { |
| get foo24() { return this.Value; }, |
| set foo24(arg) { helpers.writeln("old setter"); this.Value = arg; } |
| }; |
| var newGetter = function() { return 2; }; |
| var newSetter = function(arg) { helpers.writeln("new setter"); } |
| var pd = { get: newGetter, set: newSetter }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: newGetter, set: newSetter, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test25: { |
| name: "8.12.9.11.a.i: re-define accessor property: current configurable is false, descriptor specifies setter as different, expect TypeError", |
| body: function () { |
| var propertyName = "foo25"; |
| var o = helpers.getDummyObject(); |
| var pd = { set: function(arg) { helpers.writeln("old setter"); this.Value = arg; } }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| pd = { set: function(arg) { helpers.writeln("new setter"); } }; |
| assert.throws(function() { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test26: { |
| name: "8.12.9.11.a.ii: re-define accessor property: current configurable is false, descriptor specifies getter as different, expect TypeError", |
| body: function () { |
| var propertyName = "foo26"; |
| var o = helpers.getDummyObject(); |
| var pd = { get: function() { return this.Value; }, }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| pd = { get: function() { helpers.writeln("new getter"); return 2; } }; |
| assert.throws(function() { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test27: { |
| name: "8.12.9.11 (variation 2): re-define accessor property: current configurable is true and no getter, descriptor specifies getter as undefined, setter as same", |
| body: function () { |
| var propertyName = "foo27"; |
| var o = helpers.getDummyObject(); |
| var setter = function(arg) { helpers.writeln("setter") }; |
| var pd = { set: setter }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| pd = { get: undefined, set: setter }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: undefined, set: setter, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test28: { |
| name: "Re-define property from data to accessor property. Make sure that setter is called when setting the value.", |
| body: function () { |
| // define a data property. |
| var propertyName = "foo28"; |
| var o = helpers.getDummyObject(); |
| var pd = { value: 1, configurable: true }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| // re-define the property to be accessor property. |
| var log = ""; |
| var getter = function() { log += "getter was called."; return this.Value; } |
| var setter = function(arg) { log += "setter was called."; this.Value = arg; }; |
| pd = { get: getter, set: setter }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| // set the value and get it. |
| var newValue = 2; |
| o[propertyName] = newValue; |
| var actualValue = o[propertyName]; |
| |
| // validate. |
| var expected = { get: getter, set: setter, configurable: true, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| assert.areEqual("setter was called.getter was called.", log, "wrong log"); |
| assert.areEqual(newValue, actualValue, "wrong value"); |
| } |
| }, |
| |
| test29: { |
| name: "Define property 'length' as accessor property on array: check that it throws TypeError.", |
| body: function () { |
| assert.throws( |
| function() { Object.defineProperty([], "length", {configurable: false, get: function() {return 2;}}); }, |
| TypeError); |
| assert.throws( |
| function() { Object.defineProperty(Array.prototype, "length", {configurable: false, get: function() {return 2;}}); }, |
| TypeError); |
| } |
| }, |
| |
| // Where we are: some tests for specific issues. |
| test30: { |
| name: "Define property with getter specified as undefined, then access the property (WOOB bug 1123281)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo30"; |
| var pd = { get: undefined }; |
| Object.defineProperty(o, propertyName, pd); |
| assert.areEqual(undefined, o[propertyName]); |
| } |
| }, |
| |
| test31: { |
| name: "Define property with setter specified as undefined, then set the property (WOOB bug 1123281)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo31"; |
| var pd = { set: undefined }; |
| Object.defineProperty(o, propertyName, pd); |
| o[propertyName] = 1; // Make sure this does not throw. |
| assert.areEqual(undefined, o[propertyName]); // Just in case try to access the property. |
| } |
| }, |
| |
| test32: { |
| name: "Convert data to accessor property with getter specified as undefined, then access the property (WOOB bug 1123281)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo32"; |
| var pd = { configurable: true, value: 0 }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| pd = { get: undefined }; |
| Object.defineProperty(o, propertyName, pd); |
| assert.areEqual(undefined, o[propertyName]); |
| } |
| }, |
| |
| test33: { |
| name: "Convert data to accessor property with setter specified as undefined, then set the property (WOOB bug 1123281)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "foo33"; |
| var pd = { configurable: true, value: 0 }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| pd = { set: undefined }; |
| Object.defineProperty(o, propertyName, pd); |
| o[propertyName] = 1; // Make sure this does not throw. |
| assert.areEqual(undefined, o[propertyName]); // Just in case try to access the property. |
| } |
| }, |
| |
| // Note: this test irreversibly changes the dummy object (that's important when dummy object is document/window), |
| // it should in the very end. |
| test34: { |
| name: "8.12.9.3: define property for non-extensible object, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| Object.preventExtensions(o); |
| var propertyName = "foo01"; |
| var pd = {}; |
| assert.throws(function() { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| //---------------------- numeric property names ------------------------------- |
| test_101: { |
| name: "8.12.9.4.a (variation 1): define generic property, check default attrbitues", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "2"; |
| var pd = {}; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: undefined, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_102: { |
| name: "8.12.9.4.a (variation 2): define data property, check default attrbitues", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "3"; |
| var pd = { value: 0 }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 0, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_103: { |
| name: "8.12.9.4.a (variation 3): define generic property by specifying some attributes, check attrbitues", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "2"; |
| var pd = { configurable: true, writable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: undefined, configurable: true, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_104: { |
| name: "8.12.9.4.b: define accessor property, check default attrbitues", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "4"; |
| var getter = function () { return this.Value }; |
| var pd = { get: getter }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: getter, set: undefined, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_105: { |
| name: "8.12.9.5: re-define property: use descriptor with all fields absent, check that nothing happens to previous descriptor", |
| body: function () { |
| var propertyName = "5"; |
| var o = { 5: 1 }; |
| var pd = {}; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: true, value: 1, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_106: { |
| name: "8.12.9.6: re-define property: use equal descriptor with data field, check that nothing happens to previous descriptor", |
| body: function () { |
| var propertyName = "6"; |
| var o = { 6: 1 }; |
| var pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: true, value: 1, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| // where we are: |
| // - re-define |
| // - desc is not empty |
| // - desc and current are not the same |
| |
| test_107: { |
| name: "8.12.9.7.a: re-define property: current descriptor is not configurable and descriptor is configurable, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "7"; |
| var pd = { value: 0, configurable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, configurable: true }; |
| assert.throws(function () { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test_108: { |
| name: "8.12.9.7.b (variation 1): re-define property: current descriptor is not configurable and descriptor enumerable is specified and it's negation of current enumerable, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "8"; |
| var pd = { value: 0 }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, enumerable: true }; |
| assert.throws(function () { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test_109: { |
| name: "8.12.9.7.b (variation 2): re-define property: current descriptor is not configurable and descriptor enumerable is not specified, check that it does not throw", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "9"; |
| var pd = { value: 0, writable: true }; // set writable to true to avoid throw code path. |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, writable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 1, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_110: { |
| name: "8.12.9.7.b (variation 3): re-define property: current descriptor is not configurable and descriptor enumerable is same as current enumerable, check that it does not throw", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "10"; |
| var pd = { value: 0, writable: true }; // set writable to true to avoid throw code path. |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, enumerable: false, writable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 1, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_111: { |
| name: "8.12.9.8: re-define property: descriptor is not empty, generic and is different from current", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "11"; |
| var pd = { value: 0, configurable: true }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { enumerable: true }; // change enumerable to make sure that descriptor is different from current. |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 0, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| // where we are: |
| // - re-define |
| // - desc is not empty |
| // - desc and current are not the same |
| // - descriptor.IsData != current.IsData |
| |
| test_112: { |
| name: "8.12.9.9.a: re-define property: descriptor.IsData != current.IsData and current is not configurable, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "12"; |
| var pd = { value: 0, configurable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { get: function () { return this.Value; } }; |
| assert.throws(function () { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test_113: { |
| name: "8.12.9.9.b (variation 1): re-define property: convert from data to accessor descriptor, check that configurable/enumerable (true) are preserved", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "13"; |
| var pd = { value: 0, configurable: true, enumerable: true }; |
| Object.defineProperty(o, propertyName, pd); |
| var getter = function () { return this.Value; }; |
| pd = { get: getter }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: getter, set: undefined, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_114: { |
| name: "8.12.9.9.b (variation 2): re-define property: convert from data to accessor descriptor, check that enumerable (false) is preserved", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "14"; |
| var pd = { value: 0, configurable: true, enumerable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var getter = function () { return this.Value; }; |
| pd = { get: getter }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: getter, set: undefined, configurable: true, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_115: { |
| name: "8.12.9.9.b (variation 3): re-define property: convert from data to accessor descriptor, check that configurable/enumerable not preserved when specified by descriptor", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "15"; |
| var pd = { value: 0, configurable: true, enumerable: true }; |
| Object.defineProperty(o, propertyName, pd); |
| var getter = function () { return this.Value; }; |
| pd = { get: getter, configurable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: getter, set: undefined, configurable: false, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_116: { |
| name: "8.12.9.9.c (variation 1): re-define property: convert from accessor to data descriptor, check that configurable/enumerable (true) are preserved", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "16"; |
| var pd = { |
| set: function (arg) { helpers.writeln("setter was called"); this.Value = arg; }, |
| configurable: true, |
| enumerable: true |
| }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 1, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_117: { |
| name: "8.12.9.9.c (variation 2): re-define property: convert from accessor to data descriptor, check that enumerable (false) is preserved", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "17"; |
| var pd = { |
| set: function (arg) { helpers.writeln("setter was called"); this.Value = arg; }, |
| configurable: true, |
| enumerable: false |
| }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 1, configurable: true, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_118: { |
| name: "8.12.9.9.c (variation 3): re-define property: convert from accessor to data descriptor, check that configurable/enumerable (true/false) not preserved when specified by descriptor (false/absent)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "18"; |
| var pd = { |
| set: function (arg) { helpers.writeln("setter was called"); this.Value = arg; }, |
| configurable: true, |
| enumerable: false |
| }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, configurable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| // expected: configurable/enumerable = false/false. |
| var expected = { writable: false, value: 1, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_119: { |
| name: "8.12.9.9.c (variation 4): re-define property: convert from accessor to data descriptor, check that configurable/enumerable (true/true) not preserved when specified by descriptor (absent/false)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "19"; |
| var pd = { |
| set: function (arg) { helpers.writeln("setter was called"); this.Value = arg; }, |
| configurable: true, |
| enumerable: true |
| }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1, enumerable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| // expected: configurable/enumerable = true/false. |
| var expected = { writable: false, value: 1, configurable: true, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| // where we are: |
| // - re-define |
| // - desc is not empty |
| // - desc and current are not the same |
| // - descriptor is data, current is data |
| |
| test_120: { |
| name: "8.12.9.10.a (variation 1): re-define data property: current is not configurable/not writable and descriptor writable is absent/value is same", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "20"; |
| var pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 1, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_121: { |
| name: "8.12.9.10.a.i: re-define data property: current is not configurable/not writable and descriptor is writable, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "21"; |
| var pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 2, writable: true }; |
| assert.throws(function () { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| return true; |
| } |
| }, |
| |
| test_122: { |
| name: "8.12.9.10.a.ii: re-define data property: current is not configurable/not writable and descriptor writable is false and value is different, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "22"; |
| var pd = { value: 1 }; |
| Object.defineProperty(o, propertyName, pd); |
| pd = { value: 2, writable: false }; |
| assert.throws(function () { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test_123: { |
| name: "8.12.9.10.a (variation 2): re-define data property: current is configurable", |
| body: function () { |
| var propertyName = "23"; |
| var o = { 23: 1 }; |
| var pd = { value: 2, writable: false }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { writable: false, value: 2, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| // where we are: |
| // - re-define |
| // - desc is not empty |
| // - desc and current are not the same |
| // - descriptor is accessor, current is accessor |
| |
| test_124: { |
| name: "Test: 8.12.9.11 (variation 1): re-define accessor property: current configurable is true: valid case", |
| body: function () { |
| var propertyName = "24"; |
| var o = { |
| get 24() { return this.Value; }, |
| set 24(arg) { helpers.writeln("old setter"); this.Value = arg; } |
| }; |
| var newGetter = function() { return 2; }; |
| var newSetter = function(arg) { helpers.writeln("new setter"); } |
| var pd = { get: newGetter, set: newSetter }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: newGetter, set: newSetter, configurable: true, enumerable: true }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_125: { |
| name: "8.12.9.11.a.i: re-define accessor property: current configurable is false, descriptor specifies setter as different, expect TypeError", |
| body: function () { |
| var propertyName = "25"; |
| var o = helpers.getDummyObject(); |
| var pd = { set: function (arg) { helpers.writeln("old setter"); this.Value = arg; } }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| pd = { set: function (arg) { helpers.writeln("new setter"); } }; |
| assert.throws(function () { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test_126: { |
| name: "8.12.9.11.a.ii: re-define accessor property: current configurable is false, descriptor specifies getter as different, expect TypeError", |
| body: function () { |
| var propertyName = "26"; |
| var o = helpers.getDummyObject(); |
| var pd = { get: function () { return this.Value; } }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| pd = { get: function () { helpers.writeln("new getter"); return 2; } }; |
| assert.throws(function () { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| test_127: { |
| name: "8.12.9.11 (variation 2): re-define accessor property: current configurable is true and no getter, descriptor specifies getter as undefined, setter as same", |
| body: function () { |
| var propertyName = "27"; |
| var o = helpers.getDummyObject(); |
| var setter = function (arg) { helpers.writeln("setter") }; |
| var pd = { set: setter }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| pd = { get: undefined, set: setter }; |
| Object.defineProperty(o, propertyName, pd); |
| var expected = { get: undefined, set: setter, configurable: false, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| } |
| }, |
| |
| test_128: { |
| name: "Re-define property from data to accessor property. Make sure that setter is called when setting the value.", |
| body: function () { |
| // define a data property. |
| var propertyName = "28"; |
| var o = helpers.getDummyObject(); |
| var pd = { value: 1, configurable: true }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| // re-define the property to be accessor property. |
| var log = ""; |
| var getter = function () { log += "getter was called."; return this.Value; } |
| var setter = function (arg) { log += "setter was called."; this.Value = arg; }; |
| pd = { get: getter, set: setter }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| // set the value and get it. |
| var newValue = 2; |
| o[propertyName] = newValue; |
| var actualValue = o[propertyName]; |
| |
| // validate. |
| var expected = { get: getter, set: setter, configurable: true, enumerable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| assert.areEqual("setter was called.getter was called.", log, "wrong log"); |
| assert.areEqual(newValue, actualValue, "wrong value"); |
| } |
| }, |
| |
| test_129: { |
| name: "Define property 'length' as accessor property on array: check that it throws TypeError.", |
| body: function () { |
| assert.throws( |
| function () { Object.defineProperty([], "length", { configurable: false, get: function () { return 2; } }); }, |
| TypeError); |
| assert.throws( |
| function () { Object.defineProperty(Array.prototype, "length", { configurable: false, get: function () { return 2; } }); }, |
| TypeError); |
| } |
| }, |
| |
| // Where we are: some tests for specific issues. |
| test_130: { |
| name: "Define property with getter specified as undefined, then access the property (WOOB bug 1123281)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "30"; |
| var pd = { get: undefined }; |
| Object.defineProperty(o, propertyName, pd); |
| assert.areEqual(undefined, o[propertyName]); |
| } |
| }, |
| |
| test_131: { |
| name: "Define property with setter specified as undefined, then set the property (WOOB bug 1123281)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "31"; |
| var pd = { set: undefined }; |
| Object.defineProperty(o, propertyName, pd); |
| o[propertyName] = 1; // Make sure this does not throw. |
| assert.areEqual(undefined, o[propertyName]); // Just in case try to access the property. |
| } |
| }, |
| |
| test_132: { |
| name: "Convert data to accessor property with getter specified as undefined, then access the property (WOOB bug 1123281)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "32"; |
| var pd = { configurable: true, value: 0 }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| pd = { get: undefined }; |
| Object.defineProperty(o, propertyName, pd); |
| assert.areEqual(undefined, o[propertyName]); |
| } |
| }, |
| |
| test_133: { |
| name: "Convert data to accessor property with setter specified as undefined, then set the property (WOOB bug 1123281)", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "33"; |
| var pd = { configurable: true, value: 0 }; |
| Object.defineProperty(o, propertyName, pd); |
| |
| pd = { set: undefined }; |
| Object.defineProperty(o, propertyName, pd); |
| o[propertyName] = 1; // Make sure this does not throw. |
| assert.areEqual(undefined, o[propertyName]); // Just in case try to access the property. |
| } |
| }, |
| |
| // Note: this test irreversibly changes the dummy object (that's important when dummy object is document/window), |
| // it should in the very end. |
| test_134: { |
| name: "8.12.9.3: define property for non-extensible object, check that it throws TypeError", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| Object.preventExtensions(o); |
| var propertyName = "1"; |
| var pd = {}; |
| assert.throws(function () { Object.defineProperty(o, propertyName, pd); }, TypeError); |
| } |
| }, |
| |
| // --------------------- misc adhoc tests ------------------------------------- |
| test_301: { |
| name: "set property whose writable is false", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| var propName = 17; |
| o[propName] = 100; |
| Object.defineProperty(o, propName, {writable: false}); |
| o[propName] = 200; // should have no effect |
| assert.areEqual(100, o[propName]); |
| } |
| }, |
| |
| test_302: { |
| name: "delete index property", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| var propName = 123; |
| |
| assert.areEqual(true, delete o[1], "delete non-exist property should return true"); |
| |
| o[propName] = 123; |
| assert.areEqual(true, delete o[propName], "delete this property should return true"); |
| assert.areEqual(undefined, o[propName], "deleted property value should become undefined"); |
| |
| Object.defineProperty(o, propName, {get:function(){return 123;}, configurable: true}); |
| assert.areEqual(123, o[propName], "Property value should be from getter"); |
| assert.areEqual(true, delete o[propName], "delete this property should return true"); |
| assert.areEqual(undefined, o[propName], "deleted property value should become undefined"); |
| |
| Object.defineProperty(o, propName, {value: 123, configurable: false}); |
| assert.areEqual(123, o[propName], "Property value should be the value"); |
| assert.areEqual(false, delete o[propName], "delete this property should return false, not configurable"); |
| assert.areEqual(123, o[propName], "Property value should not be changed"); |
| } |
| }, |
| |
| test_303: { |
| name: "delete a data property then set", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| var propName = 303; |
| Object.defineProperty(o, propName, { |
| value: 100, |
| configurable: true |
| }); |
| assert.areEqual(delete o[propName], true, "delete should succeed on configurable data property"); |
| o[propName] = 200; |
| assert.areEqual(200, o[propName]); |
| } |
| }, |
| test_304: { |
| name: "delete a getter property then set", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| var propName = 303; |
| Object.defineProperty(o, propName, { |
| get: function() { return 100; }, |
| configurable: true |
| }); |
| assert.areEqual(true, delete o[propName], "delete should succeed on configurable accessor property"); |
| o[propName] = 200; |
| assert.areEqual(200, o[propName]); |
| } |
| }, |
| test_305: { |
| name: "delete a setter property then set", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| var propName = 303; |
| Object.defineProperty(o, propName, { |
| set: function(arg) { return 100; }, |
| configurable: true |
| }); |
| assert.areEqual(true, delete o[propName], "delete should succeed on configurable accessor property"); |
| o[propName] = 200; |
| assert.areEqual(200, o[propName]); |
| } |
| }, |
| |
| test_306: { |
| name: "Set a property while prototype has a getter", |
| body: function() { |
| var propName = "abc"; |
| try { |
| Object.defineProperty(Object.prototype, propName, { |
| get: function () { return 100; }, |
| configurable: true |
| }); |
| |
| var o = helpers.getDummyObject(); |
| o[propName] = 200; // should have no effect since proto only has a getter |
| assert.areEqual(100, o[propName]); |
| } finally { |
| delete Object.prototype[propName]; |
| } |
| } |
| }, |
| test_306_i: { |
| name: "Set a property while prototype has a getter", |
| body: function() { |
| var propName = "306"; // Without quote it fails on array. Covered by 310_i |
| try { |
| Object.defineProperty(Object.prototype, propName, { |
| get: function () { return 100; }, |
| configurable: true |
| }); |
| |
| var o = helpers.getDummyObject(); |
| o[propName] = 200; // should have no effect since proto only has a getter |
| assert.areEqual(100, o[propName]); |
| } finally { |
| delete Object.prototype[propName]; |
| } |
| } |
| }, |
| |
| test_307: { |
| name: "Define a property while prototype has a getter", |
| body: function() { |
| var propName = "abc"; |
| try { |
| Object.defineProperty(Object.prototype, propName, { |
| get: function () { return 100; }, |
| configurable: true |
| }); |
| |
| var o = helpers.getDummyObject(); |
| Object.defineProperty(o, propName, { value: 200 }); |
| assert.areEqual(200, o[propName]); //DefineOwnProperty succeeds |
| } finally { |
| delete Object.prototype[propName]; |
| } |
| } |
| }, |
| test_307_i: { |
| name: "Define a property while prototype has a getter", |
| body: function() { |
| var propName = 307; |
| try { |
| Object.defineProperty(Object.prototype, propName, { |
| get: function () { return 100; }, |
| configurable: true |
| }); |
| |
| var o = helpers.getDummyObject(); |
| Object.defineProperty(o, propName, { value: 200 }); |
| assert.areEqual(200, o[propName]); //DefineOwnProperty succeeds |
| } finally { |
| delete Object.prototype[propName]; |
| } |
| } |
| }, |
| |
| test_308: { |
| disabled: true, // !!! Disable due to bug (to be opened) causing assertion !!! |
| pass: "misc", |
| name: "Set a property via object literal while prototype has a getter", |
| body: function() { |
| var propName = "abc"; |
| try { |
| Object.defineProperty(Object.prototype, propName, { |
| get: function () { return 100; }, |
| configurable: true |
| }); |
| |
| var o = {abc: 200}; |
| assert.areEqual(100, o[propName]); |
| } finally { |
| delete Object.prototype[propName]; |
| } |
| } |
| }, |
| test_308_i: { |
| pass: "misc", |
| name: "Set a property via object literal while prototype has a getter", |
| body: function() { |
| var propName = 308; |
| try { |
| Object.defineProperty(Object.prototype, propName, { |
| get: function () { return 100; }, |
| configurable: true |
| }); |
| |
| var o = {308: 200}; // succeeds since object literals do not check prototypes |
| assert.areEqual(200, o[propName]); |
| } finally { |
| delete Object.prototype[propName]; |
| } |
| } |
| }, |
| |
| test_309_i: { |
| disabled: true, // !!! Disabled, Array doesn't honor prototype element attribute/getter/setter !!! |
| pass: "misc", |
| name: "Set a property while prototype property is not writable", |
| body: function() { |
| try { |
| Object.defineProperty(Object.prototype, 1, { |
| value: 100, |
| writable: false, |
| configurable: true |
| }); |
| |
| var o = []; |
| assert.areEqual(100, o[1]); |
| o[1] = 200; // should have no effect since proto[1] is not writable |
| assert.areEqual(100, o[1]); |
| } finally { |
| delete Object.prototype[1]; |
| } |
| } |
| }, |
| |
| test_310_i: { |
| disabled: true, // !!! Disabled, Array doesn't honor prototype element attribute/getter/setter !!! |
| pass: "misc", |
| name: "Set a property while prototype property is a getter", |
| body: function() { |
| try { |
| Object.defineProperty(Object.prototype, 1, { |
| get: function () { return 100; }, |
| configurable: true |
| }); |
| |
| var o = []; |
| assert.areEqual(100, o[1]); |
| o[1] = 200; // should have no effect since proto[1] has only getter |
| assert.areEqual(100, o[1]); |
| } finally { |
| delete Object.prototype[1]; |
| } |
| } |
| }, |
| |
| test_311_i: { |
| disabled: true, // !!! Disabled, Array doesn't honor prototype element attribute/getter/setter !!! |
| pass: "misc", |
| name: "Set a property while prototype property is getter/setter", |
| body: function() { |
| try { |
| var tmp = 100; |
| Object.defineProperty(Object.prototype, 1, { |
| get: function () { return tmp; }, |
| set: function(arg) { tmp = arg + 300; }, |
| configurable: true |
| }); |
| |
| var o = []; |
| assert.areEqual(100, o[1]); |
| o[1] = 200; // should call setter |
| assert.areEqual(500, o[1]); |
| } finally { |
| delete Object.prototype[1]; |
| } |
| } |
| }, |
| |
| test_312_i: { |
| name: "Test getter/setter on prototype receives the right this arg", |
| body: function() { |
| try { |
| var propName = "1"; //avoid array fast path for now |
| Object.prototype.tmp = 123; |
| Object.defineProperty(Object.prototype, propName, { |
| get: function () { return this.tmp; }, |
| set: function (arg) { this.tmp = arg + 300; }, |
| configurable: true |
| }); |
| |
| var o = helpers.getDummyObject(); |
| assert.areEqual(123, o[propName], "Should read data on prototype"); |
| o[propName] = 200; // should call proto setter on o |
| assert.areEqual(500, o.tmp, "setter should set data on o"); |
| assert.areEqual(500, o[propName], "Should read data on o"); |
| assert.areEqual(123, Object.prototype.tmp, "proto data unchanged"); |
| } finally { |
| delete Object.prototype[propName]; |
| delete Object.prototype.tmp; |
| } |
| } |
| }, |
| test_312a_i: { |
| name: "Test getter on prototype receives the right this arg", |
| body: function() { |
| try { |
| var propName = "1"; //avoid array fast path for now |
| Object.prototype.tmp = 123; |
| Object.defineProperty(Object.prototype, propName, { |
| get: function () { return this.tmp; }, |
| configurable: true |
| }); |
| |
| var o = helpers.getDummyObject(); |
| o.length = 10; // Makes propName in length range, also prepare for indexOf |
| assert.areEqual(123, o[propName], "Should read data on prototype"); |
| o.tmp = 456; |
| assert.areEqual(456, o[propName], "Should read data on o"); |
| var i = Array.prototype.indexOf.apply(o, [456]); |
| assert.areEqual(propName, i.toString(), "getter should find data on o, not on prototype!"); |
| } finally { |
| delete Object.prototype[propName]; |
| delete Object.prototype.tmp; |
| } |
| } |
| }, |
| |
| test_313_i: { |
| name: "preventExtensions with index property", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| o[1] = 1; |
| assert.areEqual(1, o[1]); |
| assert.areEqual(true, Object.isExtensible(o), "default is extensible"); |
| assert.areEqual(false, Object.isSealed(o), "default not sealed"); |
| assert.areEqual(false, Object.isFrozen(o), "default not frozen"); |
| |
| Object.preventExtensions(o); |
| assert.areEqual(false, Object.isExtensible(o), "now NOT extensible"); |
| assert.areEqual(false, Object.isSealed(o), "still not sealed, o[1] configurable"); |
| assert.areEqual(false, Object.isFrozen(o), "still not frozen, o[1] configurable"); |
| |
| o[1] = 11; // should succeed |
| assert.areEqual(11, o[1], "write should succeed"); |
| o[2] = 2; // should fail |
| assert.areEqual(undefined, o[2], "extend should fail"); |
| |
| // verify unchanged |
| assert.areEqual(false, Object.isExtensible(o), "extensible not changed"); |
| assert.areEqual(false, Object.isSealed(o), "sealed not changed"); |
| assert.areEqual(false, Object.isFrozen(o), "frozen not changed"); |
| } |
| }, |
| test_314_i: { |
| name: "seal with index property", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| o[1] = 1; |
| |
| Object.seal(o); |
| assert.areEqual(false, Object.isExtensible(o), "now NOT extensible"); |
| assert.areEqual(true, Object.isSealed(o), "now IS sealed"); |
| assert.areEqual(false, Object.isFrozen(o), "still not frozen, o[1] writable"); |
| |
| o[1] = 11; // should succeed |
| assert.areEqual(11, o[1], "write should succeed"); |
| assert.areEqual(false, delete o[1], "delete should fail, object sealed"); |
| assert.areEqual(11, o[1], "delete should fail"); |
| o[2] = 2; // should fail |
| assert.areEqual(undefined, o[2], "extend should fail"); |
| |
| // verify unchanged |
| assert.areEqual(false, Object.isExtensible(o), "extensible not changed"); |
| assert.areEqual(true, Object.isSealed(o), "sealed not changed"); |
| assert.areEqual(false, Object.isFrozen(o), "frozen not changed"); |
| } |
| }, |
| test_315_i: { |
| name: "freeze with index property", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| o[1] = 1; |
| |
| Object.freeze(o); |
| assert.areEqual(false, Object.isExtensible(o), "now NOT extensible"); |
| assert.areEqual(true, Object.isSealed(o), "now IS sealed"); |
| assert.areEqual(true, Object.isFrozen(o), "now IS frozen"); |
| |
| o[1] = 11; // should fail |
| assert.areEqual(1, o[1], "write should fail"); |
| assert.areEqual(false, delete o[1], "delete should fail, object sealed"); |
| assert.areEqual(1, o[1], "delete should fail"); |
| o[2] = 2; // should fail |
| assert.areEqual(undefined, o[2], "extend should fail"); |
| |
| // verify unchanged |
| assert.areEqual(false, Object.isExtensible(o), "extensible not changed"); |
| assert.areEqual(true, Object.isSealed(o), "sealed not changed"); |
| assert.areEqual(true, Object.isFrozen(o), "frozen not changed"); |
| } |
| }, |
| |
| test_316_i: { |
| name: "preventExtensions on empty object -> isSealed and isFrozen", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| Object.preventExtensions(o); // Haven't set any item yet, objectArray is null |
| assert.areEqual(false, Object.isExtensible(o), "NOT extensible"); |
| assert.areEqual(true, Object.isSealed(o), "IS sealed"); |
| assert.areEqual(true, Object.isFrozen(o) || Array.isArray(o), "IS frozen, unless isArray (length writable)"); |
| |
| o[1] = 11; |
| assert.areEqual(undefined, o[1], "Write failed, not extensible"); |
| } |
| }, |
| test_317_i: { |
| name: "preventExtensions on object with an accessor -> isSealed and isFrozen", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| var propName = 123; |
| Object.defineProperty(o, propName, {get: function(){ return "123"; }, configurable: false}); |
| Object.preventExtensions(o); |
| assert.areEqual(false, Object.isExtensible(o), "NOT extensible"); |
| assert.areEqual(true, Object.isSealed(o), "IS sealed"); |
| assert.areEqual(true, Object.isFrozen(o) || Array.isArray(o), "IS frozen, unless isArray (length writable)"); |
| |
| o[1] = 11; |
| assert.areEqual(undefined, o[1], "Write failed, not extensible"); |
| assert.areEqual(false, delete o[propName], "delete should fail, not configurable"); |
| assert.areEqual("123", o[propName], "delete failed, not configurable"); |
| } |
| }, |
| test_318_i: { |
| name: "preventExtensions on object with data -> isSealed and isFrozen", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| var propName = 123; |
| Object.defineProperty(o, propName, {value: 456, configurable: false, writable: true}); |
| Object.preventExtensions(o); |
| assert.areEqual(false, Object.isExtensible(o), "NOT extensible"); |
| assert.areEqual(true, Object.isSealed(o), "IS sealed"); |
| assert.areEqual(false, Object.isFrozen(o), "NOT frozen, data writable"); |
| } |
| }, |
| test_319_i: { |
| name: "preventExtensions on object with data -> isSealed and isFrozen", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| var propName = 123; |
| Object.defineProperty(o, propName, {value: 456, configurable: false, writable: false}); |
| Object.preventExtensions(o); |
| assert.areEqual(false, Object.isExtensible(o), "NOT extensible"); |
| assert.areEqual(true, Object.isSealed(o), "IS sealed"); |
| assert.areEqual(true, Object.isFrozen(o) || Array.isArray(o), "IS frozen, unless isArray (length writable)"); |
| } |
| }, |
| test_320_i: { |
| name: "preventExtensions on object with data -> isSealed and isFrozen", |
| body: function() { |
| var o = helpers.getDummyObject(); |
| var propName = 123; |
| Object.defineProperty(o, propName, {value: 456, configurable: false, writable: false}); |
| o[234] = 345; |
| Object.preventExtensions(o); |
| assert.areEqual(false, Object.isExtensible(o), "NOT extensible"); |
| assert.areEqual(false, Object.isSealed(o), "NOT sealed, 234 configurable"); |
| assert.areEqual(false, Object.isFrozen(o), "NOT frozen, 234 configurable/writable"); |
| } |
| }, |
| |
| test_321_i: { |
| name: "Test prototype value is used in sort", |
| body: function() { |
| try { |
| var propName = 1; |
| Object.defineProperty(Array.prototype, propName, { |
| value: 321, |
| writable: true, configurable: true, enumerable: true |
| }); |
| |
| var o = helpers.getDummyObject(); |
| o[0] = 10; |
| o.length = 3; |
| o.sort = Array.prototype.sort; |
| o.join = Array.prototype.join; |
| o.toString = Array.prototype.toString; |
| |
| o.sort(); |
| assert.areEqual("10,321,", o.toString(), "sort result mismatch?"); |
| } finally { |
| delete Array.prototype[propName]; |
| } |
| } |
| }, |
| |
| test_322_i: { |
| name: "Convert accessor to a data property for non-extensible object (WIN8 bug 463559) but for numeric property", |
| body: function () { |
| var o = helpers.getDummyObject(); |
| var propertyName = "1"; |
| |
| Object.defineProperty(o, propertyName, { |
| get: function() { return 0; }, |
| set: function(val) { helpers.writeln("setter was called although it shouldn't"); }, |
| configurable: true |
| }); |
| Object.preventExtensions(o); |
| var val = 1; |
| Object.defineProperty(o, propertyName, { value: val, }); |
| |
| var expected = { value: val, configurable: true, enumerable: false, writable: false }; |
| assert.areEqual(expected, Object.getOwnPropertyDescriptor(o, propertyName), "wrong value of getOwnPropertyDescriptor"); |
| assert.areEqual(val, o[propertyName], "the property value is wrong"); |
| assert.areEqual(false, Object.isExtensible(o), "isExtensible() changed"); |
| } |
| }, |
| }; // tests. |
| |
| var passes = { |
| pass1: { |
| name: "obj", |
| prep: function() { |
| helpers.getDummyObject = function() { |
| return {}; // a normal object |
| }; |
| } |
| }, |
| |
| pass2: { |
| name: "arr", |
| prep: function() { |
| helpers.getDummyObject = function() { |
| return []; // a normal array |
| }; |
| } |
| }, |
| |
| pass3: { |
| name: "es5arr", |
| prep: function() { |
| helpers.getDummyObject = function() { |
| var arr = []; |
| Object.defineProperty(arr, "12345", { |
| get: function() { |
| helpers.writeln("dummy called"); |
| }, |
| configurable: true |
| }); |
| delete arr[12345]; |
| return arr; // an ES5 array |
| }; |
| } |
| }, |
| |
| pass4: { |
| name: "misc", |
| runonce: true, // Run misc tests only once |
| prep: function() { |
| helpers.getDummyObject = function() { |
| return null; // Misc tests do not use helpers.getDummyObject |
| }; |
| } |
| } |
| |
| }; |
| |
| testRunner.runTests(passes, tests); |
