[es6] Partially implement Reflect.set.

test/mjsunit/harmony/reflect.js

Index: test/mjsunit/harmony/reflect.js
diff --git a/test/mjsunit/harmony/reflect.js b/test/mjsunit/harmony/reflect.js
index 73d0115db916f3d7041ae3333d7dc9f059e09220..9f12e9ab483b1de1ef2569935a49f51ec5da1e5f 100644
--- a/test/mjsunit/harmony/reflect.js
+++ b/test/mjsunit/harmony/reflect.js
@@ -52,11 +52,15 @@ function prepare(tgt) {
   tgt[4] = 42;
   tgt[sym] = "foo";
   tgt["noconf"] = 43;
+
   Object.defineProperty(tgt, "noconf", {configurable: false});
+  Object.defineProperty(tgt, "nowrite", {writable: false, value: 44});
   Object.defineProperty(tgt, "getter",
     { get: function () {return this.bla}, configurable: true });
   Object.defineProperty(tgt, "setter",
-    { set: function () {}, configurable: true });
+    { set: function (x) {this.gaga = x}, configurable: true });
+  Object.defineProperty(tgt, "setter2",
+    { set: function (x) {}, configurable: true});
 }
 
 
@@ -130,6 +134,136 @@ function prepare(tgt) {
 
 
 ////////////////////////////////////////////////////////////////////////////////
+// Reflect.set
+
+
+(function testReflectSetArity() {
+  assertEquals(3, Reflect.set.length);
+})();
+
+
+(function testReflectSetOnNonObject() {
+  assertThrows(function() { Reflect.set(); }, TypeError);
+  assertThrows(function() { Reflect.set(42, "bla"); }, TypeError);
+  assertThrows(function() { Reflect.set(null, "bla"); }, TypeError);
+})();
+
+
+(function testReflectSetKeyConversion() {
+  var tgt = {};
+  var a = { [Symbol.toPrimitive]: function() { return "bla" } };
+  var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
+  assertTrue(Reflect.set(tgt, a, 42));
+  assertEquals(42, tgt.bla);
+  assertThrows(function() { Reflect.set(tgt, b, 42); }, "gaga");
+})();
+
+
+(function testReflectSetOnObject() {
+  var receiver = {bla: false};
+  var value = 34234;
+  for (let tgt of objects) {
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, "bla", value));
+    assertEquals(value, tgt.bla);
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, "bla", value, tgt));
+    assertEquals(value, tgt.bla);
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, "bla", value, receiver));
+    assertEquals(true, tgt.bla);
+    assertEquals(value, receiver.bla);
+    receiver.bla = false;
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, 4, value));
+    assertEquals(value, tgt[4]);
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, 4, value, tgt));
+    assertEquals(value, tgt[4]);
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, 4, value, receiver));
+    assertEquals(42, tgt[4]);
+    assertEquals(value, receiver[4]);
+    delete receiver[4];
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, sym, value));
+    assertEquals(value, tgt[sym]);
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, sym, value, tgt));
+    assertEquals(value, tgt[sym]);
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, sym, value, receiver));
+    assertEquals("foo", tgt[sym]);
+    assertEquals(value, receiver[sym]);
+    delete receiver[sym];
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, "noconf", value));
+    assertEquals(value, tgt.noconf);
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, "noconf", value, tgt));
+    assertEquals(value, tgt.noconf);
+
+    prepare(tgt);
+    assertTrue(Reflect.set(tgt, "noconf", value, receiver));
+    assertEquals(43, tgt.noconf);
+    assertEquals(value, receiver.noconf);
+    delete receiver.noconf;
+
+    assertTrue(Reflect.set(tgt, "setter", value));
+    assertEquals(value, tgt.gaga)
+    delete tgt.gaga;
+
+    assertTrue(Reflect.set(tgt, "setter", value, tgt));
+    assertEquals(value, tgt.gaga)
+    delete tgt.gaga;
+
+    assertTrue(Reflect.set(tgt, "setter", value, receiver));
+    assertFalse("gaga" in tgt);
+    assertEquals(value, receiver.gaga);
+    delete receiver.gaga;
+
+    assertFalse(Reflect.set(tgt, "nowrite", value));
+    assertEquals(44, tgt.nowrite);
+
+    assertFalse(Reflect.set(tgt, "nowrite", value, tgt));
+    assertEquals(44, tgt.nowrite);
+
+    assertFalse(Reflect.set(tgt, "nowrite", value, receiver));
+    assertEquals(44, tgt.nowrite);
+    assertFalse("nowrite" in receiver);
+
+    assertFalse(Reflect.set({}, "nowrite", value, tgt));
+
+    // Data vs Accessor
+    // TODO(neis): This must return false but currently doesn't.
+    // assertFalse(Reflect.set(tgt, "bla", value, {set bla(x) {}}));
+
+    // Accessor vs Data
+    assertTrue(Reflect.set({set bla(x) {}}), "bla", value, tgt);
+
+    // Data vs Non-Object
+    // TODO(neis): These must return false but currently don't.
+    // assertFalse(Reflect.set({}, "bla", null));

[rossberg, 2015/10/29 16:38:24]

Something is missing here...

+    // assertFalse(Reflect.set({bla: 42}, "bla", null));
+
+    // Accessor vs Non-Object
+    assertTrue(Reflect.set(tgt, "setter2", value, null));
+  }
+})();
+
+
+
+////////////////////////////////////////////////////////////////////////////////
 // Reflect.has