Attachment #8462804 for bug #937855

Attachment #8462804: assign_test_edited_plus_mult_test.patch for bug #937855

View | Details | Raw Unified | Return to bug 937855
Collapse All | Expand All

-      Line
+  Link Here
-      Line 0
+  Link Here
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+function ToObject(o) {
+    if (o == null) throw new TypeError();
+    return Object(o);
+}
+/* 19.1.2.1  Object.assign ( target, ...sources ) */
+assertBuiltinFunction(Object.assign, "assign", 2);
+// Basic functionality works with multiple sources
+{
+    var a = {};
+    var b = { bProp : 7 };
+    var c = { cProp : 8 };
+    Object.assign(a, b, c);
+    assertSame(7, a.bProp);
+    assertSame(8, a.cProp);
+}
+// Calls ToObject() for target and source
+{
+    assertThrows(() => Object.assign(null, null), TypeError);
+    assertThrows(() => Object.assign(null, {}), TypeError);
+    assertThrows(() => Object.assign({}, null), TypeError);
+    assertInstanceOf(Boolean, Object.assign(true, {}));
+    assertInstanceOf(Number, Object.assign(1, {}));
+    assertInstanceOf(String, Object.assign("string", {}));
+    let o = {};
+    assertSame(o, Object.assign(o, {}));
+}
+// Invokes [[OwnPropertyKeys]] on ToObject(source)
+{
+    assertThrows(() => Object.assign(null, new Proxy({}, {
+        getOwnPropertyNames: () => fail("ToObject(target) succeeded")
+    })), TypeError);
+    let ownKeysCalled = false;
+    Object.assign({}, new Proxy({}, {
+        ownKeys: function() {
+            ownKeysCalled = true;
+            return [];
+        }
+    }));
+    var thing = new Proxy({}, {
+        ownKeys: function(target) {
+            ownKeysCalled = true;
+            return [];
+        }
+    });
+    assertTrue(ownKeysCalled);
+}
+// Ensure correct property traversal
+{
+    let log = "";
+    let source = new Proxy({a: 1, b: 2}, {
+        ownKeys: () => ["b", "c", "a"],
+        getOwnPropertyDescriptor: function(t, pk) {
+            log += "#" + pk;
+            return Object.getOwnPropertyDescriptor(t, pk);
+        },
+        get: function(t, pk, r) {
+            log += "-" + pk;
+            return t[pk];
+        },
+    });
+    Object.assign({}, source);
+    assertSame("#b-b#c#a-a", log);
+}
+// Only [[Enumerable]] properties are assigned to target
+{
+    let source = Object.defineProperties({}, {
+        a: {value: 1, enumerable: true},
+        b: {value: 2, enumerable: false},
+    });
+    let target = Object.assign({}, source);
+    assertTrue("a" in target);
+    assertFalse("b" in target);
+}
+// Enumerability is decided on-time, not before main loop (1)
+{
+    let getterCalled = false;
+    // FIXME: sourceTarget should not be necessary, Proxy bug in SpiderMonkey
+    let sourceTarget;
+    let source = new Proxy(sourceTarget = {
+        get a() { getterCalled = true },
+        get b() { Object.defineProperty(sourceTarget /* this */, "a", {enumerable: false}) },
+    }, {
+        ownKeys: () => ["b", "a"]
+    });
+    Object.assign({}, source);
+    assertFalse(getterCalled);
+}
+// Enumerability is decided on-time, not before main loop (2)
+{
+    let getterCalled = false;
+    // FIXME: sourceTarget should not be necessary, Proxy bug in SpiderMonkey
+    let sourceTarget;
+    let source = new Proxy(sourceTarget = {
+        get a() { getterCalled = true },
+        get b() { Object.defineProperty(sourceTarget /* this */, "a", {enumerable: true}) },
+    }, {
+        ownKeys: () => ["b", "a"]
+    });
+    Object.defineProperty(sourceTarget /* source */, "a", {enumerable: false});
+    Object.assign({}, source);
+    assertTrue(getterCalled);
+}
+// Properties are retrieved through Get()
+{
+    let getterCalled = false;
+    Object.assign({}, {get a() { getterCalled = true }});
+    assertTrue(getterCalled);
+}
+// Properties are retrieved through Get()
+// Properties are assigned through Put()
+{
+    let setterCalled = false;
+    Object.assign({set a(v) { setterCalled = v }}, {a: true});
+    assertTrue(setterCalled);
+}
+// Properties are retrieved through Get()
+// Properties are assigned through Put(): Existing property attributes are not altered
+{
+    let source = {a: 1, b: 2, c: 3};
+    let target = {a: 0, b: 0, c: 0};
+    Object.defineProperty(target, "a", {enumerable: false});
+    Object.defineProperty(target, "b", {configurable: false});
+    Object.defineProperty(target, "c", {enumerable: false, configurable: false});
+    Object.assign(target, source);
+    assertDataProperty(target, "a", {value: 1, writable: true, enumerable: false, configurable: true});
+    assertDataProperty(target, "b", {value: 2, writable: true, enumerable: true, configurable: false});
+    assertDataProperty(target, "c", {value: 3, writable: true, enumerable: false, configurable: false});
+}
+// Properties are retrieved through Get()
+// Properties are assigned through Put(): Throws TypeError if non-writable
+{
+    let source = {a: 1};
+    let target = {a: 0};
+    Object.defineProperty(target, "a", {writable: false});
+    assertThrows(() => Object.assign(target, source), TypeError);
+    assertDataProperty(target, "a", {value: 0, writable: false, enumerable: true, configurable: true});
+}
+// Properties are retrieved through Get()
+// Put() creates standard properties; Property attributes from source are ignored
+{
+    let source = {a: 1, b: 2, c: 3, get d() { return 4 }};
+    Object.defineProperty(source, "b", {writable: false});
+    Object.defineProperty(source, "c", {configurable: false});
+    let target = Object.assign({}, source);
+    assertDataProperty(target, "a", {value: 1, writable: true, enumerable: true, configurable: true});
+    assertDataProperty(target, "b", {value: 2, writable: true, enumerable: true, configurable: true});
+    assertDataProperty(target, "c", {value: 3, writable: true, enumerable: true, configurable: true});
+    assertDataProperty(target, "d", {value: 4, writable: true, enumerable: true, configurable: true});
+}
+// Properties created during traversal are not copied
+{
+    let source = {get a() { this.b = 2 }};
+    let target = Object.assign({}, source);
+    assertTrue("a" in target);
+    assertFalse("b" in target);
+}
+// Properties created during traversal are copied - Proxy edition
+// FIXME: requires [[OwnKeys]] to be an Iterable
+if (false) {
+    let hasB = false;
+    let source = new Proxy({
+        get a() { hasB = "b" in this },
+    }, {
+        getOwnPropertyNames: () => function*() {
+            yield "a";
+            source.b = 2;
+            yield "b";
+        }()
+    });
+    let target = Object.assign({}, source);
+    assertTrue("a" in target);
+    assertTrue("b" in target);
+    assertFalse(hasB);
+}
+// Properties deleted during traversal are not copied
+{
+    let source = new Proxy({
+        get a() { delete this.b },
+        b: 2,
+    }, {
+        getOwnPropertyNames: () => ["a", "b"]
+    });
+    let target = Object.assign({}, source);
+    assertTrue("a" in target);
+    assertFalse("b" in target);
+}
+// Properties first deleted and then recreated during traversal are copied (1)
+{
+    let source = new Proxy({
+        get a() { delete this.c },
+        get b() { this.c = 4 },
+        c: 3,
+    }, {
+        getOwnPropertyNames: () => ["a", "b", "c"]
+    });
+    let target = Object.assign({}, source);
+    assertTrue("a" in target);
+    assertTrue("b" in target);
+    assertTrue("c" in target);
+    assertDataProperty(target, "c", {value: 4, writable: true, enumerable: true, configurable: true});
+}
+// Properties first deleted and then recreated during traversal are copied (2)
+{
+    let source = new Proxy({
+        get a() { delete this.c },
+        get b() { this.c = 4 },
+        c: 3,
+    }, {
+        ownKeys: () => ["a", "c", "b"]
+    });
+    let target = Object.assign({}, source);
+    assertTrue("a" in target);
+    assertTrue("b" in target);
+    assertFalse("c" in target);
+}
+// String and Symbol valued properties are copied
+{
+    let keyA = "str-prop";
+    let source = {"str-prop": 1};
+    let target = Object.assign({}, source);
+    assertDataProperty(target, keyA, {value: 1, writable: true, enumerable: true, configurable: true});
+}
+// Intermediate exceptions do not stop property traversal, first exception is reported (1)
+{
+    let ErrorA = function ErrorA() {};
+    let ErrorB = function ErrorB() {};
+    let log = "";
+    let source = new Proxy({}, {
+        getOwnPropertyDescriptor: function(t, pk) {
+            log += pk;
+            throw new (pk === "a" ? ErrorA : ErrorB);
+        },
+        ownKeys: () => ["b", "a"]
+    });
+    assertThrows(() => Object.assign({}, source), ErrorB);
+    assertSame("ba", log);
+}
+// Properties are retrieved through Get()
+// Intermediate exceptions do not stop property traversal, first exception is reported (2)
+{
+    let ErrorA = function ErrorA() {};
+    let ErrorB = function ErrorB() {};
+    let log = "";
+    let source = new Proxy({
+        get a() { log += "a"; throw new ErrorA },
+        get b() { log += "b"; throw new ErrorB },
+    }, {
+        ownKeys: () => ["b", "a"]
+    });
+    assertThrows(() => Object.assign({}, source), ErrorB);
+    assertSame("ba", log);
+}
+// Intermediate exceptions do not stop property traversal, first exception is reported (3)
+{
+    let ErrorA = function ErrorA() {};
+    let ErrorB = function ErrorB() {};
+    let log = "";
+    let source = new Proxy({a: 1, b: 2}, {
+        ownKeys: () => ["b", "a"]
+    });
+    let target = {
+        set a(v) { log += "a"; throw new ErrorA },
+        set b(v) { log += "b"; throw new ErrorB },
+    };
+    assertThrows(() => Object.assign(target, source), ErrorB);
+    assertSame("ba", log);
+}
+// Intermediate exceptions do not stop property traversal, first exception is reported (4)
+{
+    let ErrorGetOwnProperty = function ErrorGetOwnProperty() {};
+    let ErrorGet = function ErrorGet() {};
+    let ErrorSet = function ErrorSet() {};
+    let source = new Proxy({
+        get a() { throw new ErrorGet }
+    }, {
+        getOwnPropertyDescriptor: function(t, pk) {
+            throw new ErrorGetOwnProperty;
+        }
+    });
+    let target = {
+        set a(v) { throw new ErrorSet }
+    };
+    assertThrows(() => Object.assign({}, source), ErrorGetOwnProperty);
+}
+// Exceptions in Iterator directly stop property traversal (1)
+// FIXME: requires [[OwnKeys]] to be an Iterable
+if (false) {
+    let ErrorNext = function ErrorNext() {};
+    let getterCalled = false;
+    let source = new Proxy({
+        get a() { getterCalled = true }
+    }, {
+        getOwnPropertyNames: () => ({next: function() { throw new ErrorNext }})
+    });
+    assertThrows(() => Object.assign({}, source), ErrorNext);
+    assertFalse(getterCalled);
+}
+// Exceptions in Iterator directly stop property traversal (2)
+// FIXME: requires [[OwnKeys]] to be an Iterable
+if (false) {
+    let ErrorDone = function ErrorDone() {};
+    let ErrorValue = function ErrorValue() {};
+    let getterCalled = false;
+    let source = new Proxy({
+        get a() { getterCalled = true }
+    }, {
+        getOwnPropertyNames: () => ({
+            next: function() {
+                return {
+                    get done() { throw new ErrorDone },
+                    get value() { throw new ErrorValue },
+                };
+            }
+        })
+    });
+    assertThrows(() => Object.assign({}, source), ErrorDone);
+    assertFalse(getterCalled);
+}
+// Exceptions in Iterator directly stop property traversal (3)
+// FIXME: requires [[OwnKeys]] to be an Iterable
+if (false) {
+    let ErrorValue = function ErrorValue() {};
+    let getterCalled = false;
+    let source = new Proxy({
+        get a() { getterCalled = true }
+    }, {
+        getOwnPropertyNames: () => ({
+            next: function() {
+                return {
+                    get done() { return false },
+                    get value() { throw new ErrorValue },
+                };
+            }
+        })
+    });
+    assertThrows(() => Object.assign({}, source), ErrorValue);
+    assertFalse(getterCalled);
+}
+if (typeof reportCompare == "function")
+    reportCompare(true, true);

-      Line
+  Link Here
-      Line 0
+  Link Here
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+if (typeof version != 'undefined')
+{
+  version(185);
+}
+var assertThrows = assertThrowsInstanceOf;
+function fail(message) {
+    throw new Error(message);
+}
+function IsCallable(o) {
+    return typeof o === "function";
+}
+function IsConstructor(o) {
+    try {
+        new (new Proxy(o, {construct: () => ({})}));
+        return true;
+    } catch(e) {
+        return false;
+    }
+}
+function assertSame(expected, actual) {
+    return assertEq(actual, expected);
+}
+function assertTrue(value) {
+    return assertSame(true, value);
+}
+function assertFalse(value) {
+    return assertSame(false, value);
+}
+function assertNotUndefined(value) {
+    return assertTrue(value !== undefined);
+}
+function assertInstanceOf(constructor, value) {
+    return assertTrue(value instanceof constructor);
+}
+function assertCallable(o) {
+    return assertTrue(IsCallable(o));
+}
+function assertNotConstructor(o) {
+    return assertFalse(IsConstructor(o));
+}
+function assertDataProperty(object, propertyKey, {value:value, writable:writable, enumerable:enumerable, configurable:configurable}) {
+    var desc = Object.getOwnPropertyDescriptor(object, propertyKey);
+    assertNotUndefined(desc);
+    assertTrue('value' in desc);
+    assertSame(value, desc.value);
+    assertSame(writable, desc.writable);
+    assertSame(enumerable, desc.enumerable);
+    assertSame(configurable, desc.configurable);
+}
+function assertAccessorProperty(object, propertyKey, {get:get, set:set, enumerable:enumerable, configurable:configurable}) {
+    var desc = Object.getOwnPropertyDescriptor(object, propertyKey);
+    assertNotUndefined(desc);
+    assertFalse('value' in desc);
+    assertSame(get, desc.get);
+    assertSame(set, desc.set);
+    assertSame(enumerable, desc.enumerable);
+    assertSame(configurable, desc.configurable);
+}
+function assertBuiltinFunction(fun, name, arity) {
+    assertSame("function", typeof fun);
+    assertCallable(fun);
+    // FIXME: Proxy should only have [[Construct]] if target has [[Construct]] (bug 929467)
+    // assertNotConstructor(fun);
+    assertSame(Function.prototype, Object.getPrototypeOf(fun));
+    assertDataProperty(fun, "length", {value: arity, writable: false, enumerable: false, configurable: false});
+    assertDataProperty(fun, "name", {value: name, writable: false, enumerable: false, configurable: false});
+}

Return to bug 937855